Suriyakumarvijayanayagam
949f78f6d0
- TECH_ARCHITECTURE.md: technical blueprint for the new platform - AI_LAYER_DESIGN_NOTES.md: AI agent, event/action, SQL and audit design - Axpert 11.2 web runtime source, structure exports and release notes (reference) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
8188 lines
357 KiB
C#
8188 lines
357 KiB
C#
#region NameSpaces
|
||
|
||
using Newtonsoft.Json;
|
||
using Newtonsoft.Json.Linq;
|
||
using System;
|
||
using System.Collections;
|
||
using System.Collections.Generic;
|
||
using System.Data;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Text;
|
||
using System.Text.RegularExpressions;
|
||
using System.Web;
|
||
using System.Xml;
|
||
#endregion
|
||
|
||
#region TstructData Class
|
||
/// <summary>
|
||
/// TstructData class stores all the field related data like, field Name,value,oldvalue,componentname
|
||
/// rowno,frameno. Using this fieldvaluexml is constructed and stored in a string.
|
||
/// </summary>
|
||
[Serializable()]
|
||
public class TStructData
|
||
{
|
||
#region Attributes
|
||
/// <summary>
|
||
/// Declaration of all attributes related to Tstruct Data Class
|
||
/// </summary>
|
||
public ArrayList fieldIndexArray = new ArrayList();
|
||
public ArrayList fieldName = new ArrayList();
|
||
public ArrayList fieldFrameNo = new ArrayList();
|
||
public ArrayList fieldControlName = new ArrayList();
|
||
public ArrayList fieldRowNo = new ArrayList();
|
||
public ArrayList fieldValue = new ArrayList();
|
||
public ArrayList fieldOldValue = new ArrayList();
|
||
public ArrayList fieldIdValue = new ArrayList();
|
||
public ArrayList fieldOldIdValue = new ArrayList();
|
||
public ArrayList dcRowCntVals = new ArrayList();
|
||
public ArrayList fieldRowValues = new ArrayList();
|
||
public ArrayList fldIdCol = new ArrayList();
|
||
public ArrayList fldMasterRow = new ArrayList();
|
||
public ArrayList fieldDPMVals = new ArrayList();
|
||
public ArrayList fieldDPVals = new ArrayList();
|
||
public ArrayList ChangedDcs = new ArrayList();
|
||
public ArrayList DelRowFldsXml = new ArrayList();
|
||
public ArrayList newRowNos = new ArrayList();
|
||
public ArrayList oldRowNos = new ArrayList();
|
||
// TODO: Get the attachment files from the client and update the attachment array in the object.
|
||
public ArrayList attachArray = new ArrayList();
|
||
public String fieldValueXml = string.Empty;
|
||
private StringBuilder dsDataXML = new StringBuilder();
|
||
public String fgFieldValueXml = string.Empty;
|
||
public String popFGFieldValueXml = string.Empty;
|
||
public String transactionID = string.Empty;
|
||
public String recordID = string.Empty;
|
||
private string jsonString = string.Empty;
|
||
private string defaultDateStr = "dd/mm/yyyy";
|
||
public ArrayList imageFldNames = new ArrayList();
|
||
public ArrayList imageFldSrc = new ArrayList();
|
||
ArrayList depFormatDcs = new ArrayList();
|
||
public StringBuilder tabJson = new StringBuilder();
|
||
public ArrayList AxMasterRowFlds = new ArrayList();
|
||
public StringBuilder AxDepArrays = new StringBuilder();
|
||
public string project = string.Empty;
|
||
public string user = string.Empty;
|
||
public string AxRole = string.Empty;
|
||
public string sessionid = string.Empty;
|
||
public string errlog = string.Empty;
|
||
public string filename = string.Empty;
|
||
public DataSet dsData;
|
||
public string ires = string.Empty;
|
||
public string serviceInputXml = string.Empty;
|
||
public string result = string.Empty;
|
||
public string axpert = "Axpert\\";
|
||
public string transID = "";
|
||
public string rid = string.Empty;
|
||
private int deletedCount = -1;
|
||
public bool IsDraftObj = false;
|
||
public string AxActDepField = "";
|
||
public string TabDcStatus = string.Empty;
|
||
ArrayList AxSubGridRows = new ArrayList();
|
||
ArrayList AxDelDcNo = new ArrayList();
|
||
ArrayList AxDelRecIds = new ArrayList();
|
||
ArrayList subWsRows = new ArrayList();
|
||
ArrayList subDsRows = new ArrayList();
|
||
public string AxActiveDc = string.Empty;
|
||
public ArrayList removeFiles = new ArrayList();
|
||
//Variables to store the memVars details
|
||
ArrayList memVarNames = new ArrayList();
|
||
ArrayList memVarValues = new ArrayList();
|
||
ArrayList memVarTypes = new ArrayList();
|
||
public string memVarsData = string.Empty;
|
||
bool hasMemVars = false;
|
||
public string strServerTime = string.Empty;
|
||
public double webTime1;
|
||
public double webTime2;
|
||
public double asbTime;
|
||
//public DateTime asbTime2;
|
||
public bool logTimeTaken = false;
|
||
public bool hasImagePath = false;
|
||
string scriptsPath = HttpContext.Current.Application["ScriptsPath"].ToString();
|
||
|
||
public string attachDirPath = "";
|
||
public string imgAttachPath = "";
|
||
|
||
public string AxActiveAction = string.Empty;
|
||
List<string> deletedRowCount = new List<string>();
|
||
bool isDeletedRow = false;
|
||
public ArrayList AxGridAttNotExistList = new ArrayList();
|
||
|
||
[NonSerialized]
|
||
public ASBExt.WebServiceExt objWebServiceExt = new ASBExt.WebServiceExt();
|
||
|
||
LogFile.Log logobj = new LogFile.Log();
|
||
Util.Util util = new Util.Util();
|
||
CacheMgr.CacheManager cm = new CacheMgr.CacheManager("");
|
||
Boolean isDebugFileCreated = false;
|
||
public TStructDef tstStrObj;
|
||
public bool attachDir = false;
|
||
public Dictionary<string, string> fastDDL = new Dictionary<string, string>();
|
||
|
||
int DeleteRowTopNo = 0;
|
||
#endregion
|
||
|
||
#region Attributes with get,set properties.
|
||
/// <summary>
|
||
/// Attributes with get, set properties.
|
||
/// </summary>
|
||
public ArrayList fldNames
|
||
{
|
||
get { return fieldName; }
|
||
set { fieldName = value; }
|
||
}
|
||
|
||
public ArrayList fldFrameNos
|
||
{
|
||
get { return fieldFrameNo; }
|
||
set { fieldFrameNo = value; }
|
||
}
|
||
|
||
public ArrayList fldControlNames
|
||
{
|
||
get { return fieldControlName; }
|
||
set { fieldControlName = value; }
|
||
}
|
||
|
||
public ArrayList fldRowNos
|
||
{
|
||
get { return fieldRowNo; }
|
||
set { fieldRowNo = value; }
|
||
}
|
||
|
||
public ArrayList fldValues
|
||
{
|
||
get { return fieldValue; }
|
||
set { fieldValue = value; }
|
||
}
|
||
|
||
public ArrayList fldOldValues
|
||
{
|
||
get { return fieldOldValue; }
|
||
set { fieldOldValue = value; }
|
||
}
|
||
|
||
public ArrayList fldIdValues
|
||
{
|
||
get { return fieldIdValue; }
|
||
set { fieldIdValue = value; }
|
||
}
|
||
|
||
public ArrayList fldOldIdValues
|
||
{
|
||
get { return fieldOldIdValue; }
|
||
set { fieldOldIdValue = value; }
|
||
}
|
||
|
||
public ArrayList attachments
|
||
{
|
||
get { return attachArray; }
|
||
set { attachArray = value; }
|
||
}
|
||
|
||
public String fldValueXml
|
||
{
|
||
get { return fieldValueXml; }
|
||
set { fieldValueXml = value; }
|
||
}
|
||
|
||
public String fgFldValueXml
|
||
{
|
||
get { return fgFieldValueXml; }
|
||
set { fgFieldValueXml = value; }
|
||
}
|
||
|
||
public String transid
|
||
{
|
||
get { return transactionID; }
|
||
set { transactionID = value; }
|
||
}
|
||
|
||
public String recordid
|
||
{
|
||
get { return recordID; }
|
||
set { recordID = value; }
|
||
}
|
||
|
||
public string newJson
|
||
{
|
||
get { return jsonString; }
|
||
set { jsonString = value; }
|
||
}
|
||
public DataSet dsDataSet
|
||
{
|
||
get { return dsData; }
|
||
set { dsData = value; }
|
||
}
|
||
|
||
public bool isSaveCalled = false;
|
||
public bool isAxpImagePath = false;
|
||
#endregion
|
||
|
||
#region Constructor which parses the jsonData.
|
||
/// <summary>
|
||
/// Constructor which gets the JsonData from the service and updates all the field related information
|
||
/// to the array list by parsing through json data.
|
||
/// </summary>
|
||
/// <param name="jsonData"></param>
|
||
public TStructData(string jsonData, string transId, string recId, TStructDef strObj)
|
||
{
|
||
if (HttpContext.Current.Session["AxLogging"] != null)
|
||
{
|
||
if (Convert.ToString(HttpContext.Current.Session["AxLogging"]).ToLower() == "true")
|
||
logTimeTaken = true;
|
||
}
|
||
|
||
tstStrObj = strObj;
|
||
CreateDataSets(strObj);
|
||
|
||
this.rid = recId;
|
||
transID = transId;
|
||
|
||
if (HttpContext.Current.Session["AxAttachFilePath"] != null)
|
||
attachDirPath = HttpContext.Current.Session["AxAttachFilePath"].ToString();
|
||
|
||
if (HttpContext.Current.Session["AxpAttachmentPathGbl"] != null)
|
||
attachDirPath = HttpContext.Current.Session["AxpAttachmentPathGbl"].ToString();
|
||
|
||
if (attachDirPath != string.Empty)
|
||
attachDir = true;
|
||
|
||
|
||
if (HttpContext.Current.Session["AxImagePath"] != null && HttpContext.Current.Session["AxImagePath"].ToString() != "")
|
||
{
|
||
imgAttachPath = HttpContext.Current.Session["AxImagePath"].ToString();
|
||
//CommonDir directory creation taken back due to application server memory usage.
|
||
//if (!imgAttachPath.Contains(":\\") && !imgAttachPath.StartsWith("\\"))
|
||
//{
|
||
// CreateDirectoryInCommonDir(ref imgAttachPath);
|
||
//}
|
||
}
|
||
if (HttpContext.Current.Session["AxpImagePathGbl"] != null && HttpContext.Current.Session["AxpImagePathGbl"].ToString() != "")
|
||
{
|
||
imgAttachPath = HttpContext.Current.Session["AxpImagePathGbl"].ToString();
|
||
imgAttachPath = imgAttachPath.Replace(";bkslh", "\\");
|
||
}
|
||
if (HttpContext.Current.Session["AxpSaveImageDb"] != null && HttpContext.Current.Session["AxpSaveImageDb"].ToString() == "true")
|
||
imgAttachPath = "";
|
||
|
||
ArrayList imageFlds = new ArrayList();
|
||
ArrayList imageSrc = new ArrayList();
|
||
GetGlobalVars();
|
||
|
||
|
||
jsonData = jsonData.Replace("*$*", "♦");
|
||
jsonData = jsonData.Replace("\\", ";bkslh");
|
||
string[] resval = jsonData.Split('♦');
|
||
StringBuilder dataJson = new StringBuilder();
|
||
|
||
for (int j = 0; j < resval.Length; j++)
|
||
{
|
||
//TODO: all other json nodes should be handled in the json parsing
|
||
JArray Data = null;
|
||
try
|
||
{
|
||
if (resval[j] != "")
|
||
{
|
||
JObject tstData = JObject.Parse(resval[j]);
|
||
Data = (JArray)tstData["data"];
|
||
jsonString = @"{""data"":[";
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("JsonToArray function - " + ex.Message, sessionid, "Exception-" + transid, "new");
|
||
logobj.CreateLog("JsonData - " + jsonData, sessionid, "Exception-" + transid, "");
|
||
|
||
//throw ex;
|
||
}
|
||
|
||
|
||
if (Data != null)
|
||
{
|
||
string fName = string.Empty;
|
||
string fValue = string.Empty;
|
||
string delRows = string.Empty;
|
||
string rowNo = string.Empty;
|
||
string fDatatype = string.Empty;
|
||
string name = string.Empty;
|
||
string fldName = string.Empty;
|
||
string fldFrameNo = string.Empty;
|
||
string frmNum = string.Empty;
|
||
string frowValues = string.Empty;
|
||
string fldIdValues = string.Empty;
|
||
string idCol = string.Empty;
|
||
string masterRow = string.Empty;
|
||
string comboVal = string.Empty;
|
||
string comboIdCol = string.Empty;
|
||
string dcNo = "0";
|
||
string dpmValue = string.Empty;
|
||
string dpValue = string.Empty;
|
||
string idVal = string.Empty;
|
||
string oldIdVal = string.Empty;
|
||
StringBuilder ddlVals = new StringBuilder();
|
||
StringBuilder ddlDpVals = new StringBuilder();
|
||
//TODO: Create a single function for parsing the json result- The same code is used in JsonToArray
|
||
for (int m = 0; m < Data.Count; m++)
|
||
{
|
||
Dictionary<string, string> values = JsonConvert.DeserializeObject<Dictionary<string, string>>(Data[m].ToString());
|
||
|
||
fDatatype = "";
|
||
delRows = "";
|
||
masterRow = string.Empty;
|
||
dpmValue = string.Empty;
|
||
dpValue = string.Empty;
|
||
string dcHasRows = string.Empty;
|
||
|
||
if (values.ContainsKey("t"))
|
||
fDatatype = values["t"];
|
||
if (values.ContainsKey("n"))
|
||
fName = values["n"];
|
||
if (values.ContainsKey("v"))
|
||
fValue = values["v"];
|
||
if (values.ContainsKey("cr"))
|
||
delRows = values["cr"];
|
||
if (values.ContainsKey("mr"))
|
||
masterRow = values["mr"];
|
||
if (values.ContainsKey("idcol"))
|
||
idCol = values["idcol"];
|
||
if (values.ContainsKey("id"))
|
||
idVal = values["id"];
|
||
if (values.ContainsKey("oldid"))
|
||
oldIdVal = values["oldid"];
|
||
if (values.ContainsKey("dpm"))
|
||
dpmValue = values["dpm"];
|
||
if (values.ContainsKey("dp"))
|
||
dpValue = values["dp"];
|
||
if (values.ContainsKey("r"))
|
||
{
|
||
rowNo = values["r"];
|
||
if (rowNo.Length == 1)
|
||
rowNo = "00" + rowNo;
|
||
else if (rowNo.Length == 2)
|
||
rowNo = "0" + rowNo;
|
||
}
|
||
|
||
|
||
|
||
string rowValues = string.Empty;
|
||
|
||
if (fName != string.Empty)
|
||
{
|
||
fValue = fValue.Replace("^^dq", "\"");
|
||
fValue = fValue.Replace(";bkslh", "\\");
|
||
|
||
if (fName.ToLower() == Constants.AXPATTACHMENTPATH && fValue.Trim() != String.Empty)
|
||
{
|
||
attachDirPath = fValue;
|
||
attachDir = true;
|
||
}
|
||
|
||
////TODO: The same code is there in the UpdateDataList, and Jsontoarray
|
||
//if (fName.ToLower() == "axpcurrencydec")
|
||
// CheckAxpCurrDec(fName, fValue);
|
||
|
||
string rowVal = "";
|
||
if (fDatatype == "i")
|
||
{
|
||
//On loading the data, if there is a image field whose image is stored in folders,
|
||
//Add it to the array to call the MoveImage function to move it to the scripts folder.
|
||
string fldId = string.Empty;
|
||
fldId = fName + rowNo + "F" + dcNo;
|
||
if (fName.StartsWith(Constants.IMGPrefix))
|
||
{
|
||
imageFlds.Add(fldId);
|
||
fValue = string.Empty;
|
||
}
|
||
else if (fName.StartsWith(Constants.IMGSRCPrefix))
|
||
{
|
||
imageSrc.Add(fValue);
|
||
}
|
||
}
|
||
else if (fDatatype == "c")
|
||
{
|
||
comboVal = fValue;
|
||
}
|
||
else if (fDatatype == "dv")
|
||
{
|
||
rowVal = fValue;
|
||
if (rowValues == "")
|
||
rowValues = rowVal;
|
||
else
|
||
rowValues += "" + rowVal;
|
||
|
||
string[] temp = rowVal.Split('?');
|
||
if (temp.Length <= 3 && comboVal == string.Empty && temp.Length > 1)
|
||
{
|
||
StringBuilder strVal = new StringBuilder();
|
||
for (int i = 0; i < temp.Length; i++)
|
||
{
|
||
if (temp[i].ToString() != string.Empty)
|
||
strVal.Append(temp[i].ToString());
|
||
}
|
||
if (strVal.ToString().ToLower() == "yesno" || strVal.ToString().ToLower() == "noyes")
|
||
{
|
||
//To set the default value of checkbox in the grid dc to "no".
|
||
fValue = "no";
|
||
}
|
||
}
|
||
}
|
||
else if (fDatatype == "dc")
|
||
{
|
||
string dcRowCount = fName + "~" + fValue;
|
||
dcNo = fName.Substring(2);
|
||
|
||
if (values.ContainsKey("hasdatarows"))
|
||
dcHasRows = values["hasdatarows"];
|
||
|
||
bool isGrid = IsDcGrid(dcNo, strObj);
|
||
|
||
if (isGrid)
|
||
{
|
||
if (dcHasRows != "")
|
||
{
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)strObj.dcs[Convert.ToInt32(dcNo) - 1];
|
||
if (dcHasRows == "yes")
|
||
dc.DCHasDataRows = true;
|
||
else
|
||
dc.DCHasDataRows = false;
|
||
strObj.dcs[Convert.ToInt32(dcNo) - 1] = dc;
|
||
}
|
||
|
||
//This condition is added to maintain the field array for all the dc fields.
|
||
//In case of index calculation if some dc's fields are not there then it throws error.
|
||
if (fValue == "0" && delRows == "")
|
||
{
|
||
fValue = "1";
|
||
delRows = "i1";
|
||
dcRowCount = fName + "~" + fValue;
|
||
}
|
||
}
|
||
UpdateRowCount(fName, dcRowCount);
|
||
}
|
||
|
||
|
||
if (idCol == "no" || idCol == "")
|
||
idCol = "0";
|
||
else
|
||
idCol = "1";
|
||
|
||
if (fDatatype == "c")
|
||
comboIdCol = idCol;
|
||
|
||
if (fDatatype == "dv")
|
||
{
|
||
ddlVals.Append(rowValues);
|
||
ddlVals.Append("♣");
|
||
ddlDpVals.Append(dpValue);
|
||
ddlDpVals.Append("♣");
|
||
DSUpdateRowValues(fName, Convert.ToInt32(rowNo), ddlVals.ToString(), ddlDpVals.ToString(), masterRow, comboIdCol);
|
||
}
|
||
else
|
||
{
|
||
ddlVals = new StringBuilder();
|
||
if (fDatatype != "dc")
|
||
{
|
||
string rowFrmNo = string.Empty;
|
||
if (rowNo != "")
|
||
{
|
||
name = fName + rowNo + "F" + dcNo;
|
||
rowFrmNo = rowFrmNo + "F" + dcNo;
|
||
DSSubmitWithOld(fName, Convert.ToInt32(rowNo), fValue, idVal, oldIdVal);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
CreateFieldValueXml("ALL", "", "LoadData");
|
||
}
|
||
}
|
||
//Loop through the image fields and load the images in the scripts folder
|
||
for (int i = 0; i < strObj.AxImageFields.Count; i++)
|
||
{
|
||
if (imageSrc.Count != 0 && imageSrc.Count >= i)
|
||
{
|
||
if (imageSrc[i].ToString() != "")
|
||
{
|
||
string[] fvalues = imageSrc[i].ToString().Split('~');
|
||
string recordId = fvalues[2].ToString();
|
||
|
||
LoadImageToFolder(strObj.AxImageFields[i].ToString(), recordId);
|
||
}
|
||
}
|
||
else if (recId != "0" && recId != "")
|
||
{
|
||
LoadImageToFolder(strObj.AxImageFields[i].ToString(), recId);
|
||
}
|
||
}
|
||
|
||
//Load the grid attachments in the folder
|
||
if ((recId != "0" && recId != "" && tstStrObj.ContainsGridAttach) || (recId == "0" && tstStrObj.ContainsGridRefer))
|
||
{
|
||
GetGlobalAttachPath();
|
||
LoadGridAttsToFolder(recId, transID);
|
||
}
|
||
|
||
//Call the function which parses thge memvar node and updates the arrays.
|
||
ParseMemVarNode(jsonData, "LoadData");
|
||
}
|
||
|
||
|
||
#endregion
|
||
|
||
#region Methods
|
||
|
||
#region Public Methods
|
||
/// <summary>
|
||
/// This method is invoked by end user to update the list with new fieldnames and fieldvalues.
|
||
/// This method inturn calls other methods for updating the list and construct the new field value xml.
|
||
/// Here there is a assumption that fldArray and fldValueArray are consistent, means both has same number
|
||
/// of rows and maintain the index.
|
||
/// </summary>
|
||
/// <param name="fldArray">
|
||
/// fldArray consists the updated/new component names.
|
||
/// </param>
|
||
/// <param name="fldValueArray">
|
||
/// fldValueArray consists the updated/new component values.
|
||
/// </param>
|
||
/// <param name="deletedArray">
|
||
/// deletedArray is specific to grid fields , it consists the row no. which is deleted and frame no.
|
||
/// the particular dc no. from where the row is deleted.
|
||
/// </param>
|
||
public void GetFieldValueXml(ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList deletedArray, string frameNo, string calledFrom, string condition, string includeDcs)
|
||
{
|
||
//first update the list with the new fldArray.
|
||
UpdateDataList(fldArray, fldDbRowNo, fldValueArray, deletedArray);
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
if (deletedRowCount.Count > 0)
|
||
{
|
||
deleteRowOnSave();
|
||
}
|
||
//Create the xml from the updated list.
|
||
CreateFieldValueXml(condition, includeDcs, calledFrom);
|
||
}
|
||
|
||
public void GetPerfFieldValueXml(ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList deletedArray, string frameNo, string calledFrom, string condition, string includeDcs)
|
||
{
|
||
//first update the list with the new fldArray.
|
||
UpdateDataList(fldArray, fldDbRowNo, fldValueArray, deletedArray);
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// This method is invoked by end user to update the list with new fieldnames and fieldvalues.
|
||
/// This method inturn calls other methods for updating the list and construct the new field value xml.
|
||
/// Here there is a assumption that fldArray and fldValueArray are consistent, means both has same number
|
||
/// of rows and maintain the index.
|
||
/// </summary>
|
||
/// <param name="fldArray">
|
||
/// fldArray consists the updated/new component names.
|
||
/// </param>
|
||
/// <param name="fldValueArray">
|
||
/// fldValueArray consists the updated/new component values.
|
||
/// </param>
|
||
/// <param name="deletedArray">
|
||
/// deletedArray is specific to grid fields , it consists the row no. which is deleted and frame no.
|
||
/// the particular dc no. from where the row is deleted.
|
||
/// </param>
|
||
public void GetPopFieldValueXml(ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList deletedArray, string frameNo, string parDcNo, int parRowNo, string popDcNo, int popRowNo)
|
||
{
|
||
//first update the list with the new fldArray.
|
||
UpdateDataList(fldArray, fldDbRowNo, fldValueArray, deletedArray);
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
|
||
// Create the xml from the updated list.
|
||
CreateFieldValueXml("-1", parDcNo, parRowNo, popDcNo, popRowNo);
|
||
}
|
||
|
||
|
||
public void UpdateAttachments(string attachFiles)
|
||
{
|
||
string[] attach = attachFiles.Split(',');
|
||
|
||
for (int j = 0; j < attach.Length; j++)
|
||
attachArray.Add(attach[j].ToString());
|
||
}
|
||
|
||
private string GetDelRowDataIndex(string axpRecId)
|
||
{
|
||
string delXml = string.Empty;
|
||
for (int j = 0; j < DelRowFldsXml.Count; j++)
|
||
{
|
||
string[] strDelData = DelRowFldsXml[j].ToString().Split('♦');
|
||
if (strDelData[0].ToString() == axpRecId)
|
||
{
|
||
delXml = strDelData[1].ToString();
|
||
break;
|
||
}
|
||
}
|
||
return delXml;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get the deleted row info from the server side deleted rows.
|
||
/// </summary>
|
||
/// <param name="delRows"></param>
|
||
/// <returns></returns>
|
||
private string GetDelRowsInServer(string delRows)
|
||
{
|
||
StringBuilder strDelDcData = new StringBuilder();
|
||
//the delrows will be in the below format
|
||
//dc1-recid1,recid2~dc2-recid1,recid2
|
||
if (delRows != string.Empty)
|
||
{
|
||
string[] delRowStr = delRows.Split('~');
|
||
for (int i = 0; i < delRowStr.Length; i++)
|
||
{
|
||
string[] dcStr = delRowStr[i].ToString().Split('-');
|
||
string recIds = string.Empty;
|
||
bool found = false;
|
||
for (int j = AxDelDcNo.Count - 1; j >= 0; j--)
|
||
{
|
||
if (AxDelDcNo[j].ToString() == dcStr[0])
|
||
{
|
||
found = true;
|
||
recIds = AxDelRecIds[j].ToString();
|
||
AxDelDcNo.RemoveAt(j);
|
||
AxDelRecIds.RemoveAt(j);
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (strDelDcData.ToString() != "")
|
||
strDelDcData.Append("~");
|
||
|
||
if (found)
|
||
strDelDcData.Append(dcStr[0] + "-" + dcStr[1] + "," + recIds);
|
||
else
|
||
strDelDcData.Append(dcStr[0] + "-" + dcStr[1]);
|
||
}
|
||
}
|
||
|
||
for (int k = 0; k < AxDelDcNo.Count; k++)
|
||
{
|
||
if (strDelDcData.ToString() != "")
|
||
strDelDcData.Append("~");
|
||
strDelDcData.Append(AxDelDcNo[k] + "-" + AxDelRecIds[k]);
|
||
}
|
||
|
||
return strDelDcData.ToString();
|
||
}
|
||
|
||
public string GetDelRowsNode(string delRows)
|
||
{
|
||
//delrow format will be dcno~recid1,recid2-dcno~recid1,recid2..
|
||
StringBuilder strRows = new StringBuilder();
|
||
//hook to add deleted rows info from server side
|
||
delRows = GetDelRowsInServer(delRows);
|
||
|
||
string[] delRowStr = delRows.Split('~');
|
||
|
||
if (delRows != "")
|
||
{
|
||
strRows.Append("<delrows>");
|
||
for (int i = 0; i < delRowStr.Length; i++)
|
||
{
|
||
string[] dcStr = delRowStr[i].ToString().Split('-');
|
||
strRows.Append("<" + dcStr[0].ToString() + ">");
|
||
string[] strRecIds = dcStr[1].ToString().Split(',');
|
||
for (int j = 0; j < strRecIds.Length; j++)
|
||
{
|
||
string axp_recId = strRecIds[j].ToString();
|
||
string delXml = GetDelRowDataIndex(axp_recId);
|
||
|
||
if (delXml != "")
|
||
strRows.Append(delXml);
|
||
}
|
||
|
||
strRows.Append("</" + dcStr[0].ToString() + ">");
|
||
}
|
||
strRows.Append("</delrows>");
|
||
}
|
||
return strRows.ToString();
|
||
}
|
||
|
||
private string GetChangedRows(string changedRows)
|
||
{
|
||
StringBuilder strRows = new StringBuilder();
|
||
|
||
string[] chngRowStr = changedRows.Split('~');
|
||
if (changedRows != "")
|
||
{
|
||
strRows.Append("<changedrows>");
|
||
for (int i = 0; i < chngRowStr.Length; i++)
|
||
{
|
||
string[] dcStr = chngRowStr[i].ToString().Split('-');
|
||
|
||
strRows.Append("<" + dcStr[0].ToString() + ">");
|
||
strRows.Append(dcStr[1].ToString());
|
||
strRows.Append("</" + dcStr[0].ToString() + ">");
|
||
}
|
||
strRows.Append("</changedrows>");
|
||
}
|
||
else if (recordID == "0")
|
||
strRows.Append("<changedrows>*</changedrows>");
|
||
return strRows.ToString();
|
||
}
|
||
|
||
private string GetAttachTransid()
|
||
{
|
||
string tidValue = string.Empty;
|
||
int idx = tstStrObj.GetFieldIndex("axp_attachtransid");
|
||
if (idx != -1)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
tidValue = GetFieldValue(fld.fldframeno.ToString(), fld.name);
|
||
}
|
||
else
|
||
{
|
||
tidValue = tstStrObj.transId;
|
||
}
|
||
return tidValue;
|
||
}
|
||
|
||
|
||
|
||
//save attached file into local
|
||
public void SaveAttached(string files, string RecordId)
|
||
{
|
||
//CommonDir directory creation taken back due to application server memory usage.
|
||
//if (!attachDirPath.Contains(":\\") && !attachDirPath.StartsWith("\\"))
|
||
//{
|
||
// CreateDirectoryInCommonDir(ref attachDirPath);
|
||
//}
|
||
|
||
DirectoryInfo srcDir = new DirectoryInfo(scriptsPath + "Axpert\\" + sessionid);
|
||
string tidValue = string.Empty;
|
||
//string schemaName = project;
|
||
tidValue = GetAttachTransid();
|
||
|
||
DirectoryInfo desDir = new DirectoryInfo(attachDirPath + "\\" + tidValue + "\\");
|
||
if (files != string.Empty)
|
||
{
|
||
string[] fnames = files.Split(',');
|
||
string[] sFileName = new string[fnames.Length];
|
||
for (int i = 0; i < fnames.Length; i++)
|
||
sFileName[i] = Directory.GetFiles(scriptsPath + "Axpert\\" + sessionid, fnames[i])[0];
|
||
|
||
string sFileDir = scriptsPath + "Axpert\\" + sessionid;
|
||
string desPath = attachDirPath + "\\" + tidValue + "\\";
|
||
try
|
||
{
|
||
//Save File on disk
|
||
if (!desDir.Exists)
|
||
desDir.Create();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw ex;
|
||
}
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
foreach (var file in sFileName)
|
||
File.Copy(file, Path.Combine(desPath, RecordId + "-" + Path.GetFileName(file)), true);
|
||
}
|
||
}
|
||
//Delete the files from folder
|
||
if (removeFiles.Count > 0 && desDir.Exists)
|
||
{
|
||
for (int i = 0; i < removeFiles.Count; i++)
|
||
{
|
||
try
|
||
{
|
||
foreach (FileInfo fi in desDir.GetFiles(removeFiles[i].ToString().Replace("%20", " ")))
|
||
fi.Delete();
|
||
}
|
||
catch { }
|
||
}
|
||
}
|
||
}
|
||
|
||
protected void RemoveUnwantedAxpFiles(string transid, string recId, string delRows, TStructData tstData, ArrayList deletedFldArrayValues)
|
||
{
|
||
try
|
||
{
|
||
GetGlobalAttachPath();
|
||
ArrayList lstAttFileServer = new ArrayList();
|
||
if (HttpContext.Current.Session["AxpAttFileServer"] != null)
|
||
lstAttFileServer = (ArrayList)HttpContext.Current.Session["AxpAttFileServer"];
|
||
|
||
foreach (var axpFlds in tstStrObj.AxpFileUploadFields)
|
||
{
|
||
if (!axpFlds.ToString().ToLower().StartsWith("axpfilepath_"))
|
||
{
|
||
int idx = tstStrObj.GetFieldIndex(axpFlds.ToString());
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
int axpFldDcNo = fld.fldframeno;
|
||
DataTable oldDcTable = dsDataSet.Tables["deldc" + axpFldDcNo];
|
||
if (oldDcTable != null && oldDcTable.Rows.Count > 0)
|
||
RemoveDeletedRowAxpFiles(oldDcTable, axpFlds.ToString());
|
||
|
||
var axpFld = lstAttFileServer.Cast<string>().Where(i => i.StartsWith(axpFlds + "~")).ToArray();
|
||
if (axpFld.Count() == 0)
|
||
continue;
|
||
else
|
||
{
|
||
// Need to remove saved files from list.
|
||
DataTable dcTable = dsDataSet.Tables["dc" + axpFldDcNo];
|
||
DataView dv = new DataView(dcTable);
|
||
dv.Sort = "axp__rowno ASC";
|
||
dcTable = dv.ToTable();
|
||
string axpGrAttPath = string.Empty;
|
||
for (int j = 0; j < dcTable.Rows.Count; j++)
|
||
{
|
||
string axpValues = string.Empty;
|
||
axpValues = dcTable.Rows[j][axpFlds.ToString()].ToString();
|
||
foreach (var existFiles in axpValues.Split(','))
|
||
{
|
||
var removeValue = lstAttFileServer.Cast<string>().Where(i => i.StartsWith(axpFlds + "~") && i.EndsWith(existFiles)).ToArray();
|
||
if (removeValue.Count() > 0)
|
||
lstAttFileServer.Remove(removeValue[0]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (deletedFldArrayValues.Count > 0)
|
||
{
|
||
foreach (var delFile in deletedFldArrayValues)
|
||
{
|
||
string[] dltfnameval = delFile.ToString().Split('~');
|
||
string dlFName = dltfnameval[0].Substring(0, dltfnameval[0].LastIndexOf("F") - 3);
|
||
string dlRow = dltfnameval[0].Substring(dltfnameval[0].LastIndexOf("F") - 3, 3);
|
||
var dlFullname = lstAttFileServer.Cast<string>().Where(i => i.StartsWith(dlFName + "~") && i.EndsWith(dltfnameval[1])).ToArray();
|
||
// TO delete file from folder and remove from list which are deleted before save the transaction
|
||
if (dlFullname.Count() > 0)
|
||
{
|
||
lstAttFileServer.Remove(dlFullname[0]);
|
||
string dlFullPath = dlFullname[0].Replace(dlFName + "~", "");
|
||
RemoveDeletedAxpFileFromFolder(dlFullPath);
|
||
}
|
||
else
|
||
{
|
||
// To delete file from folder after load transaction and delete files
|
||
var axpfilepath_ = tstStrObj.AxpFileUploadFields.Cast<string>().Where(i => i.ToLower().StartsWith("axpfilepath") && i.EndsWith("_" + dlFName.ToString().Substring(8))).ToArray();
|
||
int idx = tstStrObj.GetFieldIndex(dlFName.ToString());
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
int axpFldDcNo = fld.fldframeno;
|
||
DataTable dcTable = dsDataSet.Tables["dc" + axpFldDcNo];
|
||
bool isDcGrid = false;
|
||
isDcGrid = IsDcGrid(axpFldDcNo.ToString(), tstStrObj);
|
||
int rNo = 0;
|
||
if (isDcGrid)
|
||
rNo = int.Parse(dlRow) - 1;
|
||
else
|
||
rNo = int.Parse(dlRow);
|
||
string axpFPath = string.Empty;
|
||
if (dcTable.Rows.Count > 0)
|
||
axpFPath = dcTable.Rows[rNo][axpfilepath_[0]].ToString();
|
||
if (axpFPath == string.Empty)
|
||
axpFPath = HttpContext.Current.Session["grdAttPath"].ToString();
|
||
if (axpFPath.EndsWith("*"))
|
||
{
|
||
string axpFilePath = axpFPath.Substring(0, axpFPath.LastIndexOf('\\')) + "\\";
|
||
string PrefixFilename = axpFPath.Substring(axpFPath.LastIndexOf("\\") + 1).Replace("*", "");
|
||
string axpFileName = dltfnameval[1];
|
||
if (PrefixFilename != string.Empty)
|
||
axpFileName = PrefixFilename + axpFileName;
|
||
RemoveDeletedAxpFileFromFolder(axpFilePath + axpFileName);
|
||
}
|
||
else
|
||
RemoveDeletedAxpFileFromFolder(axpFPath + dltfnameval[1]);
|
||
}
|
||
}
|
||
}
|
||
if (lstAttFileServer.Count > 0)
|
||
HttpContext.Current.Session["AxpAttFileServer"] = lstAttFileServer;
|
||
else
|
||
HttpContext.Current.Session["AxpAttFileServer"] = null;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("Error while deleting-" + ex.Message, sessionid, "RemoveUnwantedAxpFiles", "new");
|
||
}
|
||
}
|
||
|
||
protected void RemoveDeletedRowAxpFiles(DataTable oldDcTable, string axpFld)
|
||
{
|
||
try
|
||
{
|
||
var axpfilepath_ = tstStrObj.AxpFileUploadFields.Cast<string>().Where(i => i.ToLower().StartsWith("axpfilepath") && i.EndsWith("_" + axpFld.ToString().Substring(8))).ToArray();
|
||
string axpFPath = string.Empty;
|
||
string axpValues = string.Empty;
|
||
for (int j = 0; j < oldDcTable.Rows.Count; j++)
|
||
{
|
||
axpFPath = oldDcTable.Rows[j][axpfilepath_[0]].ToString();
|
||
axpValues = oldDcTable.Rows[j][axpFld].ToString();
|
||
if (axpFPath == string.Empty)
|
||
axpFPath = HttpContext.Current.Session["grdAttPath"].ToString();
|
||
foreach (var existFiles in axpValues.Split(','))
|
||
{
|
||
if (axpFPath.EndsWith("*"))
|
||
{
|
||
string axpFilePath = axpFPath.Substring(0, axpFPath.LastIndexOf('\\')) + "\\";
|
||
string PrefixFilename = axpFPath.Substring(axpFPath.LastIndexOf("\\") + 1).Replace("*", "");
|
||
string existFile = existFiles;
|
||
if (PrefixFilename != string.Empty)
|
||
existFile = PrefixFilename + existFiles;
|
||
RemoveDeletedAxpFileFromFolder(axpFilePath + existFile);
|
||
}
|
||
else
|
||
RemoveDeletedAxpFileFromFolder(axpFPath + existFiles);
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("Error while deleting OldFiles-" + ex.Message, sessionid, "RemoveDeletedRowAxpFiles", "new");
|
||
}
|
||
}
|
||
|
||
protected void RemoveDeletedAxpFileFromFolder(string fullPath)
|
||
{
|
||
try
|
||
{
|
||
File.Delete(fullPath);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("Error while RemoveDeletedAxpFileFromFolder-" + ex.Message, sessionid, "RemoveDeletedAxpFileFromFolder", "new");
|
||
}
|
||
}
|
||
|
||
|
||
public string CallSaveDataWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, ArrayList deletedFldArrayValues, string files, string rid, string delRows, string changedRows)
|
||
{
|
||
|
||
DateTime stTime = DateTime.Now;
|
||
string successMsg = string.Empty;
|
||
string gridAttSaveResult = string.Empty;
|
||
string AxRelKeys = string.Empty;
|
||
bool holdpopup = false;
|
||
if (!string.IsNullOrEmpty(files))
|
||
UpdateAttachments(files);
|
||
string filesCpy = files;
|
||
if (attachDir)
|
||
files = "";
|
||
|
||
|
||
string cngRows = GetChangedRows(changedRows);
|
||
|
||
transid = tstData.transid.ToString();
|
||
filename = "save-" + transid;
|
||
errlog = logobj.CreateLog("Saving Data", sessionid, filename, "new");
|
||
string imagefromdb = "false";
|
||
if (HttpContext.Current.Session["AxpSaveImageDb"] != null)
|
||
imagefromdb = HttpContext.Current.Session["AxpSaveImageDb"].ToString();
|
||
serviceInputXml = "<Transaction axpapp=\"" + project + "\" imagefromdb=\"" + imagefromdb + "\" afiles=\"" + files + "\" trace=\"" + errlog + "\" sessionid=\"" + sessionid + "\" appsessionkey='" + HttpContext.Current.Session["AppSessionKey"].ToString() + "' username='" + HttpContext.Current.Session["username"].ToString() + "'><data transid=\"" + transid + "\" recordid=\"" + rid + "\"> ";
|
||
result = string.Empty;
|
||
logobj.CreateLog("Cross checking field value xml length sent from client and received xml length", sessionid, filename, "");
|
||
//call a function to delete the default row in pop grid
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
isSaveCalled = true;
|
||
tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "true", "ALL", "");
|
||
delRows = GetDelRowsNode(delRows);
|
||
isSaveCalled = false;
|
||
if (tstData.fldValueXml.Contains("docid"))
|
||
{
|
||
holdpopup = true;
|
||
}
|
||
|
||
serviceInputXml += tstData.fldValueXml + memVarsData + "</data>";
|
||
serviceInputXml += delRows + cngRows;
|
||
serviceInputXml += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
serviceInputXml += "</Transaction>";
|
||
logobj.CreateLog("Call to SaveData Web Service", sessionid, filename, "");
|
||
ires = tstStrObj.structRes;
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
DateTime asStart = DateTime.Now;
|
||
result = objWebServiceExt.CallSaveDataWS(transid, serviceInputXml, ires);
|
||
string requestProcess_logtime = result.Split('♠')[0];
|
||
result = result.Split('♠')[1];
|
||
DateTime asEnd = DateTime.Now;
|
||
logobj.CreateLog("End Time : " + DateTime.Now.ToString(), sessionid, filename, "");
|
||
|
||
//{"message":[{"msg":"Master Saved,recordid=20054000000070"}]}
|
||
result = result.Replace("\\", ";bkslh");
|
||
//To save the image fields in server folders,
|
||
//the below code checks if the record is saved and copies the images to the folders.
|
||
if (result.ToLower().Contains("ora-"))
|
||
{
|
||
result = result.Replace("ora-", "");
|
||
result = result.Replace("ORA-", "");
|
||
}
|
||
if (!result.StartsWith(Constants.ERROR))
|
||
{
|
||
string returnStr = result.Replace("*$*", "¿");
|
||
string[] newResult = returnStr.Split('¿');
|
||
for (int i = 0; i < newResult.Length; i++)
|
||
{
|
||
JArray msg, rslt;
|
||
try
|
||
{
|
||
JObject message = JObject.Parse(newResult[i].ToString());
|
||
msg = (JArray)message["message"];
|
||
rslt = (JArray)message["result"];
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw ex;
|
||
}
|
||
if (rslt != null)
|
||
{
|
||
string saveStatus = rslt[0].SelectToken("save").ToString();
|
||
if (saveStatus == "success" && util.isRealTimeCacEnabled(transid, tstStrObj))
|
||
AxRelKeys = util.GetAxRelations(tstData.transid);
|
||
if (saveStatus == "success" && transID == "axstc")
|
||
{
|
||
DataTable dt = tstData.dsDataSet.Tables["dc1"];
|
||
if (dt != null && dt.Rows.Count > 0)
|
||
{
|
||
string props = dt.Rows[0]["PROPS"].ToString();
|
||
if (props.ToLower() == "general")
|
||
util.ClearAxpStructConfigInRedis(Constants.AXCONFIGGENERAL, transID, GetFieldValue("1", "userroles"), "general", "");
|
||
else
|
||
{
|
||
string stype = dt.Rows[0]["STYPE"].ToString();
|
||
string sname = dt.Rows[0]["STRUCTNAME"].ToString();
|
||
if (stype == "Tstruct")
|
||
util.ClearAxpStructConfigInRedis(Constants.AXCONFIGTSTRUCT, transID, GetFieldValue("1", "userroles"), "tstruct", sname);
|
||
if (stype == "Iview")
|
||
{
|
||
util.ClearAxpStructConfigInRedis(Constants.AXCONFIGTSTRUCT, transID, GetFieldValue("1", "userroles"), "iview", sname);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (msg != null)
|
||
{
|
||
string saveResult = msg[0].SelectToken("msg").ToString();
|
||
|
||
if (saveResult.IndexOf(',') != -1)
|
||
{
|
||
string recId = "";
|
||
string[] resultData = saveResult.Split(',');
|
||
if (resultData.Length > 1)
|
||
{
|
||
successMsg = resultData[0];
|
||
if (resultData[resultData.Length - 1].ToString().IndexOf("=") != -1 && resultData[resultData.Length - 1].ToString().IndexOf("recordid") != -1)
|
||
{
|
||
string[] recordDts = resultData[resultData.Length - 1].ToString().Split('=');
|
||
recId = recordDts[1].ToString();
|
||
}
|
||
else if (resultData[resultData.Length - 1].ToString().IndexOf("=") == -1 && Array.FindIndex(resultData, x => x.Trim().Contains("recordid=")) > -1)
|
||
{
|
||
int recIdx = Array.FindIndex(resultData, x => x.Contains("recordid"));
|
||
if (resultData[recIdx].ToString().Contains("="))
|
||
{
|
||
string[] recordDts = resultData[recIdx].ToString().Split('=');
|
||
recId = recordDts[1].ToString();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
continue;
|
||
}
|
||
}
|
||
|
||
if (recId != string.Empty)
|
||
{
|
||
if (tstStrObj.AxpFileUploadFields.Count > 0)
|
||
RemoveUnwantedAxpFiles(transid, recId, delRows, tstData, deletedFldArrayValues);
|
||
|
||
if (tstStrObj.ContainsGridAttach)
|
||
{
|
||
try
|
||
{
|
||
gridAttSaveResult = SaveGridAttachments(transid, sessionid, recId, delRows, tstData, changedRows, deletedFldArrayValues);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("Error while SaveGridAttachments-" + ex.Message, sessionid, "SaveGridAttachments", "new", "true");
|
||
}
|
||
}
|
||
|
||
if (tstStrObj.ContainsImage)
|
||
{
|
||
string authenticationStatus = string.Empty;
|
||
bool isAuthenticated = util.GetAuthentication(ref authenticationStatus);
|
||
SaveImageToFolder(tstStrObj, transid, sessionid, recId, deletedFldArrayValues);
|
||
}
|
||
//Save the attach file into the dir
|
||
if (attachDir && (!string.IsNullOrEmpty(filesCpy) || removeFiles.Count > 0))
|
||
SaveAttached(filesCpy, recId);
|
||
try
|
||
{
|
||
Custom custObj = Custom.Instance;
|
||
custObj.AxAfterAttSave(transid, sessionid, recId);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
|
||
}
|
||
RefFastDataOnSave("save");
|
||
RefInMemOnSave();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (logTimeTaken)
|
||
{
|
||
webTime1 = asStart.Subtract(stTime).TotalMilliseconds;
|
||
webTime2 = DateTime.Now.Subtract(asEnd).TotalMilliseconds;
|
||
asbTime = asEnd.Subtract(asStart).TotalMilliseconds;
|
||
}
|
||
if (AxRelKeys != string.Empty)
|
||
result = result + "*#*" + AxRelKeys;
|
||
if (holdpopup != false)
|
||
{
|
||
result = "{" + "\"holdpopup\"" + ":[{" + "\"hold\"" + ":\" " + holdpopup + "\"}]}" + "*$*" + result;
|
||
}
|
||
if (gridAttSaveResult != string.Empty)
|
||
{
|
||
result = "{" + "\"GridAttachments\"" + ":[{" + "\"Message\"" + ":\" Attachment is not Saved : " + gridAttSaveResult + "\"}]}" + "*$*" + result;
|
||
}
|
||
result = requestProcess_logtime + "♠" + result;
|
||
return result;
|
||
}
|
||
|
||
private void ModifyAsNewRecord()
|
||
{
|
||
if (dsDataSet.Tables.Count > 0)
|
||
{
|
||
for (int i = 1; i <= tstStrObj.dcs.Count; i++)
|
||
{
|
||
DataTable dt = dsDataSet.Tables["dc" + i];
|
||
if (dt.Rows.Count > 0)
|
||
{
|
||
if (((TStructDef.DcStruct)(tstStrObj.dcs[i - 1])).isgrid)
|
||
{
|
||
foreach (DataRow row in dt.Rows)
|
||
{
|
||
row["axp_recid" + i] = "0";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
dt.Rows[0]["axp_recid" + i] = "0";
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
public string CallWorkFlowActionWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string files, string rid, string inputXml)
|
||
{
|
||
if (!string.IsNullOrEmpty(files))
|
||
{
|
||
UpdateAttachments(files);
|
||
}
|
||
//GetGlobalVars();
|
||
transid = tstData.transid.ToString();
|
||
filename = "WorkFlow-" + transid;
|
||
errlog = logobj.CreateLog("Saving Workflow Data", sessionid, filename, "new");
|
||
result = string.Empty;
|
||
logobj.CreateLog("Cross checking field value xml length send from client and received xml length", sessionid, filename, "");
|
||
//call a function to delete the default row in pop grid
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
|
||
tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "true", "ALL", "");
|
||
inputXml += "<data>" + tstData.fldValueXml + "</data>";
|
||
inputXml += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString() + "</root>";
|
||
logobj.CreateLog("Call to WorkFlowAction Web Service", sessionid, filename, "");
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallWorkFlowActionWS(transid, inputXml);
|
||
logobj.CreateLog("End Time : " + DateTime.Now.ToString(), sessionid, filename, "");
|
||
return result;
|
||
}
|
||
|
||
|
||
public string GetErrorInResultJson(string result)
|
||
{
|
||
result = result.Replace("\\", ";bkslh");
|
||
result = result.Replace("^^dq", "\"");
|
||
string returnStr = result.Replace("*$*", "¿");
|
||
string[] newResult = returnStr.Split('¿');
|
||
for (int i = 0; i < newResult.Length; i++)
|
||
{
|
||
JArray msg;
|
||
try
|
||
{
|
||
JObject message = JObject.Parse(newResult[i].ToString());
|
||
msg = (JArray)message["error"];
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw ex;
|
||
}
|
||
|
||
if (msg != null)
|
||
{
|
||
string saveResult = msg[0].SelectToken("msg").ToString();
|
||
saveResult = saveResult.Remove(0, 1);
|
||
saveResult = saveResult.Remove(saveResult.Length - 1, 1);
|
||
return saveResult;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
private string SaveGridAttachments(string transid, string sid, string recId, string delRows, TStructData tstData, string changedRows, ArrayList deletedFldArrayValues)
|
||
{
|
||
GetGlobalAttachPath();
|
||
string saveResult = string.Empty;
|
||
|
||
if (recId != "0")
|
||
{
|
||
string sourceFilePath = scriptsPath + "axpert\\" + sid;
|
||
string destFilePath = string.Empty;
|
||
string grdAttPath = string.Empty;
|
||
bool hasMultipleFiles = false;
|
||
bool isAxpAttachFld = false;
|
||
hasImagePath = false;
|
||
string fldName = string.Empty;
|
||
ArrayList attFldNames = new ArrayList();
|
||
ArrayList attDestPath = new ArrayList();
|
||
ArrayList attFileNames = new ArrayList();
|
||
StringBuilder strFiles = new StringBuilder();
|
||
ArrayList attWantToDelete = new ArrayList();
|
||
//string schemaName = project;
|
||
string attachTid = GetAttachTransid();
|
||
int attTotalFileCount = 0;
|
||
int attDelFileCount = 0;
|
||
int attSavedFileCount = 0;
|
||
ArrayList isRecordFile = new ArrayList();
|
||
//bool isRecordFile = false;
|
||
if (HttpContext.Current.Session["attGridFileServer"] != null && HttpContext.Current.Session["attGridFileServer"].ToString() != string.Empty)
|
||
{
|
||
string attTotalFile = HttpContext.Current.Session["attGridFileServer"].ToString();
|
||
string[] attTotalFiles = attTotalFile.Split('♦');
|
||
attTotalFileCount = attTotalFiles.Length;
|
||
}
|
||
|
||
bool deletedGridFilesExist = false;
|
||
foreach (var attFld in tstStrObj.AxAttachFields)
|
||
{
|
||
int idx = tstStrObj.GetFieldIndex(attFld.ToString());
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
|
||
if ((fld.name.StartsWith("dc") && fld.name.ToLower().EndsWith("_image") || fld.name.StartsWith("axp_gridattach_")) && IsDcGrid(fld.fldframeno.ToString(), tstStrObj))
|
||
{
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[fld.fldframeno - 1];
|
||
fldName = fld.name;
|
||
|
||
//For all attachment fields now the global variables AxpImageServer and AxpImagePath will be used for destination path
|
||
// GetGlobalAttachPath();
|
||
grdAttPath = HttpContext.Current.Session["grdAttPath"].ToString();
|
||
DataTable dcTable = dsDataSet.Tables["dc" + dc.frameno];
|
||
|
||
DataTable dcDelRowTable = dsDataSet.Tables["deldc" + dc.frameno];
|
||
|
||
bool hasDcImagePath = false;
|
||
hasDcImagePath = dcTable.Columns.Contains("dc" + dc.frameno + "_imagepath");
|
||
hasImagePath = hasDcImagePath;
|
||
|
||
if (dc.DCHasDataRows && (grdAttPath != string.Empty || hasDcImagePath == true))
|
||
{
|
||
if (!grdAttPath.EndsWith("\\"))
|
||
grdAttPath = grdAttPath + "\\";
|
||
|
||
string value = string.Empty;
|
||
string destFileName = string.Empty;
|
||
string sfileEx = string.Empty;
|
||
|
||
|
||
bool hasAxpAttachCol = false;
|
||
hasAxpAttachCol = dcTable.Columns.Contains("axp_gridattach_" + dc.frameno);
|
||
bool hasAxpAttFileName = false;
|
||
hasAxpAttFileName = dcTable.Columns.Contains("axpattach_filename" + dc.frameno);
|
||
|
||
DataView dv = new DataView(dcTable);
|
||
dv.Sort = "axp__rowno ASC";
|
||
dcTable = dv.ToTable();
|
||
string axpGrAttPath = string.Empty;
|
||
int delRowCnt = 0;
|
||
for (int j = 0; j < dcTable.Rows.Count; j++)
|
||
{
|
||
//If dc_image is used for referimages, then don't add the referred files for saving, save only newly attached files
|
||
if (!hasAxpAttachCol)
|
||
value = GetFilesforSave(dcTable.Rows[j][fld.name].ToString());
|
||
else
|
||
value = dcTable.Rows[j]["axp_gridattach_" + dc.frameno].ToString();
|
||
|
||
if (value == string.Empty && (changedRows != string.Empty || delRows == string.Empty) && !hasDcImagePath && !hasAxpAttachCol && (fld.name.StartsWith("dc" + dc.frameno + "_image")))
|
||
{
|
||
try
|
||
{
|
||
DataTable oldDcTable = dsDataSet.Tables["dc_old" + dc.frameno];
|
||
if (dsDataSet.Tables["dc_old" + dc.frameno].Rows[0]["old__" + fld.name].ToString() != string.Empty)
|
||
{
|
||
deletedGridFilesExist = true;
|
||
}
|
||
}
|
||
catch (Exception ex) { }
|
||
}
|
||
|
||
if (value.Contains(","))
|
||
hasMultipleFiles = true;
|
||
|
||
if (value == string.Empty && HttpContext.Current.Session["attGridFileServer"] != null && HttpContext.Current.Session["attGridFileServer"].ToString() != string.Empty)
|
||
{
|
||
string attServerFiles = HttpContext.Current.Session["attGridFileServer"].ToString();
|
||
string[] lstServerFiles = attServerFiles.Split('♦');
|
||
int irow = j + 1;
|
||
var lstServerFile = lstServerFiles.AsEnumerable().Where(x => x.StartsWith(fldName + irow + "~") && x.Contains(HttpContext.Current.Session["username"].ToString() + "-")).ToList();
|
||
string authenticationStatus = string.Empty;
|
||
if (lstServerFile.Count > 0 && util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
foreach (var lst in lstServerFile)
|
||
{
|
||
string savedFileName = lst.Split('~')[1];
|
||
File.Delete(savedFileName);
|
||
attDelFileCount++;
|
||
HttpContext.Current.Session["attGridFileServer"] = attServerFiles = attServerFiles.Replace(lst + "♦", "").Replace(lst, "");
|
||
}
|
||
}
|
||
}
|
||
|
||
if (value != string.Empty || deletedGridFilesExist)
|
||
{
|
||
//If axp_gridattach
|
||
if (hasAxpAttachCol)
|
||
{
|
||
if (hasAxpAttFileName && !hasMultipleFiles)
|
||
{
|
||
sfileEx = value.Substring(value.LastIndexOf("."));
|
||
destFileName = dcTable.Rows[j]["axpattach_filename" + dc.frameno].ToString() + sfileEx;
|
||
}
|
||
isAxpAttachFld = true;
|
||
//destFilePath = grdAttPath + schemaName + "\\" + attachTid + "\\" + recId + "\\" + fld.name;
|
||
destFilePath = grdAttPath + "\\" + attachTid + "\\" + recId + "\\" + fld.name;
|
||
}
|
||
else if (fld.name.StartsWith("dc") && fld.name.ToLower().EndsWith("_image") && !hasDcImagePath)
|
||
{
|
||
//destFilePath = grdAttPath + schemaName + "\\" + attachTid + "\\" + fld.name;
|
||
destFilePath = grdAttPath + "\\" + attachTid + "\\" + fld.name;
|
||
}
|
||
else if (hasDcImagePath && !hasAxpAttachCol)
|
||
{
|
||
if (dcTable.Rows[j]["dc" + +dc.frameno + "_imagepath"].ToString() != string.Empty)
|
||
{
|
||
hasImagePath = true;
|
||
grdAttPath = GetdcImagePath(dcTable.Rows[j]["dc" + +dc.frameno + "_imagepath"].ToString());
|
||
destFilePath = grdAttPath;
|
||
}
|
||
else
|
||
{
|
||
string errorLog = string.Empty;
|
||
string errMessage = "Value for dc_imagepath field is not specified";
|
||
errorLog = logobj.CreateLog("Error in Saving Grid attachments - " + errMessage, sid, "GridAttachments", "new");
|
||
saveResult = errMessage;
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
if ((value != string.Empty || deletedGridFilesExist) && destFilePath != string.Empty)
|
||
{
|
||
try
|
||
{
|
||
DirectoryInfo di = new DirectoryInfo(destFilePath);
|
||
if (!di.Exists)
|
||
di.Create();
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
saveResult = "Destination Path is empty";
|
||
}
|
||
if (destFileName != "") value = destFileName;
|
||
string[] fileNames = value.Split(',');
|
||
//These arrays will be used to delete the deleted attachments
|
||
attFldNames.Add(fldName);
|
||
if (attDestPath.Count > 0)
|
||
{
|
||
if (attDestPath.IndexOf(destFilePath) == -1)
|
||
{
|
||
attDestPath.Add(destFilePath);
|
||
if (hasImagePath || hasAxpAttachCol)
|
||
isRecordFile.Add("false");
|
||
else
|
||
isRecordFile.Add("true");
|
||
}
|
||
}
|
||
else
|
||
{
|
||
attDestPath.Add(destFilePath);
|
||
if (hasImagePath || hasAxpAttachCol)
|
||
isRecordFile.Add("false");
|
||
else
|
||
isRecordFile.Add("true");
|
||
}
|
||
|
||
for (int fIdx = 0; fIdx < fileNames.Length; fIdx++)
|
||
{
|
||
if (HttpContext.Current.Session["attGridFileServer"] != null && HttpContext.Current.Session["attGridFileServer"].ToString() != string.Empty)
|
||
{
|
||
int irow = j + delRowCnt + 1;
|
||
if (dcDelRowTable != null && dcDelRowTable.Rows.Count > 0)
|
||
{
|
||
int iDelrow = j + 1;
|
||
var delRowList = dcDelRowTable.AsEnumerable().Where(s => s.Field<string>("axp__delrow") == iDelrow.ToString()).Select(s => s.Field<string>("axp__delrow")).ToList();
|
||
if (delRowList != null && delRowList.Count > 0)
|
||
{
|
||
string attServerFiless = HttpContext.Current.Session["attGridFileServer"].ToString();
|
||
string[] lstServerFiless = attServerFiless.Split('♦');
|
||
var lstMatchFiles = lstServerFiless.AsEnumerable().Where(x => x.StartsWith(fldName + irow + "~") && x.Contains(HttpContext.Current.Session["username"].ToString() + "-")).ToList();
|
||
delRowCnt = delRowCnt + 1;
|
||
irow = irow + 1;
|
||
foreach (var lst in lstMatchFiles)
|
||
{
|
||
string savedFileName = lst.Split('\\').Last();
|
||
string attdestFilePath = string.Empty;
|
||
attdestFilePath = destFilePath + "\\" + savedFileName;
|
||
// File.Delete(attdestFilePath);
|
||
attWantToDelete.Add(attdestFilePath);
|
||
HttpContext.Current.Session["attGridFileServer"] = attServerFiless.Replace(lst + "♦", "").Replace(lst, "");
|
||
}
|
||
}
|
||
}
|
||
string attServerFiles = HttpContext.Current.Session["attGridFileServer"].ToString();
|
||
string[] lstServerFiles = attServerFiles.Split('♦');
|
||
|
||
|
||
var lstServerFile = lstServerFiles.AsEnumerable().Where(x => x.StartsWith(fldName + irow + "~") && x.Contains(HttpContext.Current.Session["username"].ToString() + "-")).ToList();
|
||
string authenticationStatus = string.Empty;
|
||
if (lstServerFile.Count > 0 && util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
foreach (var lst in lstServerFile)
|
||
{
|
||
string savedFileName = lst.Split('\\').Last();// lst.Split('~')[1];
|
||
string attdestFilePath = string.Empty;
|
||
attdestFilePath = destFilePath + "\\" + savedFileName;
|
||
string atFileName = savedFileName.Replace(HttpContext.Current.Session["username"].ToString() + "-", "");
|
||
var saveFileLst = fileNames.AsEnumerable().Where(x => x == atFileName).ToList();
|
||
if (saveFileLst.Count > 0)
|
||
{
|
||
if (fileNames[fIdx] == atFileName)
|
||
{
|
||
if (hasAxpAttachCol)
|
||
{
|
||
string renameFilePath = grdAttPath + attachTid + "\\" + HttpContext.Current.Session["username"].ToString() + "\\" + fld.name;
|
||
axpGrAttPath = grdAttPath + attachTid + "\\" + HttpContext.Current.Session["username"].ToString();
|
||
if (File.Exists(renameFilePath + "\\" + savedFileName))
|
||
Microsoft.VisualBasic.FileIO.FileSystem.RenameFile(renameFilePath + "\\" + savedFileName, atFileName);
|
||
renameFilePath = renameFilePath + "\\" + atFileName;
|
||
destFilePath = destFilePath + "\\" + atFileName;
|
||
File.Move(@renameFilePath, @destFilePath);
|
||
attSavedFileCount++;
|
||
if (strFiles.ToString() == string.Empty)
|
||
strFiles.Append(atFileName);
|
||
else
|
||
strFiles.Append("," + atFileName);
|
||
|
||
}
|
||
else if (hasImagePath)
|
||
{
|
||
File.Delete(destFilePath + "\\" + atFileName);
|
||
Microsoft.VisualBasic.FileIO.FileSystem.RenameFile(attdestFilePath, atFileName);
|
||
if (strFiles.ToString() == string.Empty)
|
||
strFiles.Append(atFileName);
|
||
else
|
||
strFiles.Append("," + atFileName);
|
||
attSavedFileCount++;
|
||
}
|
||
else
|
||
{
|
||
File.Delete(destFilePath + "\\" + recId + "-" + atFileName);
|
||
Microsoft.VisualBasic.FileIO.FileSystem.RenameFile(attdestFilePath, recId + "-" + atFileName);
|
||
if (strFiles.ToString() == string.Empty)
|
||
strFiles.Append(recId + "-" + atFileName);
|
||
else
|
||
strFiles.Append("," + recId + "-" + atFileName);
|
||
attSavedFileCount++;
|
||
}
|
||
HttpContext.Current.Session["attGridFileServer"] = attServerFiles = attServerFiles.Replace(lst + "♦", "").Replace(lst, "");
|
||
}
|
||
else
|
||
{
|
||
if (hasImagePath || hasAxpAttachCol)
|
||
{
|
||
if (strFiles.ToString() == string.Empty)
|
||
strFiles.Append(fileNames[fIdx]);
|
||
else
|
||
strFiles.Append("," + fileNames[fIdx]);
|
||
}
|
||
else
|
||
{
|
||
if (strFiles.ToString() == string.Empty)
|
||
strFiles.Append(recId + "-" + fileNames[fIdx]);
|
||
else
|
||
strFiles.Append("," + recId + "-" + fileNames[fIdx]);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (hasImagePath || hasAxpAttachCol)
|
||
{
|
||
if (strFiles.ToString() == string.Empty)
|
||
strFiles.Append(fileNames[fIdx]);
|
||
else
|
||
strFiles.Append("," + fileNames[fIdx]);
|
||
}
|
||
else
|
||
{
|
||
if (strFiles.ToString() == string.Empty)
|
||
strFiles.Append(recId + "-" + fileNames[fIdx]);
|
||
else
|
||
strFiles.Append("," + recId + "-" + fileNames[fIdx]);
|
||
}
|
||
attDelFileCount++;
|
||
File.Delete(attdestFilePath);
|
||
HttpContext.Current.Session["attGridFileServer"] = attServerFiles = attServerFiles.Replace(lst + "♦", "").Replace(lst, "");
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
string fNames = fileNames[fIdx].ToString();
|
||
if (fNames == "") continue;
|
||
if (!hasDcImagePath && !hasAxpAttachCol)
|
||
fNames = recId + "-" + fileNames[fIdx].ToString();
|
||
if (strFiles.ToString() == string.Empty)
|
||
strFiles.Append(fNames);
|
||
else
|
||
strFiles.Append("," + fNames);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
string fName = fileNames[fIdx].ToString();
|
||
if (fName == "") continue;
|
||
if (!hasDcImagePath && !hasAxpAttachCol)
|
||
fName = recId + "-" + fileNames[fIdx].ToString();
|
||
if (strFiles.ToString() == string.Empty)
|
||
strFiles.Append(fName);
|
||
else
|
||
strFiles.Append("," + fName);
|
||
|
||
CopyFiles(sourceFilePath, destFilePath, fileNames[fIdx], fName);
|
||
}
|
||
}
|
||
}
|
||
if (axpGrAttPath != string.Empty && Directory.Exists(axpGrAttPath))
|
||
{
|
||
try
|
||
{
|
||
Directory.Delete(axpGrAttPath, true);
|
||
}
|
||
catch { }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
string attDelPath = "";
|
||
if (attWantToDelete.Count > 0)//Delete and add same file in another row
|
||
{
|
||
attDelFileCount += attWantToDelete.Count;
|
||
foreach (string wtdFile in attWantToDelete)
|
||
{
|
||
string attFName = wtdFile.Split('\\').Last();
|
||
attDelPath = wtdFile;
|
||
attDelPath = attDelPath.Replace("\\" + attFName, "");
|
||
try
|
||
{
|
||
File.Delete(wtdFile);
|
||
}
|
||
catch (Exception ex) { }
|
||
}
|
||
}
|
||
|
||
|
||
if (changedRows != string.Empty || delRows != string.Empty)//Delete any file or load record and delete file
|
||
{
|
||
int delFcnt = DeleteGridAttachments(delRows, recId, grdAttPath, transid, isAxpAttachFld, fldName, attFldNames, attDestPath, strFiles, isRecordFile);
|
||
//attDelPath = attDelPath == "" ? attDestPath[0].ToString() : attDelPath;
|
||
if (attDelPath == "" && attDestPath.Count > 0)
|
||
attDelPath = attDestPath[0].ToString();
|
||
if (delFcnt != 0)
|
||
attDelFileCount += delFcnt;
|
||
}
|
||
if (attDelPath != "" && attDelFileCount != 0)
|
||
{
|
||
AttDelLogFile(attDelPath, recId, attTotalFileCount, attSavedFileCount, attDelFileCount);
|
||
}
|
||
|
||
}
|
||
return saveResult;
|
||
}
|
||
|
||
private void AttDelLogFile(string attDelPath, string strRecId, int attTotalFileCount, int attSavedFileCount, int attDelFileCount)
|
||
{
|
||
// Total uploaded files: , Saved files: and deleted files :
|
||
// Log file recid-attdetails.txt
|
||
try
|
||
{
|
||
if (attDelPath != "")
|
||
{
|
||
//attTotalFileCount
|
||
//string attFName = attDelPath.Split('\\').Last();
|
||
//attDelPath = attDelPath.Replace("\\" + attFName, "");
|
||
attDelPath = attDelPath + "\\Temp";
|
||
DirectoryInfo diDel = new DirectoryInfo(attDelPath);
|
||
if (!diDel.Exists)
|
||
diDel.Create();
|
||
string attFPath = diDel + "\\" + strRecId + "-attdetails.txt";
|
||
StreamWriter sw = default(StreamWriter);
|
||
if (File.Exists(attFPath))
|
||
{
|
||
sw = new StreamWriter(attFPath, true);
|
||
sw.WriteLine("********** {0} **********", DateTime.Now.ToString());
|
||
sw.Flush();
|
||
sw.Close();
|
||
sw = new StreamWriter(attFPath, true);
|
||
}
|
||
else
|
||
{
|
||
sw = new StreamWriter(attFPath, false);
|
||
sw.WriteLine("********** {0} **********", DateTime.Now.ToString());
|
||
sw.Flush();
|
||
sw.Close();
|
||
sw = new StreamWriter(attFPath, true);
|
||
}
|
||
string text = "Total uploaded files:" + attTotalFileCount + " , saved files:" + attSavedFileCount + " and deleted files :" + attDelFileCount;
|
||
sw.WriteLine(text);
|
||
sw.Flush();
|
||
sw.Close();
|
||
}
|
||
}
|
||
catch (Exception exs) { }
|
||
}
|
||
|
||
public string GetFilesforSave(string referredFiles)
|
||
{
|
||
string nonReferredFiles = referredFiles;
|
||
return nonReferredFiles;
|
||
|
||
string[] refFiles = referredFiles.Split(')');
|
||
|
||
if (refFiles.Length > 1 && refFiles[1] != string.Empty)
|
||
nonReferredFiles = refFiles[1];
|
||
else if (refFiles.Length > 1 && refFiles[1] == string.Empty)
|
||
nonReferredFiles = string.Empty;
|
||
|
||
return nonReferredFiles;
|
||
}
|
||
//Get dc_imagepath field value
|
||
public string GetdcImagePath(string dcImagePath)
|
||
{
|
||
string grdAttPath = GetImgServerPath();
|
||
|
||
if (dcImagePath != string.Empty && dcImagePath.Contains(":"))
|
||
{
|
||
grdAttPath = dcImagePath;
|
||
}
|
||
else if (grdAttPath != string.Empty)
|
||
{
|
||
grdAttPath = grdAttPath + "\\" + dcImagePath;
|
||
|
||
}
|
||
else if (dcImagePath == string.Empty)
|
||
{
|
||
string errorLog = string.Empty;
|
||
string errMessage = "Value for dc_imagepath field is not specified";
|
||
errorLog = logobj.CreateLog("Error in loading Grid attachments - " + errMessage, sessionid, "GridAttachments", "new");
|
||
grdAttPath = string.Empty;
|
||
}
|
||
|
||
return grdAttPath;
|
||
}
|
||
|
||
public void GetGlobalAttachPath()
|
||
{
|
||
bool isLocalFolder = false, isOnlyFolder = false;
|
||
bool isRemoteFolder = false;
|
||
string imagePath = string.Empty;
|
||
string imageServer = string.Empty;
|
||
string grdAttPath = string.Empty;
|
||
string errorMessage = string.Empty;
|
||
string mapUsername = string.Empty;
|
||
string mapPassword = string.Empty;
|
||
|
||
if (HttpContext.Current.Session["AxpImageServerGbl"] != null)
|
||
{
|
||
imageServer = HttpContext.Current.Session["AxpImageServerGbl"].ToString();
|
||
imageServer = imageServer.Replace(";bkslh", @"\");
|
||
}
|
||
if (HttpContext.Current.Session["AxpImagePathGbl"] != null)
|
||
{
|
||
imagePath = HttpContext.Current.Session["AxpImagePathGbl"].ToString();
|
||
imagePath = imagePath.Replace(";bkslh", @"\");
|
||
|
||
if (imagePath.IndexOf(":") > -1)
|
||
isLocalFolder = true;
|
||
else
|
||
if (imagePath.IndexOf(@"\") > -1)
|
||
isRemoteFolder = true;
|
||
else
|
||
isOnlyFolder = true;
|
||
}
|
||
|
||
if (imagePath != string.Empty)
|
||
{
|
||
if (isLocalFolder || isRemoteFolder)
|
||
grdAttPath = imagePath;
|
||
else
|
||
grdAttPath = imageServer + @"\" + imagePath;
|
||
}
|
||
else if (imageServer != string.Empty)
|
||
{
|
||
grdAttPath = imageServer;
|
||
}
|
||
else
|
||
//If the global variables AxpimageServer and AxpImagePath is not defined
|
||
{
|
||
|
||
if (HttpContext.Current.Session["AxGridAttachPath"] != null)
|
||
{
|
||
grdAttPath = HttpContext.Current.Session["AxGridAttachPath"].ToString();
|
||
//CommonDir directory creation taken back due to application server memory usage.
|
||
//if (!grdAttPath.Contains(":\\"))
|
||
//{
|
||
// // ftp server path
|
||
// if (!grdAttPath.Contains("\\\\"))
|
||
// {
|
||
// grdAttPath = AppDomain.CurrentDomain.BaseDirectory + "CommonDir\\" + grdAttPath;
|
||
// if (!Directory.Exists(grdAttPath))
|
||
// {
|
||
// Directory.CreateDirectory(grdAttPath);
|
||
// }
|
||
// }
|
||
//}
|
||
}
|
||
}
|
||
HttpContext.Current.Session["grdAttPath"] = grdAttPath;
|
||
}
|
||
|
||
private int DeleteGridAttachments(string delRows, string recId, string grdAttPath, string transId, bool isAxpAttachFld, string fld, ArrayList attFldNames, ArrayList attDestPath, StringBuilder attFileNames, ArrayList isRecordFile)
|
||
{
|
||
int DelfCnt = 0;
|
||
try
|
||
{
|
||
for (int i = 0; i < attDestPath.Count; i++)
|
||
{
|
||
//abc.txt,xyz.txt,
|
||
string isRecFile = isRecordFile[i].ToString();
|
||
string attFiles = attFileNames.ToString() + ",";
|
||
DirectoryInfo di = new DirectoryInfo(attDestPath[i].ToString());
|
||
if (di.Exists)
|
||
{
|
||
FileInfo[] files = isRecFile == "true" ? di.GetFiles(recId + "-*") : di.GetFiles();
|
||
for (int j = 0; j < files.Length; j++)
|
||
{
|
||
FileInfo file = (FileInfo)files[j];
|
||
string strFileName = file.Name + ",";
|
||
if (attFiles.IndexOf(strFileName) == -1 && (file.Name).IndexOf(recId) != -1)
|
||
{
|
||
file.Delete();
|
||
DelfCnt++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("Error while deleting-" + ex.Message, sessionid, "DeleteGridAttachments", "new");
|
||
}
|
||
return DelfCnt;
|
||
}
|
||
|
||
//For deleting nongrid attachment files from file server
|
||
private void DeleteNonGridAttachments(string recId, string grdAttPath, string transId, string fieldName, ArrayList attFldNames, ArrayList nonGridAttDestPath, StringBuilder attFileNames)
|
||
{
|
||
try
|
||
{
|
||
for (int i = 0; i < nonGridAttDestPath.Count; i++)
|
||
{
|
||
//abc.txt,xyz.txt,
|
||
string attFiles = attFileNames.ToString() + ",";
|
||
DirectoryInfo di = new DirectoryInfo(nonGridAttDestPath[i].ToString());
|
||
if (di.Exists)
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
for (int j = 0; j < files.Length; j++)
|
||
{
|
||
FileInfo file = (FileInfo)files[j];
|
||
string strFileName = file.Name + ",";
|
||
if (attFiles.IndexOf(strFileName) == -1 && (file.Name).IndexOf(recId) != -1)
|
||
file.Delete();
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("Error while deleting-" + ex.Message, sessionid, "DeleteGridAttachments", "new");
|
||
}
|
||
}
|
||
|
||
//Function to save the image in the server folder if the image starts with fld_ddo
|
||
private void SaveImageToFolder(TStructDef strObj, string transid, string sid, string recId, ArrayList deletedFldArrayValues)
|
||
{
|
||
|
||
bool deletedGridFilesExist = false;
|
||
|
||
if (recId != "0")
|
||
{
|
||
|
||
foreach (var imgFld in tstStrObj.AxImageFields)
|
||
{
|
||
int idx = tstStrObj.GetFieldIndex(imgFld.ToString());
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)strObj.flds[idx];
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[fld.fldframeno - 1];
|
||
DataTable dcTable = dsDataSet.Tables["dc" + dc.frameno];
|
||
|
||
if (fld.fieldIsImage)
|
||
{
|
||
if (!IsDcGrid(fld.fldframeno.ToString(), strObj))
|
||
{
|
||
|
||
string value = string.Empty, destValue = string.Empty;
|
||
ArrayList nonGridAttDestPath = new ArrayList();
|
||
ArrayList attFldNames = new ArrayList();
|
||
StringBuilder nonGrdStrFiles = new StringBuilder();
|
||
destValue = value = GetFieldValue(fld.fldframeno.ToString(), fld.name);
|
||
if (value == string.Empty && (fld.name.StartsWith("dc" + fld.fldframeno + "_image") || fld.name.StartsWith("axp_nga_")))
|
||
{
|
||
try
|
||
{
|
||
DataTable oldDcTable = dsDataSet.Tables["dc_old" + fld.fldframeno];
|
||
if (dsDataSet.Tables["dc_old" + fld.fldframeno].Rows[0]["old__" + fld.name].ToString() != string.Empty)
|
||
{
|
||
deletedGridFilesExist = true;
|
||
}
|
||
}
|
||
catch (Exception ex) { }
|
||
}
|
||
if (value != string.Empty || deletedGridFilesExist)
|
||
{
|
||
|
||
string fieldName = fld.name;//fieldControlName[index].ToString();
|
||
string strFile = "";
|
||
if (!(fieldName.StartsWith("axp_nga_")))
|
||
{
|
||
strFile = scriptsPath + "axpert\\" + sid + "\\" + fieldName;
|
||
if (!File.Exists(strFile + "\\" + value))
|
||
{
|
||
string strFileNew = scriptsPath + "axpert\\" + sid;
|
||
if (File.Exists(strFileNew + "\\" + value))
|
||
strFile = strFileNew;
|
||
}
|
||
|
||
string strDest = "";
|
||
if (imgAttachPath != "")
|
||
{
|
||
string imgName = destValue.Substring(0, destValue.LastIndexOf('.'));
|
||
destValue = destValue.Replace(imgName, recId);
|
||
//strDest = imgAttachPath + "\\axpert\\" + transid + "\\" + recId + "\\" + fieldName;
|
||
strDest = imgAttachPath + "\\" + transid + "\\" + fieldName;
|
||
}
|
||
else
|
||
{
|
||
//strDest = scriptsPath + "axpert\\" + transid + "\\" + recId + "\\" + fieldName;
|
||
strDest = scriptsPath + "axpert\\" + transid + "\\" + fieldName;
|
||
}
|
||
|
||
//loop to check if multiple images exist for same field, if yes then delete all.
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
DirectoryInfo di = new DirectoryInfo(strDest);
|
||
if (!di.Exists)
|
||
{
|
||
di.Create();
|
||
}
|
||
else if (imgAttachPath == "")
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
for (int j = 0; j < files.Length; j++)
|
||
{
|
||
FileInfo file = (FileInfo)files[j];
|
||
file.Delete();
|
||
}
|
||
}
|
||
else if (imgAttachPath != "")
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
if (files.Length > 0)
|
||
{
|
||
var ImgExist = files.Where(x => x.Name.Split('.')[0] == recId).ToList();
|
||
if (ImgExist.Count > 0)
|
||
{
|
||
foreach (var lstImg in ImgExist)
|
||
{
|
||
FileInfo file = (FileInfo)lstImg;
|
||
file.Delete();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (value != string.Empty || deletedGridFilesExist)
|
||
{
|
||
CopyFiles(strFile, strDest, value, destValue);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
|
||
//strFile = scriptsPath + "axpert\\" + sid + "\\" + fieldName;
|
||
strFile = scriptsPath + "axpert\\" + sid;
|
||
if (!File.Exists(strFile + "\\" + value))
|
||
{
|
||
string strFileNew = scriptsPath + "axpert\\" + sid;
|
||
if (File.Exists(strFileNew + "\\" + value))
|
||
strFile = strFileNew;
|
||
}
|
||
|
||
string strDest = "";
|
||
if (imgAttachPath != "" && !(deletedGridFilesExist))
|
||
{
|
||
string imgName = destValue.Substring(0, destValue.LastIndexOf('.'));
|
||
destValue = destValue.Replace(imgName, recId);
|
||
//strDest = imgAttachPath + "\\axpert\\" + transid + "\\" + recId + "\\" + fieldName;
|
||
strDest = imgAttachPath + "\\" + transid + "\\" + fieldName;
|
||
}
|
||
else if (!deletedGridFilesExist)
|
||
{
|
||
//strDest = scriptsPath + "axpert\\" + transid + "\\" + recId + "\\" + fieldName;
|
||
strDest = scriptsPath + "axpert\\" + transid + "\\" + fieldName;
|
||
}
|
||
else
|
||
{
|
||
strDest = imgAttachPath + "\\" + transid + "\\" + fieldName;
|
||
}
|
||
|
||
//loop to check if multiple images exist for same field, if yes then delete all.
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
DirectoryInfo di = new DirectoryInfo(strDest);
|
||
if (!di.Exists)
|
||
{
|
||
di.Create();
|
||
}
|
||
else if (imgAttachPath == "")
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
for (int j = 0; j < files.Length; j++)
|
||
{
|
||
FileInfo file = (FileInfo)files[j];
|
||
file.Delete();
|
||
}
|
||
}
|
||
else if (imgAttachPath != "")
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
if (files.Length > 0)
|
||
{
|
||
var ImgExist = files.Where(x => x.Name.Split('.')[0] == recId).ToList();
|
||
if (ImgExist.Count > 0)
|
||
{
|
||
foreach (var lstImg in ImgExist)
|
||
{
|
||
FileInfo file = (FileInfo)lstImg;
|
||
file.Delete();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (value != string.Empty || deletedGridFilesExist)
|
||
{
|
||
string[] fileNames = value.Split(',');
|
||
nonGridAttDestPath.Add(strDest);
|
||
attFldNames.Add(fieldName);
|
||
for (int fIdx = 0; fIdx < fileNames.Length; fIdx++)
|
||
{
|
||
string fName = fileNames[fIdx].ToString();
|
||
if (fName == "") continue;
|
||
fName = recId + "-" + fileNames[fIdx].ToString();
|
||
CopyFiles(strFile, strDest, fileNames[fIdx], fName);
|
||
if (nonGrdStrFiles.ToString() == string.Empty)
|
||
nonGrdStrFiles.Append(fName);
|
||
else
|
||
nonGrdStrFiles.Append("," + fName);
|
||
}
|
||
}
|
||
}
|
||
|
||
DeleteNonGridAttachments(recId, imgAttachPath, transid, fieldName, attFldNames, nonGridAttDestPath, nonGrdStrFiles);
|
||
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get a non grid field's value.
|
||
/// </summary>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="fldName"></param>
|
||
/// <returns></returns>
|
||
public string GetFieldValue(string dcNo, string fldName)
|
||
{
|
||
string fldValue = string.Empty;
|
||
DataTable dcTable = dsDataSet.Tables["dc" + dcNo];
|
||
if (dcTable.Rows.Count > 0)
|
||
{
|
||
try
|
||
{
|
||
fldValue = dcTable.Rows[0][fldName].ToString();
|
||
}
|
||
catch (Exception ex)
|
||
{ }
|
||
}
|
||
return fldValue;
|
||
}
|
||
|
||
public string DeleteImages(TStructData tstData, string recId, string fieldName)
|
||
{
|
||
string res = "";
|
||
transid = tstData.transid.ToString();
|
||
fieldName = fieldName.Substring(0, fieldName.LastIndexOf("F") - 3);
|
||
int index = fldNames.IndexOf(fieldName);
|
||
string fldFrameNo = GetFrameNo(fieldName);
|
||
string value = GetFieldValue(fldFrameNo, fieldName);
|
||
|
||
string strFile = "";
|
||
strFile = scriptsPath + "axpert\\" + sessionid;
|
||
|
||
string strDest = "", strDestNew = "";
|
||
if (imgAttachPath != "")
|
||
{
|
||
strDest = imgAttachPath + "\\axpert\\" + transid + "\\" + fldNames[index].ToString();
|
||
strDestNew = imgAttachPath + "\\" + transid + "\\" + fldNames[index].ToString();
|
||
}
|
||
else
|
||
{
|
||
strDest = scriptsPath + "axpert\\" + sessionid + "\\" + fldNames[index].ToString();
|
||
}
|
||
|
||
//loop to check if multiple images exist for same field, if yes then delete all.
|
||
DirectoryInfo di = new DirectoryInfo(strDestNew);
|
||
try
|
||
{
|
||
if (di.Exists)
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
for (int j = 0; j < files.Length; j++)
|
||
{
|
||
FileInfo file = (FileInfo)files[j];
|
||
string[] fileStr = file.Name.Split('-');
|
||
if (fileStr[0].ToString() == recId)
|
||
{
|
||
file.Delete();
|
||
}
|
||
}
|
||
}
|
||
DirectoryInfo diNew = new DirectoryInfo(strDest);
|
||
if (diNew.Exists)
|
||
{
|
||
FileInfo[] files = diNew.GetFiles();
|
||
for (int j = 0; j < files.Length; j++)
|
||
{
|
||
FileInfo file = (FileInfo)files[j];
|
||
string[] fileStr = file.Name.Split('-');
|
||
if (fileStr[0].ToString() == recId)
|
||
{
|
||
file.Delete();
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
res = ex.Message;
|
||
}
|
||
|
||
return res;
|
||
}
|
||
|
||
//Function to copy the image from the given source path to the destination path.
|
||
private void CopyFiles(string sourcePath, string destPath, string srcFileName, string desFileName)
|
||
{
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
DirectoryInfo sPath = new DirectoryInfo(sourcePath);
|
||
DirectoryInfo dPath = new DirectoryInfo(destPath);
|
||
|
||
if (!dPath.Exists)
|
||
dPath.Create();
|
||
|
||
if (sPath.Exists)
|
||
{
|
||
BinaryReader brReader = default(BinaryReader);
|
||
BinaryWriter brWriter = default(BinaryWriter);
|
||
|
||
string strFile = sourcePath + "\\" + srcFileName;
|
||
string strDest = destPath + "\\" + desFileName;
|
||
FileStream input = null;
|
||
try
|
||
{
|
||
input = new FileStream(strFile, FileMode.Open, FileAccess.Read);
|
||
}
|
||
catch (FileNotFoundException ex)
|
||
{
|
||
|
||
}
|
||
if (input != null)
|
||
{
|
||
FileStream output = new FileStream(strDest, FileMode.Create, FileAccess.Write);
|
||
brReader = new System.IO.BinaryReader(input);
|
||
brWriter = new System.IO.BinaryWriter(output);
|
||
int bufsize = 30000;
|
||
// this is buffer size
|
||
int readcount = 0;
|
||
int bsize = 0;
|
||
|
||
int indexer = 0;
|
||
FileInfo fileInfo = new FileInfo(strFile);
|
||
|
||
int FileLen = Convert.ToInt32(fileInfo.Length);
|
||
while ((readcount < FileLen))
|
||
{
|
||
if (bufsize < FileLen - readcount)
|
||
{
|
||
bsize = bufsize;
|
||
}
|
||
else
|
||
{
|
||
bsize = FileLen - readcount;
|
||
}
|
||
byte[] buffer = new byte[bsize];
|
||
|
||
brReader.Read(buffer, indexer, bsize);
|
||
brWriter.Write(buffer, indexer, bsize);
|
||
|
||
readcount = readcount + bsize;
|
||
}
|
||
|
||
brReader.Close();
|
||
brWriter.Close();
|
||
brReader.Dispose();
|
||
brWriter.Dispose();
|
||
output.Dispose();
|
||
input.Dispose();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
#region GridAttachments
|
||
public void LoadGridAttsToFolder(string recId, string tid)
|
||
{
|
||
string destFilePath = scriptsPath + "axpert\\" + HttpContext.Current.Session["nsessionid"];
|
||
string srcFilePath = string.Empty;
|
||
string srcpathValue = string.Empty;
|
||
string grdAttPath = string.Empty;
|
||
//string schemaName = project;
|
||
grdAttPath = HttpContext.Current.Session["grdAttPath"].ToString();
|
||
string attachTid = GetAttachTransid();
|
||
|
||
ArrayList attFileNames = new ArrayList();
|
||
bool hasGridAttachFld = false;
|
||
foreach (var attFld in tstStrObj.AxAttachFields)
|
||
{
|
||
int idx = tstStrObj.GetFieldIndex(attFld.ToString());
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
|
||
if ((fld.name.StartsWith("dc") && fld.name.ToLower().EndsWith("_imagepath")) && IsDcGrid(fld.fldframeno.ToString(), tstStrObj))
|
||
hasImagePath = true;
|
||
|
||
//If dc_referimages is defined for referring Attachments
|
||
if ((fld.name.StartsWith("dc") && fld.name.ToLower().EndsWith("_referimages")) && IsDcGrid(fld.fldframeno.ToString(), tstStrObj))
|
||
{
|
||
TStructDef.DcStruct dc1 = (TStructDef.DcStruct)tstStrObj.dcs[fld.fldframeno - 1];
|
||
|
||
DataTable dcTable1 = dsDataSet.Tables["dc" + dc1.frameno];
|
||
|
||
string refVal1 = string.Empty;
|
||
for (int k = 0; k < dcTable1.Rows.Count; k++)
|
||
{
|
||
if (string.IsNullOrEmpty(Convert.ToString(dcTable1.Rows[k]["dc" + dc1.frameno + "_referimages"])))
|
||
refVal1 = dcTable1.Rows[k]["dc" + dc1.frameno + "_referimages"].ToString();
|
||
GetReferedFiles(refVal1, hasImagePath);
|
||
}
|
||
|
||
}
|
||
if (((fld.name.StartsWith("axp_gridattach_")) || (fld.name.StartsWith("dc") && fld.name.ToLower().EndsWith("_image"))) && !(fld.name.StartsWith("axp_nga_")) && IsDcGrid(fld.fldframeno.ToString(), tstStrObj))
|
||
{
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[fld.fldframeno - 1];
|
||
if (dc.DCHasDataRows)
|
||
{
|
||
if (!(fld.name.StartsWith("axp_gridattach_")))
|
||
srcFilePath = grdAttPath + "\\" + attachTid + "\\" + fld.name;
|
||
//srcFilePath = grdAttPath + "\\" + schemaName + "\\" + attachTid + "\\" + fld.name;
|
||
else
|
||
{
|
||
hasGridAttachFld = true;
|
||
srcFilePath = grdAttPath + "\\" + attachTid + "\\" + recId + "\\" + fld.name;
|
||
//srcFilePath = grdAttPath + "\\" + schemaName + "\\" + attachTid + "\\" + recId + "\\" + fld.name;
|
||
}
|
||
|
||
string value = string.Empty;
|
||
DataTable dcTable = dsDataSet.Tables["dc" + dc.frameno];
|
||
string sfileEx = string.Empty;
|
||
|
||
for (int j = 0; j < dcTable.Rows.Count; j++)
|
||
{
|
||
attFileNames.Clear();
|
||
value = dcTable.Rows[j][fld.name].ToString();
|
||
string[] attFiles;
|
||
if (value != "")
|
||
sfileEx = value.Substring(value.LastIndexOf("."));
|
||
//If axpattach_filename is defined
|
||
if (dcTable.Columns.Contains("axpattach_filename" + dc.frameno))
|
||
{
|
||
if (value != string.Empty)
|
||
if (dcTable.Rows[j]["axpattach_filename" + dc.frameno].ToString() != string.Empty)
|
||
value = dcTable.Rows[j]["axpattach_filename" + dc.frameno].ToString() + sfileEx;
|
||
}
|
||
//If dc_imagepath is defined
|
||
if (dcTable.Columns.Contains("dc" + dc.frameno + "_imagepath"))
|
||
{
|
||
srcFilePath = GetdcImagePath(dcTable.Rows[j]["dc" + dc.frameno + "_imagepath"].ToString());
|
||
|
||
}
|
||
//If dc_image field is referring attachments
|
||
if (value.Contains("@"))
|
||
{
|
||
GetReferedFiles(value, hasImagePath);
|
||
}
|
||
if (value.Contains(","))
|
||
{
|
||
attFiles = value.Split(',');
|
||
for (int attCount = 0; attCount < attFiles.Length; attCount++)
|
||
attFileNames.Add(recId + "-" + attFiles[attCount]);
|
||
}
|
||
else
|
||
attFileNames.Add(recId + "-" + value);
|
||
|
||
LoadFilefromFolder(srcFilePath, destFilePath, attFileNames, recId);
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
//If no DataRows are there, and the Tstruct is referring attachments through dc_image field
|
||
if (fld.name.StartsWith("dc") && fld.name.ToLower().EndsWith("_image"))
|
||
{
|
||
DataTable dcTableRef = dsDataSet.Tables["dc" + dc.frameno];
|
||
for (int j = 0; j < dcTableRef.Rows.Count; j++)
|
||
{
|
||
string dcrefVal1 = dcTableRef.Rows[j]["dc" + dc.frameno + "_image"].ToString();
|
||
if (dcrefVal1.Contains("@"))
|
||
{
|
||
GetReferedFiles(dcrefVal1, hasImagePath);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (fld.name.StartsWith("axp_nga_"))
|
||
{
|
||
sessionid = HttpContext.Current.Session["nsessionid"].ToString();
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[fld.fldframeno - 1];
|
||
DataTable dcTable = dsDataSet.Tables["dc" + dc.frameno];
|
||
if (dcTable != null && dcTable.Rows.Count > 0)
|
||
{
|
||
string value = dcTable.Rows[0][fld.name].ToString();
|
||
string[] attFiles;
|
||
attFileNames.Clear();
|
||
if (value.Contains(","))
|
||
{
|
||
attFiles = value.Split(',');
|
||
for (int attCount = 0; attCount < attFiles.Length; attCount++)
|
||
attFileNames.Add(recId + "-" + attFiles[attCount]);
|
||
}
|
||
else
|
||
attFileNames.Add(recId + "-" + value);
|
||
string scrPath = scriptsPath + "axpert\\" + sessionid;
|
||
string desFilePath = "", desFilePathOld = "";
|
||
if (imgAttachPath != "")
|
||
{
|
||
desFilePathOld = imgAttachPath + "\\axpert\\" + transID + "\\" + recId + "\\" + fld.name;
|
||
desFilePath = imgAttachPath + "\\" + transID + "\\" + fld.name;
|
||
}
|
||
else
|
||
{
|
||
desFilePath = scriptsPath + "axpert\\" + transID + "\\" + fld.name;
|
||
}
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
DirectoryInfo di = new DirectoryInfo(desFilePath);
|
||
if (!di.Exists)
|
||
di.Create();
|
||
|
||
FileInfo[] fileEntries = di.GetFiles();
|
||
//TODO: since the loop is breaking after the first loop, the i need not be incremented
|
||
for (int k = 0; k < fileEntries.Length; k++)
|
||
{
|
||
FileInfo file = (FileInfo)fileEntries[k];
|
||
string imgName = file.Name.Substring(0, 13);
|
||
if (imgName == recId)
|
||
{
|
||
string destValue = file.Name.Replace(imgName, recId);
|
||
if (File.Exists(desFilePath + "\\" + destValue))
|
||
{
|
||
imageFldSrc.Add(scrPath + "axpert\\" + sessionid + "\\" + destValue);
|
||
LoadFilefromFolder(desFilePath, scrPath, attFileNames, recId);
|
||
}
|
||
else
|
||
{
|
||
DirectoryInfo diOld = new DirectoryInfo(desFilePathOld);
|
||
if (diOld.Exists)
|
||
{
|
||
FileInfo[] fileEntriesOld = diOld.GetFiles();
|
||
//TODO: since the loop is breaking after the first loop, the i need not be incremented
|
||
for (int j = 0; j < fileEntriesOld.Length; j++)
|
||
{
|
||
FileInfo fileOld = (FileInfo)fileEntriesOld[j];
|
||
imageFldSrc.Add(scrPath + "axpert\\" + sessionid + "\\" + fileOld.Name);
|
||
LoadFilefromFolder(desFilePath, scrPath, attFileNames, recId);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private string GetImgServerPath()
|
||
{
|
||
|
||
string grdAttPath = string.Empty;
|
||
string imageServer = string.Empty;
|
||
|
||
if (HttpContext.Current.Session["AxpImageServerGbl"] != null)
|
||
{
|
||
imageServer = HttpContext.Current.Session["AxpImageServerGbl"].ToString();
|
||
imageServer = imageServer.Replace(";bkslh", @"\");
|
||
}
|
||
|
||
return imageServer;
|
||
}
|
||
private void LoadFilefromFolder(string fPath, string destFilePath, ArrayList attFileNames, string recId)
|
||
{
|
||
if (fPath != string.Empty)
|
||
{
|
||
DirectoryInfo di = new DirectoryInfo(fPath);
|
||
if (!di.Exists)
|
||
di.Create();
|
||
foreach (string fileName in attFileNames)
|
||
{
|
||
bool isFileCopied = false;
|
||
FileInfo[] fileEntries = di.GetFiles(fileName);
|
||
if (fileEntries != null && fileEntries.Length > 0)
|
||
{
|
||
FileInfo file = (FileInfo)fileEntries[0];
|
||
string[] fileVal = file.Name.Split(new[] { '-' }, 2);
|
||
|
||
if (attFileNames.IndexOf(file.Name) != -1 && fileVal.Length > 1)
|
||
{
|
||
CopyFiles(fPath, destFilePath, file.Name, fileVal[1].ToString());
|
||
}
|
||
else
|
||
CopyFiles(fPath, destFilePath, file.Name, file.Name);
|
||
isFileCopied = true;
|
||
}
|
||
else
|
||
{
|
||
string[] fileVal = fileName.Split(new[] { '-' }, 2);
|
||
string worFlname = string.Empty;
|
||
if (fileVal.Length > 1 && fileVal[0] == recId)
|
||
worFlname = fileVal[1].ToString();
|
||
else
|
||
worFlname = fileName;
|
||
FileInfo[] fileEntrie = di.GetFiles(worFlname);
|
||
if (fileEntrie != null && fileEntrie.Length > 0)
|
||
{
|
||
FileInfo file = (FileInfo)fileEntrie[0];
|
||
CopyFiles(fPath, destFilePath, file.Name, file.Name);
|
||
isFileCopied = true;
|
||
}
|
||
}
|
||
if (isFileCopied == false)
|
||
{
|
||
string[] fileVal = fileName.Split(new[] { '-' }, 2);
|
||
string neFlname = string.Empty;
|
||
if (fileVal.Length > 1 && fileVal[0] == recId)
|
||
neFlname = fileVal[1].ToString();
|
||
else
|
||
neFlname = fileName;
|
||
AxGridAttNotExistList.Add(neFlname);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
private void GetReferedFiles(string dcfldValue, bool hasImagePath)
|
||
{
|
||
string destPath = scriptsPath + "axpert\\" + HttpContext.Current.Session["nsessionid"];
|
||
string fldValue = string.Empty;
|
||
string folderPath = string.Empty;
|
||
string destFname = string.Empty;
|
||
string grdAttPath = string.Empty;
|
||
string referRecid = string.Empty;
|
||
string referfNames = string.Empty;
|
||
string[] referfNameOnebyOne;
|
||
try
|
||
{
|
||
string[] fldValues = dcfldValue.Split('@');
|
||
if (hasImagePath)
|
||
{
|
||
grdAttPath = GetImgServerPath();
|
||
for (int i = 0; i < fldValues.Length; i++)
|
||
{
|
||
//Eg:{@India\BLR\license.txt,release.txt}
|
||
|
||
if (fldValues[i] != string.Empty)
|
||
{
|
||
string[] fValues = fldValues[i].Split('(');
|
||
for (int indx = 0; indx < fValues.Length; indx++)
|
||
{
|
||
if (fValues[indx].ToString() != String.Empty)
|
||
{
|
||
string[] fvalue = fValues[indx].Split(',');
|
||
}
|
||
}
|
||
folderPath = fldValues[i].Substring(0, fldValues[i].LastIndexOf("\\"));
|
||
referfNames = fldValues[i].Substring(fldValues[i].LastIndexOf("\\") + 1);
|
||
if (hasImagePath)
|
||
grdAttPath = grdAttPath + "\\" + folderPath;
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
//Eg : {@MyDocs\transid\fieldname,recordid(filename1,f2,f3)}
|
||
|
||
grdAttPath = HttpContext.Current.Session["grdAttPath"].ToString();
|
||
|
||
fldValue = dcfldValue.Substring(1, dcfldValue.Length - 1);
|
||
fldValues = fldValue.Split(new[] { ',' }, 2);
|
||
if (fldValues.Length > 1)
|
||
{
|
||
grdAttPath += "\\" + fldValues[0].ToString();
|
||
int nFileSIndex = fldValues[1].IndexOf("(");
|
||
int nFileEIndex = fldValues[1].IndexOf(")") - 1;
|
||
|
||
referfNames = fldValues[1].Substring(nFileSIndex + 1, nFileEIndex - nFileSIndex);
|
||
referRecid = fldValues[1].Substring(0, nFileSIndex);
|
||
}
|
||
|
||
}
|
||
//Copying Files to Session folder
|
||
referfNameOnebyOne = referfNames.Split(',');
|
||
for (int k = 0; k < referfNameOnebyOne.Length; k++)
|
||
{
|
||
if (referfNameOnebyOne[k] != "")
|
||
if (hasImagePath)
|
||
CopyFiles(grdAttPath, destPath, referfNameOnebyOne[k], referfNameOnebyOne[k]);
|
||
else
|
||
{
|
||
destFname = referRecid + "-" + referfNameOnebyOne[k];
|
||
CopyFiles(grdAttPath, destPath, destFname, destFname);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
//Function to check all images for the given record id and copy them to scripts folder.
|
||
private void LoadImageToFolder(string fldName, string recId)
|
||
{
|
||
string tmpFldName = fldName;//.Substring(0, fldName.LastIndexOf("F") - 3);
|
||
if (recId != "0")
|
||
{
|
||
sessionid = HttpContext.Current.Session["nsessionid"].ToString();
|
||
//scriptsPath += "axpert\\" + sessionid + "\\" + fldName;
|
||
string scrPath = scriptsPath + "axpert\\" + sessionid + "\\" + fldName;
|
||
string desFilePath = "", desFilePathOld = "";
|
||
if (imgAttachPath != "")
|
||
{
|
||
desFilePathOld = imgAttachPath + "\\axpert\\" + transID + "\\" + recId + "\\" + fldName;
|
||
desFilePath = imgAttachPath + "\\" + transID + "\\" + fldName;
|
||
}
|
||
else
|
||
{
|
||
desFilePath = scriptsPath + "axpert\\" + transID + "\\" + fldName;
|
||
//desFilePath = scriptsPath + "axpert\\" + transID + "\\" + recId + "\\" + fldName;
|
||
}
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
DirectoryInfo di = new DirectoryInfo(desFilePath);
|
||
if (!di.Exists)
|
||
di.Create();
|
||
|
||
FileInfo[] fileEntries = di.GetFiles();
|
||
//TODO: since the loop is breaking after the first loop, the i need not be incremented
|
||
for (int i = 0; i < fileEntries.Length; i++)
|
||
{
|
||
FileInfo file = (FileInfo)fileEntries[i];
|
||
//imageFldNames.Add(fldName);
|
||
string imgName = file.Name.Substring(0, file.Name.LastIndexOf('.'));
|
||
if (imgName == recId)
|
||
{
|
||
imageFldNames.Add(fldName);
|
||
string destValue = file.Name.Replace(imgName, recId);
|
||
if (File.Exists(desFilePath + "\\" + destValue))
|
||
{
|
||
imageFldSrc.Add(scriptsPath + "axpert\\" + sessionid + "\\" + destValue);
|
||
CopyFiles(desFilePath, scrPath, destValue, destValue);
|
||
}
|
||
else
|
||
{
|
||
DirectoryInfo diOld = new DirectoryInfo(desFilePathOld);
|
||
if (diOld.Exists)
|
||
{
|
||
FileInfo[] fileEntriesOld = diOld.GetFiles();
|
||
//TODO: since the loop is breaking after the first loop, the i need not be incremented
|
||
for (int j = 0; j < fileEntriesOld.Length; j++)
|
||
{
|
||
FileInfo fileOld = (FileInfo)fileEntriesOld[j];
|
||
imageFldNames.Add(fldName);
|
||
imageFldSrc.Add(scriptsPath + "axpert\\" + sessionid + "\\" + fileOld.Name);
|
||
CopyFiles(desFilePathOld, scrPath, fileOld.Name, fileOld.Name);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//Get the row numbers for the given dc no from the field array
|
||
private ArrayList GetGridRowsFromArray(string frmNo)
|
||
{
|
||
ArrayList gridRows = new ArrayList();
|
||
for (int k = 0; k < fieldControlName.Count; k++)
|
||
{
|
||
int fIndx = 0;
|
||
fIndx = fieldControlName[k].ToString().LastIndexOf("F");
|
||
string frameNo = fieldControlName[k].ToString().Substring(fIndx + 1);
|
||
string rowNo = fieldControlName[k].ToString().Substring(fIndx - 3, 3);
|
||
if (frameNo == frmNo)
|
||
{
|
||
int index = -1;
|
||
index = gridRows.IndexOf(rowNo);
|
||
if (index == -1)
|
||
gridRows.Add(rowNo);
|
||
}
|
||
}
|
||
return gridRows;
|
||
}
|
||
|
||
//Function to get the concatenated string of parent field values in the pop grid dc.
|
||
private string GetParentValues(string[] popParentFlds, string rowNo, string frmNo)
|
||
{
|
||
return DSGetParentValues(popParentFlds, rowNo, frmNo);
|
||
}
|
||
|
||
//Function to get the concatenated string of parent field values in the pop grid dc.
|
||
private string DSGetParentValues(string[] popParentFlds, string rowNo, string frmNo)
|
||
{
|
||
string parFldVals = "";
|
||
for (int j = 0; j < popParentFlds.Length; j++)
|
||
{
|
||
double fldNumber;
|
||
string popFielsName = "sub" + frmNo + "_" + popParentFlds[j].Trim();
|
||
string popFldValue = string.Empty;
|
||
if (DSGetRow(rowNo, Convert.ToInt32(frmNo)).Table.Columns.Contains(popFielsName))
|
||
popFldValue = DSGetRow(rowNo, Convert.ToInt32(frmNo))[popFielsName].ToString();
|
||
else
|
||
{
|
||
popFielsName = "Sub" + frmNo + "_" + popParentFlds[j].Trim();
|
||
popFldValue = DSGetRow(rowNo, Convert.ToInt32(frmNo))[popFielsName].ToString();
|
||
}
|
||
|
||
bool isNumber = double.TryParse(popFldValue, out fldNumber);
|
||
if (isNumber == true)
|
||
{
|
||
double popVal = double.Parse(popFldValue);
|
||
parFldVals += popVal.ToString();
|
||
}
|
||
else
|
||
{
|
||
parFldVals += popFldValue;
|
||
}
|
||
}
|
||
return parFldVals;
|
||
}
|
||
|
||
public DataRow DSGetRow(string rowNo, int dcNo)
|
||
{
|
||
if (dcNo == 0) return null;
|
||
DataTable dt = dsDataSet.Tables["dc" + dcNo];
|
||
int rNo = Convert.ToInt32(rowNo);
|
||
if (rNo == 0) rNo = 1;
|
||
return dt.Rows.Find(rNo);
|
||
}
|
||
|
||
public DataRow DsGetRow(string fldName, string rowNo)
|
||
{
|
||
return DSGetRow(rowNo, tstStrObj.GetFieldDc(fldName));
|
||
}
|
||
|
||
|
||
public void GetKeyColValues(int dcNo, ArrayList arrKeyCols, ArrayList keyRowNos)
|
||
{
|
||
DSGetKeyColValues(dcNo, arrKeyCols, keyRowNos);
|
||
}
|
||
|
||
private void DSGetKeyColValues(int dcNo, ArrayList arrKeyCols, ArrayList arrKeyRowNos)
|
||
{
|
||
DataTable dt = dsDataSet.Tables["dc" + dcNo];
|
||
foreach (DataRow dr in dt.Rows)
|
||
{
|
||
string keyValue = string.Empty;
|
||
string keyRow = string.Empty;
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[dcNo - 1];
|
||
keyValue = dr[dc.KeyColumn].ToString();
|
||
keyRow = dr["axp__rowno"].ToString();
|
||
int keyIndex = arrKeyCols.IndexOf(keyValue);
|
||
if (keyIndex == -1)
|
||
{
|
||
arrKeyCols.Add(keyValue);
|
||
arrKeyRowNos.Add(keyRow);
|
||
}
|
||
else
|
||
{
|
||
arrKeyRowNos[keyIndex] += "," + keyRow;
|
||
}
|
||
}
|
||
}
|
||
|
||
private int GetFldArrayIndex(string fieldName)
|
||
{
|
||
int index = -1;
|
||
for (int cnt = 0; cnt < fieldControlName.Count; cnt++)
|
||
{
|
||
if (fieldControlName[cnt].ToString().ToLower() == fieldName.ToLower())
|
||
index = cnt;
|
||
}
|
||
return index;
|
||
}
|
||
|
||
private void DeleteDefaultRowInPopDc(string project, string user, string transid, string sessionId, string AxRole)
|
||
{
|
||
|
||
ArrayList deleteRows = new ArrayList();
|
||
bool isRowFound = false;
|
||
for (int i = 0; i < tstStrObj.popdcs.Count; i++)
|
||
{
|
||
TStructDef.PopDcStruct popDc = (TStructDef.PopDcStruct)tstStrObj.popdcs[i];
|
||
string[] popParentFlds = popDc.pfields.Split(',');
|
||
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[popDc.frameno - 1];
|
||
|
||
if (popDc.pFirm == "t" || !dc.DCHasDataRows)
|
||
continue;
|
||
|
||
int rowCount = GetDcRowCount(dc.frameno.ToString());
|
||
for (int k = 1; k < rowCount; k++)
|
||
{
|
||
for (int j = 0; j < popParentFlds.Length; j++)
|
||
{
|
||
string prefix = "sub";
|
||
string popFielsName = prefix + popDc.frameno + "_" + popParentFlds[j].Trim() + GetRowNoHelper(k.ToString()) + "F" + popDc.frameno;
|
||
//int idx = GetFldIndex(dc.frameno, "sub" + popDc.frameno + "_" + popParentFlds[j].Trim(), k;
|
||
DataRow dr = DsGetRow(prefix + popDc.frameno + "_" + popParentFlds[j].Trim(), k.ToString());
|
||
if (dr == null)
|
||
{
|
||
prefix = "Sub";
|
||
DsGetRow(prefix + popDc.frameno + "_" + popParentFlds[j].Trim(), k.ToString());
|
||
|
||
}
|
||
if (dr != null)
|
||
{
|
||
string fldValue = dr[prefix + popDc.frameno + "_" + popParentFlds[j].Trim()].ToString();
|
||
|
||
if (fldValue == "" || fldValue == "***")
|
||
{
|
||
string rowNo = k.ToString();
|
||
if (rowNo != "-1")
|
||
deleteRows.Add(rowNo + "F" + popDc.frameno);
|
||
isRowFound = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (isRowFound)
|
||
{
|
||
isRowFound = false;
|
||
break;
|
||
}
|
||
|
||
}
|
||
for (int dCnt = 0; dCnt < deleteRows.Count; dCnt++)
|
||
{
|
||
int fIdx = deleteRows[dCnt].ToString().IndexOf("F");
|
||
string delRowNo = deleteRows[dCnt].ToString().Substring(0, fIdx);
|
||
string delDcNo = deleteRows[dCnt].ToString().Substring(fIdx + 1);
|
||
if (GetDcRowCount(delDcNo) == 1 && delRowNo == "001")
|
||
{
|
||
TStructDef.DcStruct pdc = (TStructDef.DcStruct)tstStrObj.dcs[Convert.ToInt32(delDcNo) - 1];
|
||
pdc.DCHasDataRows = false;
|
||
tstStrObj.dcs[Convert.ToInt32(delDcNo) - 1] = pdc;
|
||
break;
|
||
}
|
||
DeleteRowInFldArrays(delDcNo, delRowNo);
|
||
int tmpRowCnt = GetDcRowCount(delDcNo);
|
||
tmpRowCnt = tmpRowCnt - 1;
|
||
UpdateRowCount("DC" + delDcNo, "DC" + delDcNo + "~" + tmpRowCnt);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to be called to add group
|
||
/// </summary>
|
||
/// <param name="tstData"></param>
|
||
/// <param name="fldArray"></param>
|
||
/// <param name="fldDbRowNo"></param>
|
||
/// <param name="fldValueArray"></param>
|
||
/// <param name="fldDeletedArray"></param>
|
||
/// <param name="s"></param>
|
||
/// <param name="f"></param>
|
||
/// <param name="source"></param>
|
||
/// <param name="delRows"></param>
|
||
/// <param name="changedRows"></param>
|
||
/// <param name="frameNo"></param>
|
||
/// <returns></returns>
|
||
public string CallActionWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, ArrayList deletedFldArrayValues, string s, string f, string source, string delRows, string changedRows, string frameNo, string calledFrom = "false", bool isScript = false)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
result = string.Empty;
|
||
//GetGlobalVars();
|
||
|
||
string cngRows = GetChangedRows(changedRows);
|
||
delRows = GetDelRowsNode(delRows);
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
frameNo = (Convert.ToInt32(frameNo) - 1).ToString();
|
||
|
||
tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, frameNo, calledFrom, "ALL", "");
|
||
|
||
|
||
s += tstData.fieldValueXml + memVarsData + "</row></varlist>" + delRows + cngRows;
|
||
s += HttpContext.Current.Session["axApps"].ToString();
|
||
s += HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString() + "</root>";
|
||
|
||
|
||
if (ires == null)
|
||
ires = "";
|
||
|
||
if (isScript)
|
||
{
|
||
filename = "Script-" + transid;
|
||
logobj.CreateLog("Call to RemoteDoScript Web Service", sessionid, filename, "");
|
||
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.callRemoteDoScriptWS(transid, s, ires, tstData.tstStrObj.WebServiceTimeout);
|
||
|
||
}
|
||
else
|
||
{
|
||
filename = "Action-" + transid;
|
||
logobj.CreateLog("Call to RemoteDoAction Web Service", sessionid, filename, "");
|
||
|
||
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallRemoteDoActionWS(transid, s, ires, tstData.tstStrObj.WebServiceTimeout);
|
||
|
||
}
|
||
if (result != null)
|
||
result = result.Split('♠')[1];
|
||
CheckSave(result, delRows, tstData, changedRows, deletedFldArrayValues);
|
||
logobj.CreateLog("End Time : " + DateTime.Now.ToString(), sessionid, filename, "");
|
||
return result;
|
||
}
|
||
|
||
public string CallActionWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, ArrayList deletedFldArrayValues, string s, string f, string source, string delRows, string changedRows, string calledFrom = "false", StringBuilder files = null, bool isScript = false)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
result = string.Empty;
|
||
if (source == "t")
|
||
{
|
||
string imagefromdb = "false";
|
||
if (HttpContext.Current.Session["AxpSaveImageDb"] != null)
|
||
imagefromdb = HttpContext.Current.Session["AxpSaveImageDb"].ToString();
|
||
if (s != string.Empty)
|
||
s = s.Replace("<root", "<root imagefromdb='" + imagefromdb + "'");
|
||
string cngRows = GetChangedRows(changedRows);
|
||
delRows = GetDelRowsNode(delRows);
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", calledFrom, "ALL", "");
|
||
s += tstData.fldValueXml + memVarsData + "</row></varlist>" + delRows + cngRows;
|
||
s += HttpContext.Current.Session["axApps"].ToString();
|
||
s += HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString() + "</root>";
|
||
}
|
||
else
|
||
ires = "";
|
||
|
||
XmlDocument xmlDoc = new XmlDocument();
|
||
string newfilename = "";
|
||
if (f != "" && f.Contains("&"))
|
||
{
|
||
|
||
newfilename = f.Replace("&", "&");
|
||
|
||
s = s.Replace("__file=\"" + f.ToString() + "\"", "__file=\"" + newfilename.ToString() + "\"");//&
|
||
|
||
}
|
||
xmlDoc.LoadXml(s);
|
||
XmlNode rootNode = xmlDoc.SelectSingleNode("//root");
|
||
if (rootNode != null)
|
||
{
|
||
if (rootNode.Attributes["actname"].Value != string.Empty)
|
||
AxActiveAction = rootNode.Attributes["actname"].Value;
|
||
}
|
||
|
||
if (ires == null)
|
||
ires = "";
|
||
if (isScript)
|
||
{
|
||
filename = "Script-" + transid;
|
||
logobj.CreateLog("Call to RemoteDoScript Web Service", sessionid, filename, "");
|
||
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.callRemoteDoScriptWS(transid, s, ires, tstData.tstStrObj.WebServiceTimeout);
|
||
|
||
}
|
||
else
|
||
{
|
||
filename = "Action-" + transid;
|
||
logobj.CreateLog("Call to RemoteDoAction Web Service", sessionid, filename, "");
|
||
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallRemoteDoActionWS(transid, s, ires, tstData.tstStrObj.WebServiceTimeout);
|
||
}
|
||
|
||
string requestProcess_logtime = result.Split('♠')[0];
|
||
result = result.Split('♠')[1];
|
||
//avoid special chars in result DURING notify
|
||
if (result != "This proces taking time is more than expected. You will get a notification once completed")
|
||
CheckSave(result, delRows, tstData, changedRows, deletedFldArrayValues, (files != null ? files.ToString() : ""));
|
||
AxActiveAction = string.Empty;
|
||
logobj.CreateLog("End Time : " + DateTime.Now.ToString(), sessionid, filename, "");
|
||
result = requestProcess_logtime + "♠" + result;
|
||
return result;
|
||
}
|
||
|
||
private void CheckSave(string result, string delRows, TStructData tstData, string changedRows, ArrayList deletedFldArrayValues, string files = "")
|
||
{
|
||
if (result == "") return;
|
||
result = result.Replace("\\", ";bkslh");
|
||
//To save the image fields in server folders,
|
||
//the below code checks if the action was 'save' and copies the images to the folders.
|
||
|
||
string returnStr = result.Replace("*$*", "¿");
|
||
string[] newResult = returnStr.Split('¿');
|
||
for (int i = 0; i < newResult.Length; i++)
|
||
{
|
||
if (newResult[i].ToString() == "")
|
||
continue;
|
||
JArray action;
|
||
try
|
||
{
|
||
JObject actionresult = JObject.Parse(newResult[i].ToString());
|
||
action = (JArray)actionresult["command"];
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw ex;
|
||
}
|
||
|
||
if (action != null)
|
||
{
|
||
string cmd = string.Empty;
|
||
string cmdVal = string.Empty;
|
||
string pname = string.Empty;
|
||
string pvalue = string.Empty;
|
||
string showin = string.Empty;
|
||
string recId = string.Empty;
|
||
string actionValue = string.Empty;
|
||
for (int m = 0; m < action.Count; m++)
|
||
{
|
||
cmd = (string)action[m]["cmd"].ToString().Trim('"');
|
||
|
||
cmdVal = (string)action[m]["cmdval"].ToString().Trim('"');
|
||
|
||
if (cmd == "openiview")
|
||
{
|
||
pname = (string)action[m]["pname"].ToString().Trim('"');
|
||
pvalue = (string)action[m]["pvalue"].ToString().Trim('"');
|
||
showin = (string)action[m]["showin"].ToString().Trim('"');
|
||
AddParamsToSession(cmdVal, pname, pvalue, showin);
|
||
}
|
||
|
||
|
||
if (cmd == "action")
|
||
actionValue = cmdVal;
|
||
else if (cmd == "recid")
|
||
recId = cmdVal;
|
||
}
|
||
|
||
|
||
if (actionValue.ToLower() == "save")
|
||
{
|
||
if (HttpContext.Current.Session["AxReloadCloud"] != null)
|
||
{
|
||
if (HttpContext.Current.Session["AxReloadCloud"].ToString() == transid)
|
||
{
|
||
try
|
||
{
|
||
HttpContext.Current.Session["IscloudRelogin"] = "true";
|
||
HttpContext.Current.Session["AxInternalRefresh"] = "true";
|
||
util.ClearAxpStructConfigInRedis(Constants.AXCONFIGGENERAL, "", "", "general", "");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
HttpContext.Current.Session["IscloudRelogin"] = "true";
|
||
HttpContext.Current.Session["AxInternalRefresh"] = "true";
|
||
logobj.CreateLog("Main Page Reload-" + ex.Message, sessionid, "MainPageReload", "new", "true");
|
||
}
|
||
}
|
||
}
|
||
|
||
if (util.isRealTimeCacEnabled(transid, tstStrObj))
|
||
HttpContext.Current.Session["AxRelKeys"] = util.GetAxRelations(tstData.transid);
|
||
else
|
||
HttpContext.Current.Session["AxRelKeys"] = null;
|
||
|
||
if (recId != string.Empty)
|
||
{
|
||
if (tstStrObj.AxpFileUploadFields.Count > 0)
|
||
RemoveUnwantedAxpFiles(transid, recId, delRows, tstData, deletedFldArrayValues);
|
||
|
||
//TStructDef strObj = cm.GetStructDef(project, sessionid, user, transid, AxRole);
|
||
if (tstStrObj.ContainsImage)
|
||
|
||
SaveImageToFolder(tstStrObj, transid, sessionid, recId, deletedFldArrayValues);
|
||
|
||
if (tstStrObj.ContainsGridAttach)
|
||
{
|
||
try
|
||
{
|
||
string gridAttSaveResult = SaveGridAttachments(transid, sessionid, recId, delRows, tstData, changedRows, deletedFldArrayValues);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("Error while SaveGridAttachments-" + ex.Message, sessionid, "SaveGridAttachments", "new", "true");
|
||
}
|
||
}
|
||
|
||
if (attachDir && (!string.IsNullOrEmpty(files) || removeFiles.Count > 0))
|
||
SaveAttached(files, recId);
|
||
}
|
||
RefFastDataOnSave(AxActiveAction);
|
||
RefInMemOnSave();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private void RefFastDataOnSave(string taskName)
|
||
{
|
||
//If fast data refresh events are not empty
|
||
FDW fobj = FDW.Instance;
|
||
for (int i = 0; i < tstStrObj.fastDataRefEvent.Count; i++)
|
||
{
|
||
if (tstStrObj.fastDataRefEvent[i].ToString().Contains(taskName))
|
||
{
|
||
//TODO: Push refresh in Fastdata
|
||
string dsName = string.Empty;
|
||
dsName = tstStrObj.fastDataRefDSName[i].ToString();
|
||
fobj.PushToDsRefresh(util.GetFastDataDSName(null, dsName));
|
||
//objfd.RefreshFastDataset(dsName);
|
||
//Thread thread = new Thread(() => objfd.PushRefreshDs(dsName, user));
|
||
//thread.Start();
|
||
}
|
||
}
|
||
}
|
||
|
||
private void AddParamsToSession(string ivName, string paramNames, string paramVals, string showIn)
|
||
{
|
||
|
||
string customIv = GetFieldValue("1", "axp_ivname");
|
||
if (customIv != "")
|
||
ivName = customIv;
|
||
|
||
if (paramNames.IndexOf("###") != -1)
|
||
paramNames = paramNames.Replace("###", "¿");
|
||
|
||
if (paramVals.IndexOf("###") != -1)
|
||
paramVals = paramVals.Replace("###", "¿");
|
||
|
||
string[] strParams = paramNames.Split('¿');
|
||
string[] strParamVals = paramVals.Split('¿');
|
||
var paramsStr = "";
|
||
int pCount = strParams.Length;
|
||
Util.Util utilObj = new Util.Util();
|
||
|
||
if (pCount != 0)
|
||
{
|
||
|
||
var paraName = ""; var paraVal = ""; var fres = "";
|
||
for (var cmp = 0; cmp < pCount; cmp++)
|
||
{
|
||
paraName = strParams[cmp];
|
||
paraVal = strParamVals[cmp];
|
||
//paraVal = utilObj.CheckUrlSpecialChars(paraVal);
|
||
paraVal = paraVal.Replace("=", "@eq@");
|
||
fres = paraName + "=" + paraVal;
|
||
fres = fres.Replace("&", "--.--");
|
||
paramsStr = paramsStr + "&" + fres;
|
||
}
|
||
|
||
}
|
||
if (showIn != "" && showIn == "pop")
|
||
showIn = "&pop=true";
|
||
paramsStr = paramsStr + showIn;
|
||
//HttpContext.Current.Session["AxActionParams" + ivName] = paramsStr;
|
||
//HttpContext.Current.Session["IviewNavigationData-" + ivName] = paramsStr;
|
||
|
||
ASB.WebService webService = new ASB.WebService();
|
||
|
||
webService.SetIviewNavigationData(paramsStr, ivName);
|
||
}
|
||
|
||
private string AddToken(string iXml)
|
||
{
|
||
string token = "";
|
||
token = util.GetToken();
|
||
HttpContext.Current.Session["axpToken"] = token;
|
||
iXml = iXml.Replace("<sqlresultset ", "<sqlresultset token='" + token + "' ");
|
||
return iXml;
|
||
}
|
||
|
||
public string GetRapidFieldValueXml(ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string frameNo, string rowNo, string fieldName)
|
||
{
|
||
string iXml = string.Empty;
|
||
int idx = tstStrObj.GetFieldIndex(fieldName);
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
UpdateDataList(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray);
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
DSRapidFieldValueXML(frameNo, rowNo, fieldName, "Rapid", fld);
|
||
|
||
if (fld.FldRapidAllParents != string.Empty)
|
||
iXml = GetGlobalVarValues(fld.FldRapidAllParents);
|
||
return iXml;
|
||
}
|
||
|
||
public string CallGetRapidDepFldWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string inputXml, string frameNo, string rowNo, string fieldName, string subGridInfo, string parentInfo)
|
||
{
|
||
DateTime stTime = DateTime.Now;
|
||
string traceSep = GetTraceString(inputXml);
|
||
if (traceSep != "") inputXml = traceSep;
|
||
|
||
//insert token in the input xml
|
||
inputXml = AddToken(inputXml);
|
||
|
||
string result = null;
|
||
transid = tstData.transid.ToString();
|
||
AxActDepField = fieldName;
|
||
int idx = tstStrObj.GetFieldIndex(fieldName);
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
bool isDcGrid = false;
|
||
Dictionary<string, string> IncludeDcRows = new Dictionary<string, string>();
|
||
isDcGrid = IsDcGrid(frameNo, tstStrObj);
|
||
logobj.CreateLog("Constructing input xml GetRapidDepFLd-field" + fld.name, sessionid, "GetRapidDep-" + transid, "new");
|
||
UpdateDataList(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray);
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
DSRapidFieldValueXML(frameNo, rowNo, fieldName, "RapidDep", fld);
|
||
if (fld.FldRapidAllParents != string.Empty)
|
||
inputXml += GetGlobalVarValues(fld.FldRapidAllParents);
|
||
inputXml += tstData.fieldValueXml + memVarsData;
|
||
inputXml += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
inputXml += "</sqlresultset>";
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
logobj.CreateLog("Input xml GetRapidDepFLd=" + inputXml, sessionid, "GetRapidDep-" + transid, "");
|
||
DateTime asStart = DateTime.Now;
|
||
result = objWebServiceExt.CallGetRapidDepFldVals(transid, inputXml);
|
||
logobj.CreateLog("RapidGetDepentendFieldValues Result=" + result, sessionid, "GetRapidDep-" + transid, "");
|
||
DateTime asEnd = DateTime.Now;
|
||
if (logTimeTaken)
|
||
{
|
||
webTime1 = asStart.Subtract(stTime).TotalMilliseconds;
|
||
webTime2 = DateTime.Now.Subtract(asEnd).TotalMilliseconds;
|
||
asbTime = asEnd.Subtract(asStart).TotalMilliseconds;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
private string GetGlobalVarValues(string parentFlds)
|
||
{
|
||
StringBuilder paramsNode = new StringBuilder();
|
||
paramsNode.Append("<params>");
|
||
List<string> paramFlds = parentFlds.Split(',').ToList();
|
||
|
||
for (int j = 0; j < paramFlds.Count; j++)
|
||
{
|
||
for (int i = 0; i < tstStrObj.lstGlobalParams.Count; i++)
|
||
{
|
||
string[] strVar = tstStrObj.lstGlobalParams[i].ToString().Split('=');
|
||
string value = CheckSpecialChars(strVar[1].ToString());
|
||
string pName = paramFlds[j].ToString();
|
||
if (strVar[0].ToString() == pName)
|
||
{
|
||
paramsNode.Append("<" + pName + ">" + value + "</" + pName + ">");
|
||
}
|
||
}
|
||
}
|
||
|
||
if (HttpContext.Current.Session["user"] != null)
|
||
paramsNode.Append("<username>" + HttpContext.Current.Session["user"].ToString() + "</username>");
|
||
|
||
paramsNode.Append("</params>");
|
||
return paramsNode.ToString();
|
||
}
|
||
|
||
public string CallGetDepFldWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string s, string frameNo, string rowNo, string fieldName, string subGridInfo, string parentInfo)
|
||
{
|
||
DateTime stTime = DateTime.Now;
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
string result = null;
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
AxActDepField = fieldName;
|
||
int idx = tstStrObj.GetFieldIndex(fieldName);
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
ArrayList AxDepFields = new ArrayList();
|
||
bool isDcGrid = false;
|
||
Dictionary<string, string> IncludeDcRows = new Dictionary<string, string>();
|
||
isDcGrid = IsDcGrid(frameNo, tstStrObj);
|
||
|
||
if (isDcGrid)
|
||
{
|
||
string DepFlds = fld.fieldSqlDepParents;
|
||
AxDepFields = GetParDepFlds(fld.fieldSqlDepParents);
|
||
}
|
||
|
||
if (fld.fieldSqlGridDeps != string.Empty)
|
||
{
|
||
string[] strSDeps = fld.fieldSqlGridDeps.Split(',');
|
||
for (int i = 0; i < strSDeps.Length; i++)
|
||
{
|
||
AxDepFields.Add(strSDeps[i].ToString());
|
||
}
|
||
|
||
//The below statement will add the current field to the dependent fields if the current dc is a grid dc
|
||
//and it has dependents in other grid, then all the row values for the field should be sent in the input xml.
|
||
if (isDcGrid)
|
||
AxDepFields.Add(fld.name);
|
||
}
|
||
|
||
|
||
//If the field has non grid sql dependents, then send the parent values for that dep field also
|
||
if (IsDcGrid(frameNo, tstStrObj))
|
||
{
|
||
|
||
//If the call is made from a parent grid, then all its subgriud and their respective rows for the given parent row
|
||
//will be sent in the given format: dcno~rowno1,rowno2¿dcno~rowno1,rowno2...
|
||
if (subGridInfo != "")
|
||
{
|
||
if (subGridInfo.IndexOf("¿") != -1)
|
||
{
|
||
string[] subgridDcs = subGridInfo.Split('¿');
|
||
for (int i = 0; i < subgridDcs.Length; i++)
|
||
{
|
||
if (subgridDcs[i] != string.Empty)
|
||
{
|
||
string[] dcInfo = subgridDcs[i].ToString().Split('~');
|
||
IncludeDcRows.Add(dcInfo[0], dcInfo[1]);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
IncludeDcRows.Add(subGridInfo.Substring(0, subGridInfo.IndexOf("~")), subGridInfo.Substring(subGridInfo.IndexOf("~") + 1));
|
||
}
|
||
}
|
||
|
||
//If the call is made from sub grid, then the parentinfo will contain the parent dc no and parent row no in the given format : dcno~rowno
|
||
if (parentInfo != "")
|
||
{
|
||
IncludeDcRows.Add(parentInfo.Substring(0, parentInfo.IndexOf("~")), parentInfo.Substring(parentInfo.IndexOf("~") + 1));
|
||
}
|
||
|
||
|
||
//first update the list with the new fldArray.
|
||
UpdateDataList(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray);
|
||
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
|
||
CreateFieldValueXmlPerf(frameNo, rowNo, AxDepFields, fld.fieldDepGridDcs, IncludeDcRows, "");
|
||
|
||
//Refer bug - AGI003591
|
||
//This function was converting the last invalid row to valid row
|
||
//UpdateGridDelRowVal(int.Parse(frameNo));
|
||
|
||
s += tstData.fieldValueXml;
|
||
}
|
||
else
|
||
{
|
||
|
||
if (AxDepFields.Count > 0)
|
||
{
|
||
//if a non grid fields has dependent grid dc fields, then send that dc fields data also.
|
||
//first update the list with the new fldArray.
|
||
UpdateDataList(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray);
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
CreateFieldValueXmlPerf(frameNo, rowNo, AxDepFields, fld.fieldDepGridDcs, IncludeDcRows, "");
|
||
s += tstData.fieldValueXml;
|
||
}
|
||
else
|
||
{
|
||
//if (fld.fieldDepFillDcs != string.Empty)
|
||
//{
|
||
// string[] depFillDcs = fld.fieldDepFillDcs.Split(',');
|
||
// for (int dIdx = 0; dIdx < depFillDcs.Length; dIdx++)
|
||
// {
|
||
// TStructDef.DcStruct depDc = (TStructDef.DcStruct)tstStrObj.dcs[Convert.ToInt32(depFillDcs[dIdx].ToString()) - 1];
|
||
|
||
// }
|
||
//}
|
||
|
||
|
||
//if a non grid fields has dependent grid Fill grid dc, then send that dc data also.
|
||
//TODO: this condition should not send all the fillgrid dep dc data
|
||
tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "GetDependents", "NG", fld.fieldDepFillDcs);
|
||
s += tstData.fieldValueXml;
|
||
}
|
||
}
|
||
|
||
s += memVarsData;
|
||
s += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
s += "</sqlresultset>";
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
|
||
DateTime asStart = DateTime.Now;
|
||
result = objWebServiceExt.CallGetDepentendFieldValuesWS(transid, s, ires);
|
||
DateTime asEnd = DateTime.Now;
|
||
if (logTimeTaken)
|
||
{
|
||
webTime1 = asStart.Subtract(stTime).TotalMilliseconds;
|
||
webTime2 = DateTime.Now.Subtract(asEnd).TotalMilliseconds;
|
||
asbTime = asEnd.Subtract(asStart).TotalMilliseconds;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public string CallGetDepFldPerfWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, ArrayList regVarFldList, string s, string frameNo, string rowNo, string perfDepFldName, string fieldName, string subGridInfo, string parentInfo)
|
||
{
|
||
DateTime stTime = DateTime.Now;
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
string result = null;
|
||
transid = tstData.transid.ToString();
|
||
AxActDepField = fieldName;
|
||
ires = tstStrObj.structRes;
|
||
tstData.GetPerfFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "GetDependents", "NG", "");
|
||
|
||
string imagefromdb = "false";
|
||
if (HttpContext.Current.Session["AxpSaveImageDb"] != null)
|
||
imagefromdb = HttpContext.Current.Session["AxpSaveImageDb"].ToString();
|
||
if (s != string.Empty)
|
||
s = s.Replace("<sqlresultset", "<sqlresultset imagefromdb='" + imagefromdb + "'");
|
||
s += PerfGetDepFldInput(fieldName, perfDepFldName, frameNo, rowNo);
|
||
s += memVarsData;
|
||
if (regVarFldList.Count > 0)
|
||
{
|
||
string regVarXml = "";
|
||
try
|
||
{
|
||
foreach (var varVal in regVarFldList)
|
||
{
|
||
regVarXml += "<" + varVal.ToString().Split(':')[0] + " t='" + varVal.ToString().Split(':')[1] + "'>" + varVal.ToString().Split(':')[2] + "</" + varVal.ToString().Split(':')[0] + ">";
|
||
}
|
||
}
|
||
catch (Exception ex) { }
|
||
s += regVarXml;
|
||
}
|
||
s += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
s += "</sqlresultset>";
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
DateTime asStart = DateTime.Now;
|
||
result = objWebServiceExt.CallGetDepentendFieldValuesWS(transid, s, ires);
|
||
DateTime asEnd = DateTime.Now;
|
||
if (logTimeTaken)
|
||
{
|
||
webTime1 = asStart.Subtract(stTime).TotalMilliseconds;
|
||
webTime2 = DateTime.Now.Subtract(asEnd).TotalMilliseconds;
|
||
asbTime = asEnd.Subtract(asStart).TotalMilliseconds;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
|
||
public string PerfGetDepFldInput(string fieldName, string perfDepFldName, string frameNo, string rowNo)
|
||
{
|
||
string inputFldXML = string.Empty;
|
||
try
|
||
{
|
||
int dfIndx = tstStrObj.GetFieldIndex(fieldName);
|
||
TStructDef.FieldStruct dfld = (TStructDef.FieldStruct)tstStrObj.flds[dfIndx];
|
||
string[] parentFlds = dfld.fieldParents.Replace("~", ",").Split(',');// a66 node of dependent field
|
||
string[] parentDcFlds = new string[] { };
|
||
if (perfDepFldName.StartsWith("dc"))
|
||
{
|
||
try
|
||
{
|
||
int dcFrame = int.Parse(perfDepFldName.Substring(2));
|
||
TStructDef.DcStruct pfldDc = (TStructDef.DcStruct)tstStrObj.dcs[dcFrame - 1];
|
||
if (pfldDc.dcPList != "")
|
||
parentDcFlds = pfldDc.dcPList.Replace("~", ",").Split(',');
|
||
}
|
||
catch (Exception ex) { }
|
||
}
|
||
string[] lstparentFlds = parentFlds.Union(parentDcFlds).ToArray();
|
||
string globalVars = HttpContext.Current.Session["axGlobalVars"].ToString();
|
||
string userVars = HttpContext.Current.Session["axUserVars"].ToString();
|
||
TStructDef.DcStruct dfldDc = (TStructDef.DcStruct)tstStrObj.dcs[dfld.fldFrameNo - 1];
|
||
for (int i = 0; i < lstparentFlds.Length; i++)
|
||
{
|
||
int arNumber = 0;
|
||
int pIndx = tstStrObj.GetFieldIndex(lstparentFlds[i]);
|
||
if (pIndx == -1)
|
||
{
|
||
if (globalVars.ToLower().IndexOf("<" + lstparentFlds[i].ToLower() + ">") > -1)
|
||
continue;
|
||
else if (userVars.ToLower().IndexOf("<" + lstparentFlds[i].ToLower() + ">") > -1)
|
||
continue;
|
||
else
|
||
continue;
|
||
}
|
||
TStructDef.FieldStruct pfld = (TStructDef.FieldStruct)tstStrObj.flds[pIndx];
|
||
TStructDef.DcStruct pfldDc = (TStructDef.DcStruct)tstStrObj.dcs[pfld.fldFrameNo - 1];
|
||
//if (pfld.fldFrameNo == dfld.fldFrameNo && dfldDc.isgrid) // Dependent & Parent fields both are in same dc and the dc is grid dc should take active row only
|
||
// arNumber = int.Parse(rowNo);
|
||
|
||
if (pfldDc.isgrid && pfldDc.DCHasDataRows)// Grid dc field should have 1 row minimum else the field not required in input
|
||
inputFldXML += PerfGetDepFldValues(pfld.fldFrameNo, arNumber, "GetDep", pfld);
|
||
else if (!pfldDc.isgrid)// Should take all the non grid dc fields following teh parents.
|
||
inputFldXML += PerfGetDepFldValues(pfld.fldFrameNo, arNumber, "GetDep", pfld);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("PerfGetDepFldInput function -" + ex.Message, sessionid, "Exception-" + transid, "");
|
||
}
|
||
return inputFldXML;
|
||
}
|
||
|
||
private string PerfGetDepFldValues(int dcNo, int arNumber, string calledFrom, TStructDef.FieldStruct fld = new TStructDef.FieldStruct())
|
||
{
|
||
string iXml = string.Empty;
|
||
TStructDef.DcStruct pfldDc = (TStructDef.DcStruct)tstStrObj.dcs[dcNo - 1];
|
||
DataTable thisDataTable = dsDataSet.Tables["dc" + dcNo];
|
||
string dcNumber = dcNo.ToString();
|
||
string isGrdVld = string.Empty;
|
||
foreach (DataRow dr in thisDataTable.Rows)
|
||
{
|
||
int rowNo = Convert.ToInt32(dr["axp__rowno"]);
|
||
if (pfldDc.isgrid)//Refer Bug:AGI004107
|
||
isGrdVld = dr["axp__isGrdVld" + dcNo].ToString();
|
||
if (isGrdVld != "false")
|
||
{
|
||
DataTable dtOld = dsDataSet.Tables["dc_old" + dcNo];
|
||
DataRow drOld = dtOld.Rows.Find(rowNo);
|
||
string value = string.Empty;
|
||
string oldValue = string.Empty;
|
||
string idValue = string.Empty;
|
||
string oldIdValue = string.Empty;
|
||
value = dr[fld.name].ToString();
|
||
if (fld.savenormal)
|
||
idValue = dr["id__" + fld.name].ToString();
|
||
|
||
if (drOld != null)
|
||
{
|
||
oldValue = drOld["old__" + fld.name].ToString();
|
||
if (fld.savenormal)
|
||
oldIdValue = drOld["oldid__" + fld.name].ToString();
|
||
}
|
||
iXml += WsPerfFieldToXML(fld.name, Convert.ToString(rowNo), value, oldValue, idValue, oldIdValue, dcNumber, fld.savenormal, fld);
|
||
}
|
||
}
|
||
return iXml;
|
||
}
|
||
|
||
public string CallRefreshDc(ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string iXml, string frameNo, string includeDcs)
|
||
{
|
||
string strTrace = GetTraceString(iXml);
|
||
if (strTrace != "") iXml = strTrace;
|
||
string result = string.Empty;
|
||
ires = tstStrObj.structRes;
|
||
GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "RefreshDc", "NG", includeDcs);
|
||
iXml += fieldValueXml + memVarsData;
|
||
iXml += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
iXml += "</sqlresultset>";
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallRefreshDc(iXml, ires);
|
||
return result;
|
||
}
|
||
|
||
private ArrayList GetParDepFlds(string depStr)
|
||
{
|
||
ArrayList arrDeps = new ArrayList();
|
||
string[] depFlds = depStr.Split(',');
|
||
for (int i = 0; i < depFlds.Length; i++)
|
||
{
|
||
arrDeps.Add(depFlds[i].ToString());
|
||
}
|
||
return arrDeps;
|
||
}
|
||
|
||
public string GetVisibleFormatGridsHtml(TStructDef strObj, string visibleDCsStr)
|
||
{
|
||
string[] visibleDCs = visibleDCsStr.Split(',');
|
||
|
||
StringBuilder strDcHtml = new StringBuilder();
|
||
for (int i = 0; i < visibleDCs.Length; i++)
|
||
{
|
||
string dcStr = visibleDCs[i].ToString().Substring(2);
|
||
int dcNo = Convert.ToInt32(dcStr);
|
||
if (depFormatDcs.IndexOf(dcStr) != -1 && ChangedDcs.IndexOf(dcStr) != -1)
|
||
try
|
||
{
|
||
strDcHtml.Append(strObj.GetTabDcHTML(dcNo, this, "false"));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
|
||
}
|
||
}
|
||
|
||
return strDcHtml.ToString();
|
||
}
|
||
|
||
public string CallMsFillGrid(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string frameNo, string s, string paramXml, string fgName)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
string result = null;
|
||
//GetGlobalVars();
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
|
||
tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "FillGrid", "NG", "");
|
||
|
||
s += tstData.fieldValueXml + memVarsData;
|
||
s += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
s += "</sqlresultset>";
|
||
|
||
#region Data cache in session
|
||
//var dcFsg = tstStrObj.fgs.Cast<TStructDef.FGStruct>().Where(f => f.fgtargetdc == ("dc" + frameNo) && f.fgName == fgName).ToList();
|
||
//string fgSqlParam = string.Empty, fgSqlParamVal = string.Empty;
|
||
//if (dcFsg.Count > 0)
|
||
//{
|
||
// TStructDef.FGStruct fg = ((TStructDef.FGStruct)dcFsg[0]);
|
||
// fgSqlParam = fg.fgSqlParams;
|
||
// if (fgSqlParam != string.Empty)
|
||
// {
|
||
// XmlDocument xml = new XmlDocument();
|
||
// xml.LoadXml(s.ToLower());
|
||
// foreach (var name in fgSqlParam.Split(','))
|
||
// {
|
||
// var xnList = xml.SelectNodes("/sqlresultset/" + name);
|
||
// foreach (XmlNode text in xnList)
|
||
// fgSqlParamVal += "~" + name + ":" + text.InnerText.ToLower();
|
||
// }
|
||
// }
|
||
//}
|
||
//if (HttpContext.Current.Session["FillGrid-" + transid + "-" + fgName + "-" + fgSqlParamVal] != null)
|
||
// result = HttpContext.Current.Session["FillGrid-" + transid + "-" + fgName + "-" + fgSqlParamVal].ToString();
|
||
//else
|
||
//{
|
||
// //Call service
|
||
// objWebServiceExt = new ASBExt.WebServiceExt();
|
||
// result = objWebServiceExt.CallGetFillGridValuesWS(transid, s, ires);
|
||
// HttpContext.Current.Session["FillGrid-" + transid + "-" + fgName + "-" + fgSqlParamVal] = result;
|
||
//}
|
||
#endregion
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallGetFillGridValuesWS(transid, s, ires);
|
||
return result;
|
||
}
|
||
|
||
public string GetCacheFileRecId(string recId)
|
||
{
|
||
string recIddataJson = "{\"data\": [";
|
||
|
||
recIddataJson += "{\"n\":\"DC1\",\"v\":\"1\",\"t\":\"dc\"},{\"n\":\"recid\",\"v\":\"" + recId + "\",\"r\":\"0\",\"t\":\"s\"}]}";
|
||
DSSubmit("recid", 0, recId, "");
|
||
return recIddataJson;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to return the Fill pop up html for the format fill grid.
|
||
/// </summary>
|
||
/// <param name="result"></param>
|
||
/// <param name="strObj"></param>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="src"></param>
|
||
/// <returns></returns>
|
||
public string ConstructFormatFillGrid(string result, TStructDef strObj, string dcNo, string src)
|
||
{
|
||
XmlDocument xmlDoc = new XmlDocument();
|
||
xmlDoc.LoadXml(result);
|
||
int m = 0;
|
||
string fgRows = "";
|
||
string cRows = "";
|
||
string headRow = "";
|
||
string chkboxVal = "";
|
||
int colcount = 0;
|
||
string fgHTML = string.Empty;
|
||
XmlNodeList headNodes;
|
||
int rowCnt = 0;
|
||
string firstColValue = string.Empty;
|
||
headNodes = xmlDoc.SelectNodes("//response/row");
|
||
TStructDef.DcStruct dc = ((TStructDef.DcStruct)(strObj.dcs[Convert.ToInt32(dcNo) - 1]));
|
||
foreach (XmlNode resNode in headNodes)
|
||
{
|
||
colcount = 0;
|
||
rowCnt = rowCnt + 1;
|
||
XmlNodeList headers = resNode.ChildNodes;
|
||
foreach (XmlNode hdrNode in headers)
|
||
{
|
||
colcount = colcount + 1;
|
||
string selColName = hdrNode.Name.ToLower();
|
||
int hIndex = dc.HideColumns.IndexOf(selColName);
|
||
|
||
if (hIndex == -1 && selColName != "nselection" && selColName != "cselection" && selColName != "dselection")
|
||
{
|
||
if (rowCnt == 1)
|
||
{
|
||
headRow = headRow + "<th>" + hdrNode.Name + "</th>";
|
||
}
|
||
cRows = cRows + "<td class='fgData'><label>" + hdrNode.InnerText + "</label></td>";
|
||
}
|
||
|
||
if (selColName.ToLower() == dc.MapColumn)
|
||
{
|
||
firstColValue = hdrNode.InnerText;
|
||
}
|
||
if (dc.Action != "")
|
||
{
|
||
if (selColName.Substring(1, selColName.Length - 1) == "selection")
|
||
{
|
||
if (chkboxVal == "")
|
||
chkboxVal = selColName + "♣" + hdrNode.InnerText;
|
||
else
|
||
chkboxVal += "¿" + selColName + "♣" + hdrNode.InnerText;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (selColName == dc.KeyColumn)
|
||
{
|
||
if (chkboxVal == "")
|
||
chkboxVal = selColName + "♣" + hdrNode.InnerText;
|
||
else
|
||
chkboxVal += "¿" + selColName + "♣" + hdrNode.InnerText;
|
||
}
|
||
}
|
||
}
|
||
|
||
string keyColName = dc.KeyColumn;
|
||
if (dc.MapParentCol != string.Empty)
|
||
keyColName = dc.MapParentCol;
|
||
else
|
||
keyColName = dc.KeyColumn;
|
||
|
||
if (firstColValue != "" && IsDupKeyColValue(keyColName, dcNo, firstColValue))
|
||
{
|
||
fgRows = fgRows + "<tr><td width='15'><span class=tem1><input class='fgChk' type=checkbox disabled='disabled' name='chkItem' " + m + " value=\"" + chkboxVal + "\" onclick='javascript:ChkHdrCheckbox(this,\"t\");' ></span></td>" + cRows + "</tr>";
|
||
}
|
||
else
|
||
fgRows = fgRows + "<tr><td width='15'><span class=tem1><input class='fgChk' type=checkbox name='chkItem' " + m + " value=\"" + chkboxVal + "\" onclick='javascript:ChkHdrCheckbox(this,\"t\");' ></span></td>" + cRows + "</tr>";
|
||
|
||
cRows = "";
|
||
chkboxVal = "";
|
||
}
|
||
|
||
if (fgRows.ToString() != "")
|
||
{
|
||
if (src == "add")
|
||
//fgHTML = "<div style=\"overflow: auto;\"><table id='tblFillGrid" + dcNo + "' class='gridData customSetupTableMN'><thead><tr><th width=\"15\"><input type=checkbox name='chkall' class='fgHdrChk' id='chkall' onclick=\"javascript:CheckAll(this,'t');\" ></th>" + headRow + "</tr></thead><tbody>" + fgRows + "</tbody></table>";
|
||
fgHTML = "<div><table id='tblFillGrid" + dcNo + "' class='gridData customSetupTableMN'><thead><tr><th width=\"15\"><input type=checkbox name='chkall' class='fgHdrChk' id='chkall' onclick=\"javascript:CheckAll(this,'t');\" ></th>" + headRow + "</tr></thead><tbody>" + fgRows + "</tbody></table>";
|
||
else
|
||
//fgHTML = "<div style=overflow: auto;\"><table id='tblFillGrid" + dcNo + "' class='gridData customSetupTableMN'><thead><tr><th width=\"15\"><input type=checkbox name='chkall' class='fgHdrChk' id='chkall' onclick=\"javascript:CheckAll(this,'t');\" ></th>" + headRow + "</tr></thead><tbody>" + fgRows + "</tbody></table>";
|
||
fgHTML = "<div><table id='tblFillGrid" + dcNo + "' class='gridData customSetupTableMN'><thead><tr><th width=\"15\"><input type=checkbox name='chkall' class='fgHdrChk' id='chkall' onclick=\"javascript:CheckAll(this,'t');\" ></th>" + headRow + "</tr></thead><tbody>" + fgRows + "</tbody></table>";
|
||
if (src == "add")
|
||
fgHTML += "<div><center><input class='hotbtn btn' type='button' value='Ok' onclick=\"javascript:ProcessAddGroup('" + dcNo + "')\"/></center></div></div>";
|
||
else
|
||
{
|
||
if (dc.Action == "")
|
||
fgHTML += "<div><center><input class='hotbtn btn' type='button' value='Ok' onclick=\"javascript:ProcessFormatStaticFill('" + dcNo + "')\"/></center></div></div>";
|
||
else
|
||
fgHTML += "<div><center><input class='hotbtn btn' type='button' value='Ok' onclick=\"javascript:ProcessFormatFill('" + dcNo + "')\"/></center></div></div>";
|
||
}
|
||
}
|
||
else
|
||
fgHTML = "<label>" + Constants.REC_NOT_FOUND + "</label>";
|
||
|
||
return fgHTML;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to check if the key column value already exists in the field arrays.
|
||
/// </summary>
|
||
/// <param name="keyColName"></param>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="currFldvalue"></param>
|
||
/// <returns></returns>
|
||
public bool IsDupKeyColValue(string keyColName, string dcNo, string currFldvalue)
|
||
{
|
||
bool IsDupValue = false;
|
||
|
||
int rCnt = GetDcRowCount(dcNo);
|
||
|
||
for (int i = 1; i <= rCnt; i++)
|
||
{
|
||
string FldValue = string.Empty;
|
||
if (DSGetRow(i.ToString(), Convert.ToInt32(dcNo))[keyColName] != null)
|
||
FldValue = DSGetRow(i.ToString(), Convert.ToInt32(dcNo))[keyColName].ToString();
|
||
|
||
if (FldValue == currFldvalue)
|
||
{
|
||
IsDupValue = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return IsDupValue;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to return the index of the fill grid from the fill grid struct.
|
||
/// </summary>
|
||
/// <param name="dcNo"></param>
|
||
/// <returns></returns>
|
||
private int GetDcFillGridIndex(string dcName, string fillGridName)
|
||
{
|
||
if (fillGridName == string.Empty)
|
||
{
|
||
for (int i = 0; i < tstStrObj.fgs.Count; i++)
|
||
{
|
||
TStructDef.FGStruct fg = (TStructDef.FGStruct)tstStrObj.fgs[i];
|
||
if (fg.fgtargetdc.ToLower() == dcName.ToLower())
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (int i = 0; i < tstStrObj.fgs.Count; i++)
|
||
{
|
||
TStructDef.FGStruct fg = (TStructDef.FGStruct)tstStrObj.fgs[i];
|
||
if (fg.fgName.ToLower() == fillGridName.ToLower())
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to construct the fill grid pop up html for the given dc.
|
||
/// </summary>
|
||
/// <param name="iXml"></param>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="strObj"></param>
|
||
/// <param name="tstData"></param>
|
||
/// <param name="src"></param>
|
||
/// <returns></returns>
|
||
public string ConstructFillGrid(string iXml, string dcNo, string fgName, TStructDef strObj, TStructData tstData, string src, string expResult)
|
||
{
|
||
string fgHTML = "";
|
||
expResult = expResult.ToLower();
|
||
string chkChecked = string.Empty;
|
||
|
||
if (expResult == "t" || expResult == "true")
|
||
//TODO: to avoid default selection of all items, we have made it unchecked always
|
||
//chkChecked = "checked";
|
||
chkChecked = "";
|
||
else
|
||
chkChecked = "";
|
||
|
||
if (iXml.Contains(Constants.ERROR))
|
||
{
|
||
string errMsg = tstData.GetErrorInResultJson(iXml);
|
||
if (errMsg != "")
|
||
fgHTML = "<label>" + errMsg + "</label>";
|
||
else
|
||
fgHTML = "<label>" + Constants.REC_NOT_FOUND + "</label>";
|
||
}
|
||
else
|
||
{
|
||
XmlDocument xmlDoc = new XmlDocument();
|
||
xmlDoc.LoadXml(iXml);
|
||
int m = 0;
|
||
string fgRows = "";
|
||
bool allrowSelected = false;
|
||
string cRows = "";
|
||
string headRow = "";
|
||
string chkboxVal = "";
|
||
string fgtlhw = "";
|
||
int colcount = 0;
|
||
XmlNodeList headNodes;
|
||
List<string> headerCaption = new List<string>();
|
||
List<string> headerNode = new List<string>();
|
||
int hdrCnt = 0;
|
||
headNodes = xmlDoc.SelectNodes("//response/headrow");
|
||
foreach (XmlNode resNode in headNodes)
|
||
{
|
||
if (resNode.Attributes["tlhw"] != null)
|
||
{
|
||
fgtlhw = resNode.Attributes["tlhw"].Value;
|
||
}
|
||
XmlNodeList headers = resNode.ChildNodes;
|
||
foreach (XmlNode hdrNode in headers)
|
||
{
|
||
for (int i = 0; i < strObj.fgs.Count; i++)
|
||
{
|
||
TStructDef.FGStruct fg = (TStructDef.FGStruct)strObj.fgs[i];
|
||
if (fg.fgtargetdc == "dc" + dcNo && fg.fgName == fgName)
|
||
{
|
||
string colWidth = "50";
|
||
if (hdrNode.Attributes["width"] != null)
|
||
{
|
||
colWidth = hdrNode.Attributes["width"].Value;
|
||
}
|
||
// string colWidth = strObj.GetColumnWidth(dcNo, fg.fgDcFldName[j].ToString());
|
||
//string colWidth = strObj.GetColumnWidth(dcNo, hdrNode.Name);
|
||
if (!string.IsNullOrEmpty(hdrNode.InnerText) && (hdrNode.InnerText.ToLower() == "hide" || hdrNode.InnerText.ToLower().StartsWith("hide_")))
|
||
headRow = headRow + "<th style='display:none;'>" + hdrNode.InnerText + "</th>";
|
||
else
|
||
headRow = headRow + "<th width=\"" + colWidth + "\">" + hdrNode.InnerText + "</th>";
|
||
headerCaption.Add(hdrNode.InnerText);
|
||
headerNode.Add(hdrNode.Name);
|
||
hdrCnt++;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
DataTable fgData = dsDataSet.Tables["dc" + dcNo];
|
||
XmlNodeList dataNodes;
|
||
dataNodes = xmlDoc.SelectNodes("//response/row");
|
||
string fgCondition = string.Empty; //APPEND
|
||
foreach (XmlNode dataNode in dataNodes)
|
||
{
|
||
XmlNodeList baseDataNodes = dataNode.ChildNodes;
|
||
ArrayList ExitFld = new ArrayList();
|
||
ArrayList ExitFldVal = new ArrayList();
|
||
foreach (XmlNode baseDataNode in baseDataNodes)
|
||
{
|
||
|
||
colcount = colcount + 1;
|
||
|
||
for (int i = 0; i < strObj.fgs.Count; i++)
|
||
{
|
||
TStructDef.FGStruct fg = (TStructDef.FGStruct)strObj.fgs[i];
|
||
if (fg.fgtargetdc == "dc" + dcNo && fg.fgName == fgName)
|
||
{
|
||
fgCondition = fg.FGCondition;
|
||
string strVal = CheckSpecialChars(baseDataNode.InnerText);
|
||
for (int j = 0; j < fg.fgSqlFldName.Count; j++)
|
||
{
|
||
if (fg.fgSqlFldName[j].ToString().ToLower() == baseDataNode.Name.ToLower())
|
||
{
|
||
ExitFld.Add(fg.fgDcFldName[j]);
|
||
ExitFldVal.Add(strVal);
|
||
break;
|
||
}
|
||
}
|
||
if (headerNode.IndexOf(baseDataNode.Name) != -1 && !string.IsNullOrEmpty(headerCaption[headerNode.IndexOf(baseDataNode.Name)]) && (headerCaption[headerNode.IndexOf(baseDataNode.Name)].ToLower() == "hide" || headerCaption[headerNode.IndexOf(baseDataNode.Name)].ToLower().StartsWith("hide_")))
|
||
cRows = cRows + "<td style='display:none;'><label>" + strVal + "</label></td>";
|
||
else
|
||
cRows = cRows + "<td class='fgData'><label>" + strVal + "</label></td>";
|
||
|
||
if (fg.fgSqlFldName.IndexOf(baseDataNode.Name.ToLower()) != -1)
|
||
{
|
||
if (chkboxVal == "")
|
||
chkboxVal = baseDataNode.Name + "♣" + strVal;
|
||
else
|
||
chkboxVal += "¿" + baseDataNode.Name + "♣" + strVal;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (fgData.Rows.Count > 0 && fgCondition == "APPEND")
|
||
{
|
||
bool rowExit = false;
|
||
var fgData1 = fgData;
|
||
for (int i = 0; i < ExitFld.Count; i++)
|
||
{
|
||
try
|
||
{
|
||
fgData1 = fgData1.AsEnumerable().Where(r => r.Field<string>(ExitFld[i].ToString()) == ExitFldVal[i].ToString()).CopyToDataTable();
|
||
rowExit = true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
rowExit = false;
|
||
break;
|
||
}
|
||
}
|
||
if (!rowExit)
|
||
fgRows = fgRows + "<tr><td width='15'><span class=tem1><input class='fgChk' type=checkbox " + chkChecked + " name='chkItem' " + m + " value=\"" + chkboxVal + "\" onclick='javascript:ChkHdrCheckbox(this," + "\"" + expResult + "\"" + ");' ></span></td>" + cRows + "</tr>";
|
||
else
|
||
allrowSelected = true;
|
||
}
|
||
else
|
||
fgRows = fgRows + "<tr><td width='15'><span class=tem1><input class='fgChk' type=checkbox " + chkChecked + " name='chkItem' " + m + " value=\"" + chkboxVal + "\" onclick='javascript:ChkHdrCheckbox(this," + "\"" + expResult + "\"" + ");' ></span></td>" + cRows + "</tr>";
|
||
cRows = "";
|
||
chkboxVal = "";
|
||
|
||
}
|
||
if (fgRows.ToString() != "")
|
||
{
|
||
//fgHTML = "<div style=\"overflow: auto;\"><table id='tblFillGrid" + dcNo + "' class='gridData customSetupTableMN'><thead><tr><th width=\"15\"><input type=checkbox name='chkall' class='fgHdrChk' id='chkall' " + chkChecked + " onclick=\"javascript:CheckAll(this, " + "'" + expResult + "'" + ");\" ></th>" + headRow + "</tr></thead><tbody>" + fgRows + "</tbody></table>";
|
||
fgHTML = "<div><table id='tblFillGrid" + dcNo + "' class='gridData customSetupTableMN'><thead><tr><th width=\"15\"><input type=checkbox name='chkall' class='fgHdrChk' id='chkall' " + chkChecked + " onclick=\"javascript:CheckAll(this, " + "'" + expResult + "'" + ");\" ></th>" + headRow + "</tr></thead><tbody>" + fgRows + "</tbody></table>";
|
||
fgHTML += "</div>";
|
||
fgHTML += "*♠*" + fgtlhw;
|
||
}
|
||
else if (allrowSelected)
|
||
fgHTML = "<label>" + Constants.SEL_ROWS_FOUND + "</label>";
|
||
else
|
||
fgHTML = "<label>" + Constants.REC_NOT_FOUND + "</label>";
|
||
|
||
}
|
||
return fgHTML;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get the fill grid data for the selected rows in the fill grid pop up.
|
||
/// </summary>
|
||
/// <param name="tstData"></param>
|
||
/// <param name="fldArray"></param>
|
||
/// <param name="fldDbRowNo"></param>
|
||
/// <param name="fldValueArray"></param>
|
||
/// <param name="fldDeletedArray"></param>
|
||
/// <param name="frameNo"></param>
|
||
/// <param name="s"></param>
|
||
/// <returns></returns>
|
||
public string CallGetFillGridWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string frameNo, string s)
|
||
{
|
||
DateTime stTime = DateTime.Now;
|
||
string result = null;
|
||
string dcNo = frameNo;
|
||
//GetGlobalVars();
|
||
frameNo = Convert.ToString(Convert.ToInt32(frameNo) + 1);
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
//tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, frameNo, "FillGrid", "NG", dcNo);
|
||
tstData.GetPerfFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, frameNo, "FillGrid", "NG", dcNo);
|
||
s += "<FieldList>" + WsPerfAddRowLoadDc(dcNo, "FillGrid") + memVarsData + "</FieldList>" + HttpContext.Current.Session["axApps"].ToString();
|
||
s += HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString() + "</sqlresultset>";
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
DateTime asStart = DateTime.Now;
|
||
|
||
string isRapidCall = "false";
|
||
if ((HttpContext.Current.Session["RapidTsTruct"] != null && HttpContext.Current.Session["RapidTsTruct"].ToString() == "true") && (HttpContext.Current.Session["AxIsPerfCode"] != null && HttpContext.Current.Session["AxIsPerfCode"].ToString().ToLower() == "true"))
|
||
isRapidCall = "true";
|
||
if (isRapidCall == "true")
|
||
{
|
||
s = AddToken(s);
|
||
result = objWebServiceExt.CallRapidDoFillGridValuesWS(transid, s);
|
||
}
|
||
else
|
||
{
|
||
result = objWebServiceExt.CallDoFillGridValuesWS(transid, s, ires);
|
||
}
|
||
|
||
DateTime asEnd = DateTime.Now;
|
||
|
||
if (logTimeTaken)
|
||
{
|
||
webTime1 = asStart.Subtract(stTime).TotalMilliseconds;
|
||
webTime2 = DateTime.Now.Subtract(asEnd).TotalMilliseconds;
|
||
asbTime = asEnd.Subtract(asStart).TotalMilliseconds;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public string CallCreatePDFWS(string s)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
s = s + HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString() + "</root>";
|
||
string result = null;
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallCreatePDFWS(transid, s);
|
||
return result;
|
||
}
|
||
|
||
public string CallCreateFastPDFWS(string s)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
s += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString() + "</root>";
|
||
string result = null;
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallCreateFastPDFWS(transid, s, tstStrObj.structRes);
|
||
return result;
|
||
}
|
||
|
||
public string CallViewAttachWS(string s, string structXml)
|
||
{
|
||
string result = string.Empty;
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
try
|
||
{
|
||
if (attachDir)
|
||
result = GetViewAttachment(s);
|
||
if (result == string.Empty)
|
||
result = objWebServiceExt.CallViewAttachmentsWS(transid, s, structXml);
|
||
|
||
if (result != string.Empty)
|
||
{
|
||
JObject res = null;
|
||
JArray command = null;
|
||
try
|
||
{
|
||
res = JObject.Parse(result);
|
||
command = (JArray)res["command"];
|
||
JObject item = (JObject)command[0];
|
||
item.Add(new JProperty("isatt", "T"));
|
||
result = res.ToString();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
result = ex.Message;
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
result = ex.Message;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
//copy files from local to script
|
||
public string GetViewAttachment(string inputXML)
|
||
{
|
||
string result = string.Empty;
|
||
//CommonDir directory creation taken back due to application server memory usage.
|
||
//if (!attachDirPath.Contains(":\\") && !attachDirPath.StartsWith("\\"))
|
||
//{
|
||
// CreateDirectoryInCommonDir(ref attachDirPath);
|
||
//}
|
||
|
||
XmlDocument xmlDoc = new XmlDocument();
|
||
xmlDoc.LoadXml(inputXML);
|
||
XmlNode rootNode = default(XmlNode);
|
||
rootNode = xmlDoc.SelectSingleNode("root");
|
||
string fname = string.Empty;
|
||
if (rootNode.Attributes["filename"] != null)
|
||
fname = rootNode.Attributes["filename"].Value;
|
||
else
|
||
return result;
|
||
string srcPath = attachDirPath + "\\" + transid + "\\";
|
||
DirectoryInfo tarDir = new DirectoryInfo(scriptsPath + "Axpert\\" + sessionid);
|
||
DirectoryInfo sPath = new DirectoryInfo(srcPath);
|
||
try
|
||
{
|
||
if (!tarDir.Exists)
|
||
tarDir.Create();
|
||
if (sPath.Exists)
|
||
{
|
||
string[] sFileName = Directory.GetFiles(srcPath, recordid + "-" + fname);
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
foreach (var file in sFileName)
|
||
{
|
||
string fileName = Path.GetFileName(file);
|
||
File.Copy(file, Path.Combine(tarDir.ToString(), fileName.Substring(fileName.IndexOf("-") + 1)), true);
|
||
}
|
||
}
|
||
result = "{\"command\":[{\"cmd\":\"openfile\",\"cmdval\":\"" + fname + "\"}]}";
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
result = ex.Message;
|
||
}
|
||
return result;
|
||
}
|
||
//Remove the file from dir
|
||
public string RemoveAttachFromDir(string inputXML)
|
||
{
|
||
string myPath = attachDirPath + "\\" + transid + "\\";
|
||
string result = string.Empty;
|
||
DirectoryInfo dir = new DirectoryInfo(myPath);
|
||
if (inputXML != string.Empty)
|
||
{
|
||
XmlDocument xmlDoc = new XmlDocument();
|
||
xmlDoc.LoadXml(inputXML);
|
||
XmlNode rootNode = default(XmlNode);
|
||
rootNode = xmlDoc.SelectSingleNode("root");
|
||
string fname = string.Empty;
|
||
if (rootNode.Attributes["filename"] != null)
|
||
fname = rootNode.Attributes["filename"].Value;
|
||
else
|
||
return result;
|
||
if (dir.Exists && !string.IsNullOrEmpty(fname))
|
||
{
|
||
removeFiles.Add(recordid + "-" + fname);
|
||
result = "{\"message\":[{\"msg\":\"done\"}]}";
|
||
}
|
||
return result;
|
||
}
|
||
else
|
||
{
|
||
try
|
||
{
|
||
if (dir.Exists)
|
||
dir.Delete(true);
|
||
return result;
|
||
}
|
||
catch { return result; }
|
||
}
|
||
}
|
||
|
||
public string RemoveAttachFromServer(string inputXML, string stransId)
|
||
{
|
||
string result = string.Empty;
|
||
XmlDocument xml = new XmlDocument();
|
||
xml.LoadXml(inputXML);
|
||
XmlElement root = xml.DocumentElement;
|
||
string recordid = string.Empty;
|
||
if (root.HasAttribute("recordid"))
|
||
recordid = root.GetAttribute("recordid");
|
||
if (imgAttachPath != "" && recordid != "0")
|
||
{
|
||
for (int i = 0; i < tstStrObj.flds.Count; i++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[i];
|
||
if (fld.fieldIsImage)
|
||
{
|
||
if (!IsDcGrid(fld.fldframeno.ToString(), tstStrObj) && !fld.name.StartsWith("axp_nga_"))
|
||
{
|
||
string strDest = imgAttachPath + "\\" + transid + "\\" + fld.name;
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
DirectoryInfo di = new DirectoryInfo(strDest);
|
||
if (di.Exists)
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
if (files.Length > 0)
|
||
{
|
||
var ImgExist = files.Where(x => x.Name.Split('.')[0] == recordid).ToList();
|
||
if (ImgExist.Count > 0)
|
||
{
|
||
foreach (var lstImg in ImgExist)
|
||
{
|
||
FileInfo file = (FileInfo)lstImg;
|
||
file.Delete();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (fld.name.StartsWith("axp_nga_"))
|
||
{
|
||
string strDest = imgAttachPath + "\\" + transid + "\\" + fld.name;
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
DirectoryInfo di = new DirectoryInfo(strDest);
|
||
if (di.Exists)
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
if (files.Length > 0)
|
||
{
|
||
var ImgExist = files.Where(x => x.Name.StartsWith(recordid + "-")).ToList();
|
||
if (ImgExist.Count > 0)
|
||
{
|
||
foreach (var lstImg in ImgExist)
|
||
{
|
||
FileInfo file = (FileInfo)lstImg;
|
||
file.Delete();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if ((fld.name.StartsWith("dc") && fld.name.ToLower().EndsWith("_image") || fld.name.StartsWith("axp_gridattach_")) && IsDcGrid(fld.fldframeno.ToString(), tstStrObj))
|
||
{
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[fld.fldframeno - 1];
|
||
string fldName = fld.name;
|
||
string grdAttPath = HttpContext.Current.Session["grdAttPath"].ToString();
|
||
|
||
if (dc.DCHasDataRows && grdAttPath != string.Empty)
|
||
{
|
||
if (!grdAttPath.EndsWith("\\"))
|
||
grdAttPath = grdAttPath + "\\";
|
||
|
||
string destFilePath = destFilePath = grdAttPath + "\\" + stransId + "\\" + fld.name;
|
||
string authenticationStatus = string.Empty;
|
||
if (util.GetAuthentication(ref authenticationStatus))
|
||
{
|
||
DirectoryInfo di = new DirectoryInfo(destFilePath);
|
||
if (di.Exists)
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
if (files.Length > 0)
|
||
{
|
||
var ImgExist = files.Where(x => x.Name.StartsWith(recordid + "-")).ToList();
|
||
if (ImgExist.Count > 0)
|
||
{
|
||
foreach (var lstImg in ImgExist)
|
||
{
|
||
FileInfo file = (FileInfo)lstImg;
|
||
file.Delete();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (attachDirPath != "" && recordid != "0")
|
||
{
|
||
string strDest = imgAttachPath + "\\" + stransId;
|
||
DirectoryInfo di = new DirectoryInfo(strDest);
|
||
if (di.Exists)
|
||
{
|
||
FileInfo[] files = di.GetFiles();
|
||
if (files.Length > 0)
|
||
{
|
||
var ImgExist = files.Where(x => x.Name.StartsWith(recordid + "-")).ToList();
|
||
if (ImgExist.Count > 0)
|
||
{
|
||
foreach (var lstImg in ImgExist)
|
||
{
|
||
FileInfo file = (FileInfo)lstImg;
|
||
file.Delete();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public string CallRemoveAttachWS(string s, string structXml)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
s = s + HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString() + "</root>";
|
||
string result = null;
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
s = util.CheckReverseUrlSpecialChars(s);
|
||
if (attachDir)
|
||
result = RemoveAttachFromDir(s);
|
||
if (string.IsNullOrEmpty(result))
|
||
result = objWebServiceExt.CallRemoveAttachmentsWS(transid, s, structXml);
|
||
return result;
|
||
}
|
||
|
||
//This function creates new directories inside the 'CommonDir' folder in web server.
|
||
public void CreateDirectoryInCommonDir(ref String dirPath)
|
||
{
|
||
dirPath = AppDomain.CurrentDomain.BaseDirectory + "CommonDir\\" + dirPath;
|
||
if (!Directory.Exists(dirPath))
|
||
{
|
||
Directory.CreateDirectory(dirPath);
|
||
}
|
||
}
|
||
|
||
private string GetTraceString(string currentXml)
|
||
{
|
||
string traceVal = string.Empty;
|
||
traceVal = currentXml;
|
||
if (currentXml.Contains("_#") == true)
|
||
{
|
||
currentXml = currentXml.Replace("_#", "~");
|
||
}
|
||
|
||
string filename = string.Empty;
|
||
int sindex = currentXml.IndexOf(Constants.TRACESPLITSTR2);
|
||
int eindex = currentXml.LastIndexOf(Constants.TRACESPLITSTR1);
|
||
|
||
if (sindex != -1 && eindex != -1)
|
||
{
|
||
filename = currentXml.Substring(sindex + 2, eindex - sindex - 2);
|
||
sessionid = HttpContext.Current.Session["nsessionid"].ToString();
|
||
errlog = logobj.CreateLog("Executing Action", sessionid, filename, "new");
|
||
traceVal = currentXml.Replace(Constants.TRACESPLITSTR2 + filename + Constants.TRACESPLITSTR1, errlog);
|
||
}
|
||
|
||
if (traceVal.Contains("~") == true)
|
||
{
|
||
traceVal = traceVal.Replace("~", "_#");
|
||
}
|
||
if (scriptsPath != string.Empty)
|
||
{
|
||
traceVal = traceVal.Replace("<root", "<root scriptpath=" + '"' + scriptsPath + '"');
|
||
}
|
||
if (traceVal != null && traceVal != "")// Reddy
|
||
{
|
||
if (traceVal.TrimStart().StartsWith("<root "))
|
||
{
|
||
traceVal = traceVal.Replace("<root", "<root appsessionkey='" + HttpContext.Current.Session["AppSessionKey"].ToString() + "' username='" + HttpContext.Current.Session["username"].ToString() + "'");
|
||
}
|
||
else if (traceVal.TrimStart().StartsWith("<sqlresultset "))
|
||
{
|
||
traceVal = traceVal.Replace("<sqlresultset", "<sqlresultset appsessionkey='" + HttpContext.Current.Session["AppSessionKey"].ToString() + "' username='" + HttpContext.Current.Session["username"].ToString() + "'");
|
||
}
|
||
else if (traceVal.TrimStart().StartsWith("<Transaction "))
|
||
{
|
||
traceVal = traceVal.Replace("<Transaction", "<Transaction appsessionkey='" + HttpContext.Current.Session["AppSessionKey"].ToString() + "' username='" + HttpContext.Current.Session["username"].ToString() + "'");
|
||
}
|
||
}
|
||
|
||
return traceVal;
|
||
}
|
||
|
||
public string GetAxFormDetails()
|
||
{
|
||
string frmDetails = string.Empty;
|
||
string trace = HttpContext.Current.Session["AxTrace"].ToString();
|
||
frmDetails = "<script type='text/javascript'>";
|
||
frmDetails += "function GetFormDetails() { var a = '" + project + "';var b='" + user + "';var c='" + transactionID + "';var d='" + sessionid + "';var e = '" + AxRole + "';var f='" + trace + "';SetTstProps(a,b,c,d,e,f);}";
|
||
frmDetails += "</script>";
|
||
|
||
return frmDetails;
|
||
}
|
||
|
||
public string CallGetFormLoad(TStructData tstData, string errorLog)
|
||
{
|
||
string result = null;
|
||
string visibleDCs = string.Empty;
|
||
visibleDCs = tstStrObj.GetVisibleDCs();
|
||
string loadXml = "<root axpapp='" + HttpContext.Current.Session["project"].ToString() + "' sessionid='" + HttpContext.Current.Session["nsessionid"].ToString() + "' transid='" + tstData.transid + "' recordid='" + rid + "' dcname='" + visibleDCs + "' trace='" + errorLog + "' appsessionkey='" + HttpContext.Current.Session["AppSessionKey"].ToString() + "' username='" + HttpContext.Current.Session["username"].ToString() + "'>";
|
||
loadXml += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
loadXml += "</root>";
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallDoFormLoadWS(tstData.transid, loadXml, tstStrObj.structRes);
|
||
//requestProcess_logtime += loadRes.Split('♠')[0];
|
||
result = result.Split('♠')[1];
|
||
return result;
|
||
}
|
||
|
||
public string CallGetLoadData(TStructData tstData, string recordid, string errorLog)
|
||
{
|
||
string result = null;
|
||
string visibleDCs = string.Empty;
|
||
visibleDCs = tstStrObj.GetVisibleDCs();
|
||
string proj = HttpContext.Current.Session["project"].ToString();
|
||
string imagefromdb = "false";
|
||
if (HttpContext.Current.Session["AxpSaveImageDb"] != null)
|
||
imagefromdb = HttpContext.Current.Session["AxpSaveImageDb"].ToString();
|
||
string loadXml = "<root imagefromdb='" + imagefromdb + "' axpapp = '" + proj + "' sessionid = '" + HttpContext.Current.Session["nsessionid"].ToString() + "' appsessionkey = '" + HttpContext.Current.Session["AppSessionKey"].ToString() + "' username = '" + HttpContext.Current.Session["username"].ToString() + "' transid = '" + tstData.transid + "' recordid = '" + recordid + "' dcname = '" + visibleDCs + "' trace = '" + errorLog + "' > ";
|
||
loadXml += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
loadXml += "</root>";
|
||
loadXml = util.ReplaceImagePath(loadXml);
|
||
string tsId = tstData.transid;
|
||
string sXml = tstStrObj.structRes;
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallLoadDataWS(tsId, loadXml, sXml, recordid, proj);
|
||
HttpContext.Current.Session["axp_lockonrecid"] = tsId + "~" + recordid;
|
||
return result;
|
||
}
|
||
#endregion
|
||
|
||
#region Private Methods
|
||
|
||
/// <summary>
|
||
/// Function to update the decimal value for the given field in the structure xml
|
||
/// </summary>
|
||
/// <param name="fieldName"></param>
|
||
/// <param name="dec"></param>
|
||
private void UpdateAxpCurrDec(string[] fieldNames, int dec)
|
||
{
|
||
XmlDocument xmlDoc = new XmlDocument();
|
||
xmlDoc.LoadXml(tstStrObj.structRes);
|
||
XmlNodeList fieldNode;
|
||
//looping from i=1 as the first item is decimal
|
||
for (int i = 1; i < fieldNames.Length; i++)
|
||
{
|
||
fieldNode = xmlDoc.GetElementsByTagName(fieldNames[i].ToString().Trim());
|
||
if (fieldNode.Count > 0)
|
||
{
|
||
foreach (XmlNode childNode in fieldNode[0].ChildNodes)
|
||
{
|
||
if (childNode.Name == "a5")
|
||
{
|
||
childNode.InnerText = dec.ToString();
|
||
tstStrObj.structRes = xmlDoc.OuterXml;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to check if the field is axpcurrencydec and call update struct xml
|
||
/// </summary>
|
||
/// <param name="fldName"></param>
|
||
/// <param name="fldVal"></param>
|
||
private void CheckAxpCurrDec(string fldName, string fldVal)
|
||
{
|
||
string[] axpCurrDetails = new string[] { };
|
||
axpCurrDetails = fldVal.Split(',');
|
||
if (axpCurrDetails.Length > 0 && fldVal != "")
|
||
{
|
||
int decNo = Convert.ToInt32(axpCurrDetails[0]);
|
||
UpdateAxpCurrDec(axpCurrDetails, decNo);
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Function which loads the given image from the image folder to scripts.
|
||
/// On change of the product, if the image should be replaced, this function is called.
|
||
/// </summary>
|
||
/// <param name="imageName"></param>
|
||
/// <param name="imageSrc"></param>
|
||
/// <returns>It returns the imagename along with the source value for the image, which is set in the client function</returns>
|
||
public string GetImageSource(string imageName, string imageSrc)
|
||
{
|
||
if (imageSrc != "")
|
||
{
|
||
string[] fvalues = imageSrc.ToString().Split('~');
|
||
string recordId = fvalues[2].ToString();
|
||
imageFldNames.Clear();
|
||
imageFldSrc.Clear();
|
||
LoadImageToFolder(imageName, recordId);
|
||
|
||
|
||
string imgSrc = "";
|
||
for (int i = 0; i < imageFldNames.Count; i++)
|
||
{
|
||
if (imageFldNames[i].ToString() == imageName)
|
||
{
|
||
imgSrc = imageFldSrc[i].ToString();
|
||
break;
|
||
}
|
||
}
|
||
|
||
return imageName + "♣" + imgSrc;
|
||
}
|
||
return imageFldSrc + "♣" + "";
|
||
}
|
||
|
||
private void CreateFieldValueXmlLoadTab(string frameNo)
|
||
{
|
||
string fValue = string.Empty;
|
||
StringBuilder fldXml = new StringBuilder();
|
||
string curFldFrmNo = "0";
|
||
for (int i = 0; i < fieldName.Count; i++)
|
||
{
|
||
int fIndex = 0;
|
||
fIndex = fieldControlName[i].ToString().LastIndexOf("F");
|
||
fIndex = fIndex + 1;
|
||
curFldFrmNo = fieldControlName[i].ToString().Substring(fIndex, fieldControlName[i].ToString().Length - fIndex);
|
||
|
||
if (Convert.ToInt32(curFldFrmNo) <= Convert.ToInt32(frameNo))
|
||
{
|
||
fldXml.Append("<" + fieldName[i] + ">");
|
||
fValue = CheckSpecialChars(fieldValue[i].ToString());
|
||
fldXml.Append(fValue);
|
||
fldXml.Append("</" + fieldName[i] + ">");
|
||
}
|
||
}
|
||
|
||
fgFieldValueXml = fldXml.ToString();
|
||
}
|
||
private void CreateFieldValueXmlPerf(string frameNum, string ActiveRowNo, ArrayList AxDepFields, string fldDepGridDcs, Dictionary<string, string> includeDcRows, string includeDcs)
|
||
{
|
||
DSFieldValueXMLPerf(frameNum, ActiveRowNo, AxDepFields, fldDepGridDcs, includeDcRows, includeDcs);
|
||
}
|
||
|
||
private void CreateFieldValueXml(string condition, string includeDcs, string calledFrom)
|
||
{
|
||
DSFieldValueXML(condition, includeDcs, calledFrom);
|
||
}
|
||
|
||
private void FieldToXML(string fldName, string rowNo, string value, string oldValue, string idvalue, string oldIdValue, string dcNo, Boolean fldSaveNormal, bool isSubGrid, string subRowNo, TStructDef.FieldStruct fld = new TStructDef.FieldStruct())
|
||
{
|
||
rowNo = GetRowNoHelper(rowNo.ToString());
|
||
value = CheckSpecialChars(value);
|
||
oldValue = CheckSpecialChars(oldValue);
|
||
string oldVal = "";
|
||
if (recordid != "0")
|
||
{
|
||
if (value != oldValue)
|
||
oldVal = "ov='" + oldValue + "'";
|
||
else
|
||
oldVal = "";
|
||
}
|
||
if (fldName.StartsWith(Constants.IMGPrefix))
|
||
return;
|
||
if (fldName.ToLower() == (Constants.AXPIMAGEPATH))
|
||
isAxpImagePath = true;
|
||
//if (fld.datatype != null && fld.datatype.ToLower() == "image" && imgAttachPath != "")
|
||
// return;
|
||
if (fldSaveNormal)
|
||
{
|
||
if (Convert.ToString(idvalue) == "") idvalue = "0";
|
||
if (Convert.ToString(oldIdValue) == "") oldIdValue = "0";
|
||
if (isSubGrid)
|
||
dsDataXML.Append("<" + fldName + " rowno='" + subRowNo + "' id='" + idvalue + "' oldid='" + oldIdValue + "' " + oldVal + ">" + value + "</" + fldName + ">");
|
||
else
|
||
dsDataXML.Append("<" + fldName + " rowno='" + rowNo + "' id='" + idvalue + "' oldid='" + oldIdValue + "' " + oldVal + ">" + value + "</" + fldName + ">");
|
||
}
|
||
else
|
||
{
|
||
if (isSubGrid)
|
||
dsDataXML.Append("<" + fldName + " rowno='" + subRowNo + "' " + oldVal + ">" + value + "</" + fldName + ">");
|
||
else if (fld.fldMultiSelect != null)
|
||
{
|
||
dsDataXML.Append("<" + fldName + " rowno='" + rowNo + "' " + oldVal + " multiselect='true' separator='" + fld.fldMultiSelectSep + "'>" + value + "</" + fldName + ">");
|
||
}
|
||
else
|
||
dsDataXML.Append("<" + fldName + " rowno='" + rowNo + "' " + oldVal + ">" + value + "</" + fldName + ">");
|
||
}
|
||
}
|
||
|
||
private void DSFieldValueXML(string frameNum, string parDcNo, int ParRowNo, string popDcNo, int popRowNo)
|
||
{
|
||
int fNo = -1;
|
||
bool isNumber = false;
|
||
try
|
||
{
|
||
fNo = int.Parse(frameNum);
|
||
isNumber = true;
|
||
frameNum = "F" + frameNum;
|
||
}
|
||
catch
|
||
{
|
||
}
|
||
|
||
dsDataXML.Length = 0;
|
||
|
||
//loop for constructing the field value xml based on the frame no, row no and field order
|
||
foreach (TStructDef.DcStruct dc in tstStrObj.dcs)
|
||
{
|
||
string dcNo = Convert.ToString(dc.frameno);
|
||
|
||
//This condition will construct xml till the given dc if the given number is a frame no,
|
||
//else it will continue and create the xml for all dc's.
|
||
if ((frameNum != "F-1") && (isNumber))
|
||
{
|
||
if (dc.frameno > fNo)
|
||
break;
|
||
}
|
||
|
||
if (dc.isgrid && dc.DCHasDataRows == false)
|
||
continue;
|
||
|
||
DataTable thisDataTable = dsDataSet.Tables["dc" + dcNo];
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
string subGridRow = string.Empty;
|
||
bool isSubGrid = false;
|
||
|
||
foreach (DataRow dr in thisDataTable.Rows)
|
||
{
|
||
int rowNo = Convert.ToInt32(dr["axp__rowno"]);
|
||
if (dc.frameno.ToString() == parDcNo && rowNo != ParRowNo)
|
||
continue;
|
||
|
||
//Sub-Grid - only the newly added row should be sent in the input xml.
|
||
if (dc.frameno.ToString() == popDcNo && rowNo != popRowNo)
|
||
{
|
||
continue;
|
||
}
|
||
else if (dc.frameno.ToString() == popDcNo)
|
||
{
|
||
subGridRow = "001";
|
||
isSubGrid = true;
|
||
}
|
||
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, isSubGrid, subGridRow);
|
||
}
|
||
}
|
||
|
||
fieldValueXml = dsDataXML.ToString();
|
||
}
|
||
|
||
private void DSFieldValueXMLHelperPerf(string dcNo, int rowNo, int startIdx, int endIdx, DataRow dr, ArrayList depFields)
|
||
{
|
||
DataTable dtOld = dsDataSet.Tables["dc_old" + dcNo];
|
||
DataRow drOld = dtOld.Rows.Find(rowNo);
|
||
|
||
for (int j = startIdx; j <= endIdx; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[j];
|
||
if (depFields.IndexOf(fld.name) == -1)
|
||
continue;
|
||
|
||
string value = string.Empty;
|
||
string oldValue = string.Empty;
|
||
string idValue = string.Empty;
|
||
string oldIdValue = string.Empty;
|
||
|
||
string FldValue = string.Empty;
|
||
|
||
value = dr[fld.name].ToString();
|
||
if (fld.savenormal)
|
||
idValue = dr["id__" + fld.name].ToString();
|
||
|
||
if (drOld != null)
|
||
{
|
||
oldValue = drOld["old__" + fld.name].ToString();
|
||
if (fld.savenormal)
|
||
oldIdValue = drOld["oldid__" + fld.name].ToString();
|
||
}
|
||
|
||
FieldToXML(fld.name, Convert.ToString(rowNo), value, oldValue, idValue, oldIdValue, dcNo, fld.savenormal, false, "");
|
||
}
|
||
}
|
||
|
||
private void DSFieldValueXMLHelper(string dcNo, int rowNo, int startIdx, int endIdx, DataRow dr, bool isSubGrid, string subGridRowNo)
|
||
{
|
||
DataTable dtOld = dsDataSet.Tables["dc_old" + dcNo];
|
||
DataRow drOld = dtOld.Rows.Find(rowNo);
|
||
|
||
for (int j = startIdx; j <= endIdx; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[j];
|
||
string value = string.Empty;
|
||
string oldValue = string.Empty;
|
||
string idValue = string.Empty;
|
||
string oldIdValue = string.Empty;
|
||
|
||
string FldValue = string.Empty;
|
||
|
||
value = dr[fld.name].ToString();
|
||
if (fld.savenormal)
|
||
idValue = dr["id__" + fld.name].ToString();
|
||
|
||
if (drOld != null)
|
||
{
|
||
oldValue = drOld["old__" + fld.name].ToString();
|
||
if (fld.savenormal)
|
||
oldIdValue = drOld["oldid__" + fld.name].ToString();
|
||
}
|
||
////// is save true and rtf check..
|
||
if (isSaveCalled)
|
||
{
|
||
if ((fld.name.Contains("rtf_") || fld.name.Contains("rtfm_") || fld.name.Contains("fr_rtf_")) && fld.name.Contains("_printable"))
|
||
value = ReplaceRTFTagsForPrint(dr[fld.name.Replace("_printable", "")].ToString());
|
||
}
|
||
|
||
FieldToXML(fld.name, Convert.ToString(rowNo), value, oldValue, idValue, oldIdValue, dcNo, fld.savenormal, isSubGrid, subGridRowNo, fld);
|
||
}
|
||
}
|
||
|
||
private void RapidFieldValueXML(string dcNo, int rowNo, int startIdx, int endIdx, DataRow dr, bool isSubGrid, string subGridRowNo, TStructDef.FieldStruct Parfld, string actRow, string calledFrom)
|
||
{
|
||
DataTable dtOld = dsDataSet.Tables["dc_old" + dcNo];
|
||
DataRow drOld = dtOld.Rows.Find(rowNo);
|
||
string[] arrParams;
|
||
if (calledFrom == "Rapid")
|
||
arrParams = Parfld.FldRapidParents.Split(',');
|
||
else
|
||
arrParams = Parfld.FldRapidAllParents.Split(',');
|
||
List<string> lstParams = new List<string>();
|
||
lstParams.AddRange(arrParams);
|
||
|
||
string[] arrParAllRows = Parfld.FldRapidAllRows.Split(',');
|
||
List<string> lstParAllRows = new List<string>();
|
||
lstParAllRows.AddRange(arrParAllRows);
|
||
|
||
for (int j = startIdx; j <= endIdx; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[j];
|
||
int dIdx = -1;
|
||
dIdx = lstParams.IndexOf(fld.name);
|
||
//If the field is not there in the params array, continue the loop
|
||
if (dIdx == -1 && !fld.name.StartsWith("axp_recid")) continue;
|
||
|
||
//If the allrows for the current parent is false, then only if the current dc and parent dc are same row should be constructed for active row else continue
|
||
//arrParAllRows.Length > dIdx - this condition needs to be handled
|
||
if (IsDcGrid(fld.fldframeno.ToString(), tstStrObj) && dIdx != -1 && arrParAllRows.Length > dIdx)
|
||
{
|
||
if (!(fld.fldframeno == Parfld.fldframeno && arrParAllRows[dIdx] == "F" && rowNo.ToString() == actRow)) continue;
|
||
}
|
||
string value = string.Empty;
|
||
string oldValue = string.Empty;
|
||
string idValue = string.Empty;
|
||
string oldIdValue = string.Empty;
|
||
|
||
string FldValue = string.Empty;
|
||
|
||
value = dr[fld.name].ToString();
|
||
if (fld.savenormal)
|
||
idValue = dr["id__" + fld.name].ToString();
|
||
|
||
if (drOld != null)
|
||
{
|
||
oldValue = drOld["old__" + fld.name].ToString();
|
||
if (fld.savenormal)
|
||
oldIdValue = drOld["oldid__" + fld.name].ToString();
|
||
}
|
||
////// is save true and rtf check..
|
||
if (isSaveCalled)
|
||
{
|
||
if ((fld.name.Contains("rtf_") || fld.name.Contains("rtfm_") || fld.name.Contains("fr_rtf_")) && fld.name.Contains("_printable"))
|
||
value = ReplaceRTFTagsForPrint(dr[fld.name.Replace("_printable", "")].ToString());
|
||
}
|
||
|
||
FieldToXML(fld.name, Convert.ToString(rowNo), value, oldValue, idValue, oldIdValue, dcNo, fld.savenormal, isSubGrid, subGridRowNo);
|
||
}
|
||
}
|
||
|
||
|
||
private string ReplaceRTFTagsForPrint(string inpStr)
|
||
{
|
||
// string[] rtfTags = new string[] { "<pre", "<span", "<div", "<ul", "<li", "<ol", "<span", "<blockquote", "<font", "<h1", "<h2", "<h3", "<h4", "<h5", "<p", "<em", "<br" };
|
||
// string[] rtfEndTags = new string[] { "</pre>", "</span>", "</div>", "</ul>", "</li>", "</ol>", "</span>", "</blockquote>", "</font>", "</h1>", "</h2>", "</h3>", "</h4>", "</h5>", "</p>", "</em>", "</br>" };
|
||
|
||
string[] rtfTags = new string[] { "<pre", "<span", "<div", "<ul", "<li", "<ol", "<span", "<blockquote", "<h1", "<h2", "<h3", "<h4", "<h5", "<p", "<em", "<br" };
|
||
string[] rtfEndTags = new string[] { "</pre>", "</span>", "</div>", "</ul>", "</li>", "</ol>", "</span>", "</blockquote>", "</h1>", "</h2>", "</h3>", "</h4>", "</h5>", "</p>", "</em>", "</br>" };
|
||
|
||
for (int i = 0; i < rtfTags.Length; i++)
|
||
while (inpStr.Contains(rtfTags[i]))
|
||
{
|
||
int startIdx = -1;
|
||
int endIdx = -1;
|
||
|
||
startIdx = inpStr.IndexOf(rtfTags[i]);
|
||
endIdx = inpStr.IndexOf(">", startIdx);
|
||
|
||
string replaceStr = string.Empty;
|
||
|
||
string strNode = inpStr.Substring(startIdx, (endIdx - startIdx) + 1);
|
||
//Code to replace <div> with new line in fast report
|
||
if (strNode == "<div>" || strNode == "<li>")
|
||
{
|
||
//replaceStr = "#13#10";
|
||
inpStr = inpStr.Insert(endIdx + 1, "~");
|
||
}
|
||
|
||
inpStr = inpStr.Remove(startIdx, (endIdx + 1) - startIdx);
|
||
inpStr = inpStr.Replace(rtfEndTags[i], replaceStr);
|
||
}
|
||
|
||
string[] rtfSupportedTags = new string[] { "<em", "<i", "<b", "<u", "<strong" };
|
||
|
||
for (int i = 0; i < rtfSupportedTags.Length; i++)
|
||
{
|
||
int startIdx = -1;
|
||
int endIdx = -1;
|
||
while (true)
|
||
{
|
||
startIdx = inpStr.IndexOf(rtfSupportedTags[i], endIdx + 1);
|
||
if (startIdx == -1)
|
||
break;
|
||
|
||
endIdx = inpStr.IndexOf(">", startIdx);
|
||
inpStr = inpStr.Remove(startIdx, (endIdx + 1) - startIdx);
|
||
inpStr = inpStr.Insert(startIdx, rtfSupportedTags[i] + ">");
|
||
endIdx = endIdx - (endIdx - startIdx);
|
||
}
|
||
}
|
||
|
||
inpStr = inpStr.Replace(" ", "");
|
||
inpStr = inpStr.Replace("\n", "~");
|
||
|
||
return inpStr;
|
||
}
|
||
|
||
private void DSFieldValueXML(string frameNum, string calledFrom)
|
||
{
|
||
int fNo = -1;
|
||
bool isNumber = true;
|
||
try
|
||
{
|
||
fNo = int.Parse(frameNum);
|
||
isNumber = true;
|
||
}
|
||
catch
|
||
{
|
||
isNumber = false;
|
||
}
|
||
|
||
if (isNumber)
|
||
frameNum = "F" + frameNum;
|
||
|
||
dsDataXML.Length = 0;
|
||
|
||
//loop for constructing the field value xml based on the frame no, row no and field order
|
||
foreach (TStructDef.DcStruct dc in tstStrObj.dcs)
|
||
{
|
||
string dcNo = Convert.ToString(dc.frameno);
|
||
|
||
//This condition will construct xml till the given dc if the given number is a frame no,
|
||
//else it will continue and create the xml for all dc's.
|
||
if ((frameNum != "F-1") && (isNumber))
|
||
{
|
||
if (calledFrom == "FillGrid")
|
||
{
|
||
//– Only non grid data will be sent in input xml.For all grid dcs only row count will be sent.
|
||
if (dc.isgrid)
|
||
{
|
||
int rCnt = GetDcRowCount(dcNo);
|
||
dsDataXML.Append("<dc" + dcNo + " type=dc >" + rCnt + "</dc" + dcNo + ">");
|
||
continue;
|
||
}
|
||
}
|
||
else if (calledFrom == "LoadDc")
|
||
{
|
||
//Only non grid data and this DC data will be sent as parameter
|
||
if (fNo != dc.frameno || dc.isgrid)
|
||
continue;
|
||
}
|
||
//TODO: why this is empty?
|
||
else if (calledFrom == "GetDep")
|
||
{
|
||
|
||
}
|
||
else
|
||
{
|
||
//NOTE: for a webservice where the frame no is sent, all other grid dcs data should also be sent to the web service.
|
||
if (dc.frameno > fNo && dc.isgrid)
|
||
continue;
|
||
}
|
||
}
|
||
|
||
int rowCnt = 0;
|
||
if (dc.isgrid)
|
||
{
|
||
rowCnt = GetDcRowCount(dcNo);
|
||
if (rowCnt == 0) rowCnt = 1;
|
||
if (calledFrom != "PickList" && dc.DCHasDataRows == false)
|
||
continue;
|
||
}
|
||
|
||
DataTable thisDataTable = dsDataSet.Tables["dc" + dcNo];
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
|
||
foreach (DataRow dr in thisDataTable.Rows)
|
||
{
|
||
int rowNo = Convert.ToInt32(dr["axp__rowno"]);
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, false, "");
|
||
}
|
||
}
|
||
if (frameNum == "F-1")
|
||
fieldValueXml = dsDataXML.ToString();
|
||
else
|
||
fgFieldValueXml = dsDataXML.ToString();
|
||
|
||
}
|
||
|
||
public void DSRapidFieldValueXML(string frameNo, string actRowNo, string fieldName, string calledFrom, TStructDef.FieldStruct fld)
|
||
{
|
||
dsDataXML = new StringBuilder();
|
||
//loop for constructing the field value xml based on the frame no, row no and field order
|
||
foreach (TStructDef.DcStruct dc in tstStrObj.dcs)
|
||
{
|
||
string dcNo = Convert.ToString(dc.frameno);
|
||
|
||
//This condition will construct xml for all the non grids in the given tstruct,
|
||
//if the includeDcs contains any grid dc then that dc also will be included in the xml construction.
|
||
//TODO:RAPID - Check allrows along with params
|
||
int rowCnt = 0;
|
||
if (dc.isgrid)
|
||
{
|
||
rowCnt = GetDcRowCount(dcNo);
|
||
if (rowCnt == 0) rowCnt = 1;
|
||
//if (calledFrom != "PickList" && dc.DCHasDataRows == false && calledFrom != "RefreshDc")
|
||
// continue;
|
||
}
|
||
|
||
DataTable thisDataTable = dsDataSet.Tables["dc" + dcNo];
|
||
try
|
||
{
|
||
if (calledFrom != "AutoComplete" && calledFrom != "axpbutton")
|
||
{
|
||
DataRow[] rows;
|
||
rows = thisDataTable.Select("axp__isGrdVld" + dcNo + " = 'false'"); // axp__isGrdVld is Column Name
|
||
foreach (DataRow r in rows)
|
||
thisDataTable.Rows.Remove(r);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
//catch block is not handlink because - we are skipping the rows which does not contains axp__isGrdVld+dcno column
|
||
}
|
||
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
|
||
foreach (DataRow dr in thisDataTable.Rows)
|
||
{
|
||
int rowNo = Convert.ToInt32(dr["axp__rowno"]);
|
||
if (calledFrom != "AutoComplete" && calledFrom != "axpbutton" && thisDataTable.Columns.Contains(Constants.AXPISROWVALID + dcNo) && dr[Constants.AXPISROWVALID + dcNo].ToString() == "false")
|
||
continue;
|
||
|
||
RapidFieldValueXML(dcNo, rowNo, startIdx, endIdx, dr, false, "", fld, actRowNo, calledFrom);
|
||
|
||
}
|
||
}
|
||
|
||
fieldValueXml = dsDataXML.ToString();
|
||
}
|
||
|
||
/// <summary>
|
||
///
|
||
/// </summary>
|
||
/// <param name="condition">NG</param>
|
||
/// <param name="includeDcs"></param>
|
||
/// <param name="calledFrom"></param>
|
||
public void DSFieldValueXML(string condition, string includeDcs, string calledFrom)
|
||
{
|
||
dsDataXML.Length = 0;
|
||
|
||
ArrayList incGridDcs = new ArrayList();
|
||
if (!string.IsNullOrEmpty(includeDcs))
|
||
{
|
||
string[] incDcs = includeDcs.Split(',');
|
||
for (int idx = 0; idx < incDcs.Length; idx++)
|
||
{
|
||
if (!string.IsNullOrEmpty(incDcs[idx].ToString()))
|
||
{
|
||
incGridDcs.Add(incDcs[idx].ToString());
|
||
if (IsParentDc(incDcs[idx].ToString()))
|
||
{
|
||
ArrayList arrPopDcs = new ArrayList();
|
||
arrPopDcs = GetPopDcsForParent(incDcs[idx].ToString());
|
||
for (int pIdx = 0; pIdx < arrPopDcs.Count; pIdx++)
|
||
{
|
||
if (incGridDcs.IndexOf(arrPopDcs[pIdx].ToString()) == -1)
|
||
incGridDcs.Add(arrPopDcs[pIdx].ToString());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
string sourceDc = string.Empty;
|
||
ArrayList tabParentFlds = new ArrayList();
|
||
if (calledFrom == "LoadTab" || calledFrom == "FillGrid" || calledFrom == "AutoComplete")
|
||
{
|
||
if (includeDcs != string.Empty)
|
||
{
|
||
TStructDef.DcStruct tabDc = (TStructDef.DcStruct)tstStrObj.dcs[Convert.ToInt32(includeDcs) - 1];
|
||
tabParentFlds = tabDc.tabParentFields;
|
||
}
|
||
//incGridDcs.Clear();
|
||
if (calledFrom == "FillGrid")
|
||
{
|
||
int idx = tstStrObj.GetFillGridIndex("dc" + includeDcs.ToString());
|
||
includeDcs = "";
|
||
if (idx != -1)
|
||
{
|
||
TStructDef.FGStruct fg = (TStructDef.FGStruct)tstStrObj.fgs[idx];
|
||
if (fg.fgSourceDC != "")
|
||
sourceDc = fg.fgSourceDC.Substring(2);
|
||
}
|
||
}
|
||
}
|
||
|
||
//loop for constructing the field value xml based on the frame no, row no and field order
|
||
foreach (TStructDef.DcStruct dc in tstStrObj.dcs)
|
||
{
|
||
string dcNo = Convert.ToString(dc.frameno);
|
||
|
||
//This condition will construct xml for all the non grids in the given tstruct,
|
||
//if the includeDcs contains any grid dc then that dc also will be included in the xml construction.
|
||
if (condition == "NG")
|
||
{
|
||
//– Only non grid data will be sent in input xml.For all grid dcs only row count will be sent.
|
||
if (dc.isgrid)
|
||
{
|
||
//For getdep web service, the other grid dcs rowcount also should be sent.
|
||
//if ((calledFrom == "GetDep" || calledFrom == "GetDependents") && incGridDcs.IndexOf(dcNo) == -1)
|
||
if (calledFrom == "GetDep" && incGridDcs.IndexOf(dcNo) == -1)
|
||
{
|
||
int rCnt = GetDcRowCount(dcNo);
|
||
dsDataXML.Append("<dc" + dcNo + " type=dc >" + rCnt + "</dc" + dcNo + ">");
|
||
}
|
||
|
||
//Refer bug - IWA-C-0000024
|
||
//Removed LoadData as current dc data should not be sent to webservice- This will result in tabdata bringing empty row.
|
||
if (calledFrom != "FillGrid" && calledFrom != "AutoComplete" && calledFrom != "axpbutton" && incGridDcs.IndexOf(dcNo) == -1)
|
||
continue;
|
||
}
|
||
}
|
||
|
||
int rowCnt = 0;
|
||
if (dc.isgrid)
|
||
{
|
||
rowCnt = GetDcRowCount(dcNo);
|
||
if (rowCnt == 0) rowCnt = 1;
|
||
if (calledFrom != "PickList" && dc.DCHasDataRows == false && calledFrom != "RefreshDc")
|
||
continue;
|
||
}
|
||
|
||
DataTable thisDataTable = dsDataSet.Tables["dc" + dcNo];
|
||
try
|
||
{
|
||
if (calledFrom != "AutoComplete" && calledFrom != "axpbutton")
|
||
{
|
||
DataRow[] rows;
|
||
rows = thisDataTable.Select("axp__isGrdVld" + dcNo + " = 'false'"); // axp__isGrdVld is Column Name
|
||
foreach (DataRow r in rows)
|
||
thisDataTable.Rows.Remove(r);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
//catch block is not handlink because - we are skipping the rows which does not contains axp__isGrdVld+dcno column
|
||
}
|
||
bool isAddRow = false;
|
||
|
||
if (calledFrom == "RefreshDc" && thisDataTable.Rows.Count == 0)
|
||
{
|
||
DataRow newRow = thisDataTable.NewRow();
|
||
newRow["axp__rowno"] = 1;
|
||
newRow["axp__delrow"] = 0;
|
||
thisDataTable.Rows.Add(newRow);
|
||
thisDataTable.AcceptChanges();
|
||
isAddRow = true;
|
||
}
|
||
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
|
||
foreach (DataRow dr in thisDataTable.Rows)
|
||
{
|
||
|
||
int rowNo = Convert.ToInt32(dr["axp__rowno"]);
|
||
|
||
if (calledFrom != "AutoComplete" && calledFrom != "axpbutton" && thisDataTable.Columns.Contains(Constants.AXPISROWVALID + dcNo) && dr[Constants.AXPISROWVALID + dcNo].ToString() == "false")
|
||
continue;
|
||
|
||
if (calledFrom == "LoadTab" && dcNo == includeDcs)
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, false, "");
|
||
else if (calledFrom == "FillGrid" && dc.isgrid && dcNo == sourceDc)
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, false, "");
|
||
else if (calledFrom == "LoadTab" && dc.isgrid && incGridDcs.IndexOf(dcNo) != -1)
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, false, "");
|
||
else if ((calledFrom == "LoadTab" || calledFrom == "FillGrid" || calledFrom == "AutoComplete") && dc.isgrid && dcNo != includeDcs)
|
||
DSFieldValueXMLHelperPerf(dcNo, rowNo, startIdx, endIdx, dr, tabParentFlds);
|
||
else
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, false, "");
|
||
|
||
}
|
||
|
||
if (isAddRow && calledFrom == "RefreshDc")
|
||
{
|
||
thisDataTable.Rows.RemoveAt(0);
|
||
isAddRow = false;
|
||
}
|
||
}
|
||
|
||
fieldValueXml = dsDataXML.ToString();
|
||
|
||
}
|
||
private void DSFieldValueXMLPerf(string frameNum, string ActiveRowNo, ArrayList depFields, string fldDepGridDcs, Dictionary<string, string> includeDcRows, string includeDcs)
|
||
{
|
||
int fNo = -1;
|
||
bool isNumber = true;
|
||
bool IsDcInclude = false;
|
||
string[] refreshdc = new string[10];
|
||
if (includeDcs != string.Empty)
|
||
refreshdc = includeDcs.Split(',');
|
||
|
||
try
|
||
{
|
||
fNo = int.Parse(frameNum);
|
||
isNumber = true;
|
||
}
|
||
catch
|
||
{
|
||
isNumber = false;
|
||
}
|
||
|
||
if (isNumber)
|
||
frameNum = "F" + frameNum;
|
||
|
||
dsDataXML.Length = 0;
|
||
|
||
//loop for constructing the field value xml based on the frame no, row no and field order
|
||
foreach (TStructDef.DcStruct dc in tstStrObj.dcs)
|
||
{
|
||
string dcNo = Convert.ToString(dc.frameno);
|
||
|
||
string incRowsStr = string.Empty;
|
||
ArrayList includeRows = new ArrayList();
|
||
if (includeDcRows.ContainsKey(dcNo))
|
||
{
|
||
IsDcInclude = true;
|
||
includeDcRows.TryGetValue(dcNo, out incRowsStr);
|
||
string[] incRows = incRowsStr.Split(',');
|
||
for (int j = 0; j < incRows.Length; j++)
|
||
{
|
||
if (incRows[j] != "")
|
||
includeRows.Add(Convert.ToInt32(incRows[j].ToString()));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
IsDcInclude = false;
|
||
if (Array.IndexOf(refreshdc, dcNo) > -1)
|
||
IsDcInclude = true;
|
||
else if (!dc.isgrid)
|
||
IsDcInclude = true;
|
||
string[] depDcs = fldDepGridDcs.Split(',');
|
||
for (int dIdx = 0; dIdx < depDcs.Length; dIdx++)
|
||
{
|
||
if (depDcs[dIdx].ToString() == dcNo)
|
||
{
|
||
IsDcInclude = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
|
||
int rowCnt = 0;
|
||
if (dc.isgrid)
|
||
{
|
||
if (dc.frameno == fNo || IsDcInclude)
|
||
{
|
||
rowCnt = GetDcRowCount(dcNo);
|
||
if (rowCnt == 0) rowCnt = 1;
|
||
if (dc.DCHasDataRows == false)
|
||
continue;
|
||
}
|
||
else
|
||
continue;
|
||
}
|
||
|
||
int ActRowNo = Convert.ToInt32(ActiveRowNo);
|
||
|
||
DataTable thisDataTable = dsDataSet.Tables["dc" + dcNo];
|
||
int subRowNo = 0;
|
||
//This loop will run through all the rows in the grid, if the given rowno is same as activerowno, then it will construct for all the fields
|
||
//Else it will construct xml only for the fields given in the depFields parameter.
|
||
foreach (DataRow dr in thisDataTable.Rows)
|
||
{
|
||
|
||
|
||
int rowNo = Convert.ToInt32(dr["axp__rowno"]);
|
||
|
||
//If a non grid field is changed and a grid has record in add panel(Invalid row) it should not be sent to web-service
|
||
if (frameNum != "F" + dc.frameno.ToString() && dc.isgrid && dr[Constants.AXPISROWVALID + dcNo].ToString() == "false")
|
||
continue;
|
||
|
||
if ((Array.IndexOf(refreshdc, dcNo) > -1) && (dc.frameno != fNo))
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, false, "");
|
||
else if (!dc.isgrid)
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, false, "");
|
||
else if (dc.frameno == fNo && rowNo == ActRowNo)
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, false, "");
|
||
else if (IsDcInclude && includeRows.IndexOf(rowNo) != -1)
|
||
{
|
||
if (dc.ispopgrid)
|
||
{
|
||
subRowNo++;
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, dc.ispopgrid, subRowNo.ToString());
|
||
}
|
||
else
|
||
{
|
||
DSFieldValueXMLHelper(dcNo, rowNo, startIdx, endIdx, dr, false, "");
|
||
}
|
||
}
|
||
else
|
||
DSFieldValueXMLHelperPerf(dcNo, rowNo, startIdx, endIdx, dr, depFields);
|
||
}
|
||
}
|
||
|
||
fieldValueXml = dsDataXML.ToString();
|
||
}
|
||
|
||
private void CreateFieldValueXml(string frameNum, string parDcNo, int ParRowNo, string popDcNo, int popRowNo)
|
||
{
|
||
DSFieldValueXML(frameNum, parDcNo, ParRowNo, popDcNo, popRowNo);
|
||
return;
|
||
}
|
||
|
||
public DataTable CreateDataTable()
|
||
{
|
||
return new DataTable();
|
||
}
|
||
|
||
/// <summary>
|
||
/// This method loops through the lists and construct the field value xml.
|
||
/// and updates the object variable “PopfieldValueXml”.
|
||
/// </summary>
|
||
private void CreatePopFieldValueXml(ArrayList fldArray, ArrayList fldValueArray, ArrayList fldDeletedArray, string frameNum, string pframeno, string maxRows, ArrayList popRows)
|
||
{
|
||
|
||
string fValue = string.Empty;
|
||
frameNum = "F" + frameNum;
|
||
StringBuilder fldXml = new StringBuilder();
|
||
StringBuilder popFldXml = new StringBuilder();
|
||
string rnList = "";
|
||
popFldXml.Append("<row>");
|
||
for (int i = 0; i < fieldName.Count; i++)
|
||
{
|
||
if (fieldControlName[i].ToString().IndexOf(frameNum.ToString()) == -1)
|
||
{
|
||
fldXml.Append("<" + fieldName[i] + ">");
|
||
fValue = CheckSpecialChars(fieldValue[i].ToString());
|
||
fldXml.Append(fValue);
|
||
fldXml.Append("</" + fieldName[i] + ">");
|
||
}
|
||
else
|
||
{
|
||
popFldXml.Append("<" + fieldName[i] + ">");
|
||
fValue = CheckSpecialChars(fieldValue[i].ToString());
|
||
popFldXml.Append(fValue);
|
||
popFldXml.Append("</" + fieldName[i] + ">");
|
||
}
|
||
}
|
||
|
||
popFGFieldValueXml = "";
|
||
if (popFldXml.ToString() == "") popFldXml.Append("<row>");
|
||
popFGFieldValueXml = "<GridList rnlist=\"" + rnList.ToString() + "\" mrno=\"" + maxRows.ToString() + "\" prno=\"" + pframeno.ToString() + "\">" + popFldXml.ToString() + "</row></GridList>" + "<FieldList>" + fgFieldValueXml.ToString() + "</FieldList>";
|
||
}
|
||
|
||
/// <summary>
|
||
/// function for replacing the special characters in a given string.
|
||
/// </summary>
|
||
/// <param name="str"></param>
|
||
/// <returns></returns>
|
||
/// <remarks></remarks>
|
||
private string CheckSpecialChars(string str)
|
||
{
|
||
//hack: The below line is used to make sure that the & in & is not converted inadvertantly
|
||
// for other chars this scenario will not come as it does not contains the same char.
|
||
str = Regex.Replace(str, "&", "&");
|
||
str = Regex.Replace(str, """, "“");
|
||
str = Regex.Replace(str, "\n", "<br>");
|
||
str = Regex.Replace(str, "&", "&");
|
||
str = Regex.Replace(str, "<", "<");
|
||
str = Regex.Replace(str, ">", ">");
|
||
str = Regex.Replace(str, "'", "'");
|
||
str = Regex.Replace(str, "\"", """);
|
||
str = Regex.Replace(str, "’", "'");
|
||
str = Regex.Replace(str, "“", """);
|
||
str = Regex.Replace(str, "”", """);
|
||
str = Regex.Replace(str, "™", "™");
|
||
str = Regex.Replace(str, "®", "®");
|
||
|
||
str = str.Replace((char)160, ' ');
|
||
|
||
if (str == defaultDateStr)
|
||
str = "";
|
||
return str;
|
||
}
|
||
|
||
private string GetDbFieldName(string fieldCompName, string dbRowNo)
|
||
{
|
||
if (dbRowNo.Length == 1)
|
||
dbRowNo = "00" + dbRowNo;
|
||
else if (dbRowNo.Length == 2)
|
||
dbRowNo = "0" + dbRowNo;
|
||
|
||
int fIndx = fieldCompName.LastIndexOf("F");
|
||
if (fIndx != -1)
|
||
{
|
||
string fldDcNo = fieldCompName.Substring(fIndx + 1);
|
||
string dbFldName = fieldCompName.Substring(0, fIndx - 3);
|
||
string newCompName = dbFldName + dbRowNo + "F" + fldDcNo;
|
||
return newCompName;
|
||
}
|
||
else
|
||
{
|
||
if (fieldCompName.StartsWith("dc") && dbRowNo == "0-1")
|
||
return "dc";
|
||
else
|
||
return fieldCompName;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// This method for for updating the existing field values and adding any new values.
|
||
/// Note: Only grid field values can be added and deleted.
|
||
/// </summary>
|
||
/// <param name="fldArray"></param>
|
||
/// <param name="fldValueArray"></param>
|
||
/// <param name="deletedArray"></param>
|
||
public void UpdateDataList(ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList deletedArray)
|
||
{
|
||
|
||
for (int j = 0; j < fldArray.Count; j++)
|
||
{
|
||
if (fldArray[j] != null)
|
||
{
|
||
if (fldValueArray[j].ToString() == defaultDateStr)
|
||
fldValueArray[j] = "";
|
||
|
||
string fldname = string.Empty; string frmNum = string.Empty; string fldRowNo = string.Empty;
|
||
string newCompName = GetDbFieldName(fldArray[j].ToString(), fldDbRowNo[j].ToString());
|
||
|
||
if (newCompName == "dc")
|
||
{
|
||
string[] dcData = fldValueArray[j].ToString().Split('♦');
|
||
string newRowCnt = dcData[0];
|
||
string changedRows = dcData[1];
|
||
if (changedRows != "")
|
||
{
|
||
SetDbRows(changedRows, fldArray[j].ToString().Substring(2), tstStrObj, "");
|
||
}
|
||
|
||
UpdateRowCount(fldArray[j].ToString(), newRowCnt);
|
||
continue;
|
||
}
|
||
|
||
int lastIndex = newCompName.LastIndexOf('F');
|
||
if (lastIndex != -1)
|
||
{
|
||
fldname = newCompName.Substring(0, lastIndex - 3);
|
||
fldRowNo = newCompName.Substring(lastIndex - 3, 3);
|
||
frmNum = newCompName.Substring(lastIndex + 1);
|
||
}
|
||
else
|
||
{
|
||
fldname = newCompName.Substring(0, newCompName.Length - 5);
|
||
fldRowNo = newCompName.Substring(lastIndex - 3, 3);
|
||
frmNum = newCompName.Substring(newCompName.Length - 2);
|
||
}
|
||
|
||
//Update the dc dchasdatarowws property.
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[Convert.ToInt32(frmNum) - 1];
|
||
if (dc.isgrid)
|
||
{
|
||
if (!dc.DCHasDataRows)
|
||
{
|
||
//Refer bugid- AXP-C-0000136
|
||
//If the row comes from client due to expression eval for pop up grid row, do not mark it valid
|
||
var valIdx = fldArray.IndexOf("axp__isGrdVld" + frmNum + fldRowNo + "F" + frmNum);
|
||
if (valIdx != -1 && fldValueArray[valIdx].ToString() == "false")
|
||
{
|
||
//In case of grid(pop) a new row value will be sent after expression evaluation but the row is not valid. In this case the dchasDataRows should not be changed to true.
|
||
}
|
||
else
|
||
{
|
||
dc.DCHasDataRows = true;
|
||
tstStrObj.dcs[Convert.ToInt32(frmNum) - 1] = dc;
|
||
}
|
||
}
|
||
}
|
||
|
||
//int index = fieldControlName.IndexOf(newCompName);
|
||
// int index = GetFldIndex(Convert.ToInt32(frmNum), fldname, Convert.ToInt32(fldDbRowNo[j]));
|
||
string newFldValue = fldValueArray[j].ToString();
|
||
|
||
//TODO: The same code is there in the TstructData constructor, and Jsontoarray
|
||
//if (fldname.ToLower() == "axpcurrencydec")
|
||
// CheckAxpCurrDec(fldname, newFldValue);
|
||
|
||
if (newCompName.StartsWith("axp_recid") && newFldValue == "") newFldValue = "0";
|
||
|
||
string tmpFldVal = string.Empty;
|
||
string tmpFldIdVal = string.Empty;
|
||
|
||
if (newCompName != string.Empty)
|
||
{
|
||
if (newFldValue.Contains("¿"))
|
||
{
|
||
string[] idVal = newFldValue.Split('¿');
|
||
tmpFldVal = idVal[1];
|
||
tmpFldIdVal = idVal[0];
|
||
}
|
||
else
|
||
tmpFldVal = newFldValue.ToString();
|
||
}
|
||
DSSubmit(fldname, Convert.ToInt32(fldDbRowNo[j].ToString()), tmpFldVal, tmpFldIdVal);
|
||
}
|
||
}
|
||
|
||
// For deleting the fields from the list.
|
||
for (int k = 0; k < deletedArray.Count; k++)
|
||
{
|
||
int fIdx = deletedArray[k].ToString().IndexOf("F");
|
||
string delRowNo = deletedArray[k].ToString().Substring(0, fIdx);
|
||
string delDcNo = deletedArray[k].ToString().Substring(fIdx + 1);
|
||
int tmpRowCnt = GetActualDcRowCount(delDcNo);//GetDcRowCount(delDcNo);//Refer Bug: AGI003750
|
||
if (tmpRowCnt == 1 && (delRowNo == "001" || delRowNo == "1"))
|
||
{
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[Convert.ToInt32(delDcNo) - 1];
|
||
dc.DCHasDataRows = false;
|
||
tstStrObj.dcs[Convert.ToInt32(delDcNo) - 1] = dc;
|
||
}
|
||
if (recordID != "0" && recordID != "")
|
||
DeleteRowInFldArrays(delDcNo, delRowNo);
|
||
else
|
||
DeleteRowInFldArrays(delDcNo, delRowNo);
|
||
|
||
tmpRowCnt = tmpRowCnt - 1;
|
||
if (tmpRowCnt >= 0)
|
||
UpdateRowCount("DC" + delDcNo, "DC" + delDcNo + "~" + tmpRowCnt);
|
||
}
|
||
}
|
||
|
||
private int GetActualDcRowCount(string dcNo)
|
||
{
|
||
int rowCount = 0;
|
||
DataTable dt = dsDataSet.Tables["dc" + dcNo];
|
||
if (dt.Rows.Count > 0)
|
||
{
|
||
rowCount = dt.Select("axp__isGrdVld" + dcNo + " = ''").Count();
|
||
}
|
||
return rowCount;
|
||
}
|
||
|
||
private string GetFrameNo(string fieldId)
|
||
{
|
||
return fieldId.Substring(fieldId.LastIndexOf("F") + 1);
|
||
}
|
||
|
||
private int GetDCRowCntIndex(string dcNo)
|
||
{
|
||
int index = -1;
|
||
for (int i = 0; i < dcRowCntVals.Count; i++)
|
||
{
|
||
string[] dcName = dcRowCntVals[i].ToString().Split('~');
|
||
if (dcName[0] == dcNo)
|
||
index = i;
|
||
}
|
||
return index;
|
||
}
|
||
|
||
private ArrayList GetSubGridDcsInTabDC(TStructDef strObj, string TabDcNo)
|
||
{
|
||
ArrayList subGridDcs = new ArrayList();
|
||
for (int i = 0; i < strObj.popdcs.Count; i++)
|
||
{
|
||
if (TabDcNo == ((TStructDef.PopDcStruct)(strObj.popdcs[i])).pdcno.ToString())
|
||
{
|
||
subGridDcs.Add(((TStructDef.PopDcStruct)(strObj.popdcs[i])).frameno);
|
||
}
|
||
}
|
||
return subGridDcs;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to parse the memvar node from the json and update the memvar arrays
|
||
/// </summary>
|
||
/// <param name="jsonData"></param>
|
||
/// <param name="calledFrom"></param>
|
||
public void ParseMemVarNode(string jsonData, string calledFrom)
|
||
{
|
||
jsonData = jsonData.Replace("*$*", "♦");
|
||
jsonData = jsonData.Replace("\\", ";bkslh");
|
||
string[] resval = jsonData.Split('♦');
|
||
StringBuilder dataJson = new StringBuilder();
|
||
if (jsonData == string.Empty)
|
||
return;
|
||
|
||
for (int j = 0; j < resval.Length; j++)
|
||
{
|
||
JArray memVarNode = null;
|
||
try
|
||
{
|
||
JObject tstData = JObject.Parse(resval[j]);
|
||
memVarNode = (JArray)tstData["memvar"];
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("ParseMemVarNode function -" + ex.Message, sessionid, "Exception-" + transid, "new");
|
||
}
|
||
|
||
if (memVarNode != null)
|
||
{
|
||
for (int m = 0; m < memVarNode.Count; m++)
|
||
{
|
||
string memVarName = string.Empty;
|
||
string memVarValue = string.Empty;
|
||
string memVarType = string.Empty;
|
||
|
||
Dictionary<string, string> values = JsonConvert.DeserializeObject<Dictionary<string, string>>(memVarNode[m].ToString());
|
||
|
||
if (values.ContainsKey("n"))
|
||
memVarName = values["n"];
|
||
if (values.ContainsKey("v"))
|
||
memVarValue = values["v"];
|
||
if (values.ContainsKey("t"))
|
||
memVarType = values["t"];
|
||
|
||
memVarValue = CheckSpecialChars(memVarValue);
|
||
int idx = memVarNames.IndexOf(memVarName);
|
||
if (idx == -1)
|
||
{
|
||
memVarNames.Add(memVarName);
|
||
memVarValues.Add(memVarValue);
|
||
memVarTypes.Add(memVarType);
|
||
}
|
||
else
|
||
{
|
||
memVarNames[idx] = memVarName;
|
||
memVarValues[idx] = memVarValue;
|
||
memVarTypes[idx] = memVarType;
|
||
}
|
||
}
|
||
|
||
//Construct the fieldvaluexml for memvar node and update the global variable
|
||
ConstructMemVarNode();
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to construct the field value xml for memvar nodes from the arrays
|
||
/// </summary>
|
||
public void ConstructMemVarNode()
|
||
{
|
||
StringBuilder strXml = new StringBuilder();
|
||
//strXml.Append("<axp_memvars>");
|
||
for (int i = 0; i < memVarNames.Count; i++)
|
||
{
|
||
strXml.Append("<" + memVarNames[i].ToString() + " t='" + memVarTypes[i].ToString() + "'>" + memVarValues[i].ToString() + "</" + memVarNames[i].ToString() + ">");
|
||
}
|
||
//strXml.Append("</axp_memvars>");
|
||
memVarsData = strXml.ToString();
|
||
|
||
}
|
||
|
||
public void JsonToArray(string jsonResult, TStructDef strObj, string tabDcNo, string calledFrom)
|
||
{
|
||
|
||
|
||
ChangedDcs.Clear();
|
||
depFormatDcs.Clear();
|
||
if (jsonResult == string.Empty) return;
|
||
ArrayList tabDcs = new ArrayList();
|
||
AxDepArrays = new StringBuilder();
|
||
|
||
if (tabDcNo != "")
|
||
{
|
||
tabDcs = GetSubGridDcsInTabDC(strObj, tabDcNo);
|
||
tabDcs.Add(tabDcNo);
|
||
}
|
||
|
||
//Get the non grid experssion dependent fields if the call is done from a grid field.
|
||
ArrayList fldExpDeps = new ArrayList();
|
||
if (calledFrom == "GetDepPerf")
|
||
fldExpDeps = GetFldExpDependents(AxActDepField);
|
||
|
||
// dcRowCntVals = new ArrayList();
|
||
jsonResult = jsonResult.Replace("*$*", "♦");
|
||
jsonResult = jsonResult.Replace("\\", ";bkslh");
|
||
string[] resval = jsonResult.Split('♦');
|
||
StringBuilder dataJson = new StringBuilder();
|
||
tabJson = new StringBuilder();
|
||
string dcHasDataRowsStr = string.Empty;
|
||
string tabJsonPrefix = "{\"data\": [";
|
||
string timeTakenJson = string.Empty;
|
||
|
||
//Sub grid for GetDep related variables.
|
||
bool isDcPopGrid = false;
|
||
int dsRowNo = 0;
|
||
|
||
for (int j = 0; j < resval.Length; j++)
|
||
{
|
||
//TODO: all other json nodes should be handled in the json parsing
|
||
JArray Data = null;
|
||
try
|
||
{
|
||
JObject tstData = JObject.Parse(resval[j]);
|
||
Data = (JArray)tstData["data"];
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("JsonToArray function -" + ex.Message, sessionid, "Exception-" + transid, "new");
|
||
logobj.CreateLog("JsonData -" + jsonResult, sessionid, "Exception-" + transid, "");
|
||
//throw ex;
|
||
}
|
||
|
||
if (Data != null)
|
||
{
|
||
string fName = string.Empty;
|
||
string fValue = string.Empty;
|
||
string changedRows = string.Empty;
|
||
string delRows = string.Empty;
|
||
string rowNo = string.Empty;
|
||
string fDatatype = string.Empty;
|
||
string name = string.Empty;
|
||
string fldName = string.Empty;
|
||
string fldFrameNo = string.Empty;
|
||
string frmNum = string.Empty;
|
||
string frowValues = string.Empty;
|
||
string fldIdValues = string.Empty;
|
||
string idCol = string.Empty;
|
||
string masterRow = string.Empty;
|
||
string comboVal = string.Empty;
|
||
string comboFld = string.Empty;
|
||
string comboIdCol = "0";
|
||
string dcNo = "0";
|
||
string dpmStr = string.Empty;
|
||
string dpValues = string.Empty;
|
||
string idVal = string.Empty;
|
||
string oldIdVal = string.Empty;
|
||
string rowFromJson = string.Empty;
|
||
int DCPriorRowCount = 0;
|
||
string fillGridName = string.Empty;
|
||
StringBuilder ddlVals = new StringBuilder();
|
||
StringBuilder ddlDpVals = new StringBuilder();
|
||
bool isTabDc = false;
|
||
for (int m = 0; m < Data.Count; m++)
|
||
{
|
||
fDatatype = "";
|
||
idCol = "";
|
||
changedRows = string.Empty;
|
||
delRows = string.Empty;
|
||
masterRow = string.Empty;
|
||
|
||
dpValues = "";
|
||
string dcHasRows = string.Empty;
|
||
Dictionary<string, string> values = JsonConvert.DeserializeObject<Dictionary<string, string>>(Data[m].ToString());
|
||
|
||
|
||
if (values.ContainsKey("t"))
|
||
fDatatype = values["t"];
|
||
if (values.ContainsKey("n"))
|
||
fName = values["n"];
|
||
if (values.ContainsKey("v"))
|
||
fValue = values["v"];
|
||
if (values.ContainsKey("cr"))
|
||
changedRows = values["cr"];
|
||
if (values.ContainsKey("fg"))
|
||
fillGridName = values["fg"];
|
||
if (values.ContainsKey("dr"))
|
||
delRows = values["dr"];
|
||
if (values.ContainsKey("mr"))
|
||
masterRow = values["mr"];
|
||
if (values.ContainsKey("idcol"))
|
||
idCol = values["idcol"];
|
||
if (values.ContainsKey("id"))
|
||
idVal = values["id"];
|
||
if (values.ContainsKey("oldid"))
|
||
oldIdVal = values["oldid"];
|
||
if (values.ContainsKey("r"))
|
||
{
|
||
rowNo = values["r"];
|
||
if (rowNo.Length == 1)
|
||
rowNo = "00" + rowNo;
|
||
else if (rowNo.Length == 2)
|
||
rowNo = "0" + rowNo;
|
||
rowFromJson = rowNo;
|
||
}
|
||
if (values.ContainsKey("dp"))
|
||
dpValues = values["dp"];
|
||
if (values.ContainsKey("dpm"))
|
||
dpmStr = values["dpm"];
|
||
|
||
|
||
string rowValues = string.Empty;
|
||
if (idCol == "no" || idCol == "")
|
||
idCol = "0";
|
||
else
|
||
idCol = "1";
|
||
|
||
if (fName != string.Empty)
|
||
{
|
||
//This condition will get the fields in the tab dc which have master row true.
|
||
if (masterRow == "1" && dcNo == tabDcNo)
|
||
{
|
||
if (AxMasterRowFlds.IndexOf(fName) == -1)
|
||
AxMasterRowFlds.Add(fName);
|
||
}
|
||
|
||
fValue = fValue.Replace("^^dq", """);
|
||
fValue = fValue.Replace(";bkslh", "\\");
|
||
|
||
//To copy the dc2_referimage file from the given path to Axpert Session folder
|
||
if ((fName.StartsWith("dc") && fName.ToLower().EndsWith("_imagepath")))
|
||
hasImagePath = true;
|
||
if (fName.ToLower().Contains("dc2_referimages") && fValue != string.Empty)
|
||
GetReferedFiles(fValue, hasImagePath);
|
||
|
||
//TODO: Same code is available in TStructData constructor and UpdateDataList.
|
||
//if (fName.ToLower() == "axpcurrencydec")
|
||
// CheckAxpCurrDec(fName, fValue);
|
||
|
||
if (fDatatype != "c" && fDatatype != "dv")
|
||
dpmStr = string.Empty;
|
||
|
||
string rowVal = "";
|
||
|
||
if (fDatatype == "c" || fDatatype == "cl" || fDatatype == "rg")
|
||
{
|
||
comboVal = fValue;
|
||
comboFld = fName;
|
||
comboIdCol = idCol;
|
||
}
|
||
else if (fDatatype == "dv")
|
||
{
|
||
rowVal = fValue;
|
||
if (rowValues == "")
|
||
rowValues = rowVal;
|
||
else
|
||
rowValues += "" + rowVal;
|
||
|
||
string[] temp = rowVal.Split('?');
|
||
if (temp.Length <= 3 && comboVal == string.Empty)
|
||
{
|
||
StringBuilder strVal = new StringBuilder();
|
||
for (int i = 0; i < temp.Length; i++)
|
||
{
|
||
if (temp[i].ToString() != string.Empty)
|
||
strVal.Append(temp[i].ToString());
|
||
}
|
||
if (strVal.ToString().ToLower() == "yesno" || strVal.ToString().ToLower() == "noyes")
|
||
{
|
||
//To set the default value of checkbox in the grid dc to "no".
|
||
fValue = "no";
|
||
}
|
||
}
|
||
|
||
if (dpValues != string.Empty)
|
||
{
|
||
string[] dpVals = dpValues.Split('~');
|
||
string[] depFlds = dpmStr.Split(',');
|
||
string cbVal = string.Empty;
|
||
if (comboIdCol == "1")
|
||
cbVal = fValue.Substring(fValue.IndexOf("~") + 1);
|
||
else
|
||
cbVal = fValue;
|
||
cbVal = CheckSpecialChars(cbVal);
|
||
for (int depIdx = 0; depIdx < depFlds.Length; depIdx++)
|
||
{
|
||
AxDepArrays.Append("ComboParentField.push(\"" + comboFld + "\");ComboParentValue.push(\"" + cbVal + "\");ComboDepField.push(\"" + depFlds[depIdx] + "\");ComboDepValue.push(\"" + dpVals[depIdx] + "\");");
|
||
}
|
||
|
||
}
|
||
}
|
||
else if (fDatatype == "dc")
|
||
{
|
||
if (values.ContainsKey("hasdatarows"))
|
||
dcHasRows = values["hasdatarows"];
|
||
|
||
comboFld = "";
|
||
string dcRowCount = fName + "~" + fValue;
|
||
dcNo = fName.Substring(2);
|
||
DCPriorRowCount = 0;
|
||
//Code to avoid tabbed dc and its sub grid in the construction of json for GetTabData.
|
||
int tabIndx = tabDcs.IndexOf(dcNo);
|
||
if (tabIndx != -1)
|
||
isTabDc = true;
|
||
else
|
||
isTabDc = false;
|
||
|
||
if (strObj.IsDcFormatGrid(Convert.ToInt32(dcNo)))
|
||
{
|
||
depFormatDcs.Add(dcNo);
|
||
isTabDc = true;
|
||
}
|
||
|
||
if (isTabDc)
|
||
{
|
||
dcHasDataRowsStr = "{\"n\":\"DC" + dcNo + "\",\"v\":\"" + fValue + "\",\"t\":\"dc\",\"hasdatarows\":\"" + dcHasRows + "\"}";
|
||
}
|
||
|
||
bool dcOldHasRows = false;
|
||
bool isGrid = IsDcGrid(dcNo, strObj);
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)tstStrObj.dcs[Convert.ToInt32(dcNo) - 1];
|
||
if (dc.ispopgrid)
|
||
isDcPopGrid = true;
|
||
else
|
||
isDcPopGrid = false;
|
||
if (isGrid)
|
||
{
|
||
if (dcHasRows != "")
|
||
{
|
||
dcOldHasRows = dc.DCHasDataRows;
|
||
if (dcHasRows == "yes")
|
||
dc.DCHasDataRows = true;
|
||
else
|
||
dc.DCHasDataRows = false;
|
||
tstStrObj.dcs[Convert.ToInt32(dcNo) - 1] = dc;
|
||
}
|
||
}
|
||
|
||
if (fValue == "0")
|
||
{
|
||
fValue = "1";
|
||
dcRowCount = fName + "~" + fValue;
|
||
}
|
||
|
||
if (isDcPopGrid && calledFrom == "GetDepPerf" && IsParentDc(AxActiveDc))
|
||
{
|
||
//Code to add the dr attribute recids to deleted row information.
|
||
if (delRows != string.Empty)
|
||
SetPopDeletedRows(dcNo, delRows);
|
||
// delete the old subgrid rows sent to the webservice for the getdep call
|
||
DeletePopRowsAfterDep();
|
||
AxSubGridRows = new ArrayList();
|
||
subWsRows = new ArrayList();
|
||
subDsRows = new ArrayList();
|
||
dsRowNo = 1;
|
||
//Since the full sub grid data will not be sent to the webservice,
|
||
//the row numbers will always start from 1 hence appending the rows to the grid.
|
||
DCPriorRowCount = GetDcRowCount(dcNo);
|
||
}
|
||
|
||
if (changedRows != "" && isGrid)
|
||
{
|
||
if (dcOldHasRows == false && dcHasRows == "yes")
|
||
changedRows = "d*," + changedRows;
|
||
if (ChangedDcs.IndexOf(dcNo) == -1)
|
||
ChangedDcs.Add(dcNo);
|
||
|
||
//If the dc has fill grid, and if the fillgrid condition is INIT or AOWE
|
||
//then the existing rows should be cleared and added.
|
||
//The same condition is also added in ExecData in process.js
|
||
int fgIdx = GetDcFillGridIndex(fName, fillGridName);
|
||
if (fgIdx != -1 && calledFrom != "ExecAction" && calledFrom != "AddRow")
|
||
{
|
||
TStructDef.FGStruct fg = (TStructDef.FGStruct)tstStrObj.fgs[fgIdx];
|
||
if (fg.FGCondition == Constants.INIT || fg.FGCondition == Constants.AOWE)
|
||
{
|
||
if (changedRows.IndexOf("d*") == -1)
|
||
changedRows = "d*," + changedRows;
|
||
if (IsParentDc(dcNo))
|
||
{
|
||
ArrayList arrPopDcs = new ArrayList();
|
||
arrPopDcs = GetPopDcsForParent(dcNo);
|
||
for (int pIdx = 0; pIdx < arrPopDcs.Count; pIdx++)
|
||
{
|
||
TStructDef.DcStruct pdc = (TStructDef.DcStruct)tstStrObj.dcs[Convert.ToInt32(arrPopDcs[pIdx].ToString()) - 1];
|
||
if (pdc.DCHasDataRows)
|
||
SetDbRows("d*", pdc.frameno.ToString(), tstStrObj, "");
|
||
|
||
}
|
||
}
|
||
}
|
||
else if (fg.FGCondition == Constants.APPEND && dcHasRows == "yes" && calledFrom == "Action")
|
||
{
|
||
DCPriorRowCount = 0;// GetDcRowCount(dcNo);
|
||
if (changedRows.IndexOf("d*") != -1)
|
||
dcRowCount = fName + "~" + (Convert.ToInt32(fValue));
|
||
else
|
||
dcRowCount = fName + "~" + (Convert.ToInt32(fValue) + GetDcRowCount(dcNo));
|
||
}
|
||
else if (fg.FGCondition == Constants.APPEND && dcOldHasRows)
|
||
{
|
||
DCPriorRowCount = GetDcRowCount(dcNo);
|
||
dcRowCount = fName + "~" + (Convert.ToInt32(fValue) + GetDcRowCount(dcNo));
|
||
}
|
||
}
|
||
|
||
if (dcHasRows == "yes" || (dcOldHasRows && dcHasRows == "no"))
|
||
{
|
||
//The cr attribute from the getdep will be ignored for subgrid
|
||
if (isDcPopGrid && calledFrom == "GetDepPerf" && IsParentDc(AxActiveDc))
|
||
continue;
|
||
SetDbRows(changedRows, dcNo, strObj, calledFrom);
|
||
}
|
||
}
|
||
else if (calledFrom == "FillGridMS" && isGrid && dcOldHasRows == false && dcHasRows == "yes")//Refer Bug: HEA000021-- Multy select fillgrid having hidden row its not adding based on srvice result.
|
||
{
|
||
SetDbRows("d*", dcNo, strObj, calledFrom);
|
||
}
|
||
UpdateRowCount(fName, dcRowCount);
|
||
}
|
||
else
|
||
{
|
||
//Code for setting default item value for auto select
|
||
comboFld = "";
|
||
}
|
||
|
||
//The isTabDc can be used for format grid dc, for returning the json without format grid data.
|
||
if (!isTabDc)
|
||
{
|
||
if (dataJson.ToString() == "")
|
||
dataJson.Append(Data[m].ToString());
|
||
else
|
||
dataJson.Append("," + Data[m].ToString());
|
||
}
|
||
else
|
||
{
|
||
|
||
if (dcHasDataRowsStr != "")
|
||
{
|
||
if (dataJson.ToString() == "")
|
||
dataJson.Append(dcHasDataRowsStr);
|
||
else
|
||
dataJson.Append("," + dcHasDataRowsStr);
|
||
|
||
dcHasDataRowsStr = string.Empty;
|
||
}
|
||
}
|
||
|
||
if (fDatatype == "dv")
|
||
{
|
||
ddlVals.Append(rowValues);
|
||
ddlVals.Append("♣");
|
||
ddlDpVals.Append(dpValues);
|
||
ddlDpVals.Append("♣");
|
||
DSUpdateRowValues(fName, Convert.ToInt32(rowNo) + DCPriorRowCount, ddlVals.ToString(), ddlDpVals.ToString(), masterRow, comboIdCol);
|
||
}
|
||
else
|
||
{
|
||
ddlVals = new StringBuilder();
|
||
if (fDatatype != "dc")
|
||
{
|
||
string rowFrmNo = string.Empty;
|
||
if (rowNo != "")
|
||
{
|
||
name = fName + rowNo + "F" + dcNo;
|
||
rowFrmNo = rowFrmNo + "F" + dcNo;
|
||
}
|
||
//If the get dependents is called on a grid field, then the below code will ignore all expression dependents in the non grid.
|
||
if (calledFrom == "GetDepPerf")
|
||
{
|
||
if (fldExpDeps.IndexOf(fName) != -1)
|
||
continue;
|
||
}
|
||
|
||
if (isDcPopGrid && calledFrom == "GetDepPerf" && IsParentDc(AxActiveDc))
|
||
{
|
||
dsRowNo = GetSubDsRowNo(Convert.ToInt32(rowNo), dcNo);
|
||
DSSubmit(fName, dsRowNo, fValue, idVal);
|
||
}
|
||
else
|
||
DSSubmit(fName, Convert.ToInt32(rowNo) + DCPriorRowCount, fValue, idVal);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
|
||
ParseJsonNodes(resval[j].ToString());
|
||
JArray timeTaken = null;
|
||
try
|
||
{
|
||
JObject tstData = JObject.Parse(resval[j]);
|
||
timeTaken = (JArray)tstData["timetaken"];
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
|
||
}
|
||
|
||
if (timeTaken != null)
|
||
{
|
||
timeTakenJson = resval[j].ToString() + "*$*";
|
||
continue;
|
||
}
|
||
|
||
if (dataJson.ToString() != "")
|
||
{
|
||
tabJson.Insert(0, tabJsonPrefix);
|
||
tabJson.Append(dataJson + "]}");
|
||
dataJson.Remove(0, dataJson.ToString().Length);
|
||
}
|
||
tabJson.Append(resval[j].ToString());
|
||
}
|
||
}
|
||
if (dataJson.ToString() != "")
|
||
{
|
||
tabJson.Insert(0, tabJsonPrefix);
|
||
tabJson.Append(dataJson + "]}");
|
||
dataJson.Remove(0, dataJson.ToString().Length);
|
||
tabJson.Insert(0, timeTakenJson);
|
||
}
|
||
|
||
//Call the function which parses thge memvar node and updates the arrays.
|
||
ParseMemVarNode(jsonResult, calledFrom);
|
||
}
|
||
|
||
|
||
//Function to get the exact rowno for the new row being added.
|
||
private int GetSubDsRowNo(int wsRowNo, string dcNo)
|
||
{
|
||
int dsRowNo = 0;
|
||
int idx = -1;
|
||
idx = subWsRows.IndexOf(wsRowNo);
|
||
if (idx == -1)
|
||
{
|
||
subWsRows.Add(wsRowNo);
|
||
dsRowNo = GetDcRowCount(dcNo) + 1;
|
||
subDsRows.Add(dsRowNo);
|
||
}
|
||
else
|
||
{
|
||
dsRowNo = (Int32)subDsRows[idx];
|
||
}
|
||
|
||
return dsRowNo;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function return true if the given dc is a parent dc.
|
||
/// </summary>
|
||
/// <param name="dcNo"></param>
|
||
/// <returns></returns>
|
||
private bool IsParentDc(string dcNo)
|
||
{
|
||
bool isParDc = false;
|
||
for (int i = 0; i < tstStrObj.popdcs.Count; i++)
|
||
{
|
||
if (dcNo == ((TStructDef.PopDcStruct)(tstStrObj.popdcs[i])).pdcno.ToString())
|
||
{
|
||
isParDc = true;
|
||
break;
|
||
}
|
||
}
|
||
return isParDc;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function returns array of popdcs defined for a given dc.
|
||
/// </summary>
|
||
/// <param name="dcNo"></param>
|
||
/// <returns></returns>
|
||
public ArrayList GetPopDcsForParent(string dcNo)
|
||
{
|
||
ArrayList arrPopDcs = new ArrayList();
|
||
for (int i = 0; i < tstStrObj.popdcs.Count; i++)
|
||
{
|
||
if (dcNo == ((TStructDef.PopDcStruct)(tstStrObj.popdcs[i])).pdcno.ToString())
|
||
{
|
||
arrPopDcs.Add(((TStructDef.PopDcStruct)(tstStrObj.popdcs[i])).frameno);
|
||
}
|
||
}
|
||
return arrPopDcs;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get the non grid expression dependents for a field.
|
||
/// </summary>
|
||
/// <param name="fName"></param>
|
||
/// <returns></returns>
|
||
private ArrayList GetFldExpDependents(string fName)
|
||
{
|
||
int idx = tstStrObj.GetFieldIndex(fName);
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
ArrayList fldExpDep = new ArrayList();
|
||
string[] fldDeps = fld.fieldDependents.Split(',');
|
||
for (int i = 0; i < fldDeps.Length; i++)
|
||
{
|
||
string depFldName = fldDeps[i].ToString();
|
||
string prefix = depFldName.Substring(0, 1);
|
||
int depIdx = tstStrObj.GetFieldIndex(depFldName.Substring(1));
|
||
if (depIdx != -1)
|
||
{
|
||
TStructDef.FieldStruct depFld = (TStructDef.FieldStruct)tstStrObj.flds[depIdx];
|
||
if (prefix == "e" && fld.fldframeno > depFld.fldframeno && !IsDcGrid(depFld.fldframeno.ToString(), tstStrObj))
|
||
{
|
||
fldExpDep.Add(fldDeps[i].ToString());
|
||
}
|
||
}
|
||
}
|
||
return fldExpDep;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get the dependent grid dc for a given field.
|
||
/// </summary>
|
||
/// <param name="fieldName"></param>
|
||
/// <returns></returns>
|
||
public ArrayList GetGridDepForField(string fieldName)
|
||
{
|
||
int idx = tstStrObj.GetFieldIndex(fieldName);
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
ArrayList sqlDepDc = new ArrayList();
|
||
string[] fldDeps = fld.fieldDependents.Split(',');
|
||
for (int i = 0; i < fldDeps.Length; i++)
|
||
{
|
||
string depFldName = fldDeps[i].ToString();
|
||
string prefix = depFldName.Substring(0, 1);
|
||
int depIdx = tstStrObj.GetFieldIndex(depFldName.Substring(1));
|
||
if (depIdx != -1)
|
||
{
|
||
TStructDef.FieldStruct depFld = (TStructDef.FieldStruct)tstStrObj.flds[depIdx];
|
||
if (prefix != "e" && sqlDepDc.IndexOf(depFld.fldframeno) == -1 && IsDcGrid(depFld.fldframeno.ToString(), tstStrObj))
|
||
{
|
||
sqlDepDc.Add(depFld.fldframeno);
|
||
}
|
||
}
|
||
}
|
||
return sqlDepDc;
|
||
}
|
||
|
||
private void StringToFile(string strDebugText)
|
||
{
|
||
if (!isDebugFileCreated)
|
||
{
|
||
logobj.CreateLog(strDebugText, HttpContext.Current.Session["nsessionid"].ToString(), "DebugValues", "new");
|
||
isDebugFileCreated = true;
|
||
}
|
||
logobj.CreateLog(strDebugText, HttpContext.Current.Session["nsessionid"].ToString(), "DebugValues", "");
|
||
|
||
}
|
||
|
||
private void ParseJsonNodes(string result)
|
||
{
|
||
if (result == string.Empty) return;
|
||
JArray cmdNode = null;
|
||
try
|
||
{
|
||
JObject tstData = JObject.Parse(result);
|
||
cmdNode = (JArray)tstData["command"];
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog("ParseJsonNodes function -" + ex.Message, sessionid, "Exception-" + transid, "new");
|
||
}
|
||
|
||
if (cmdNode != null)
|
||
{
|
||
string cmdName = string.Empty;
|
||
string cmdVal = string.Empty;
|
||
for (int i = 0; i < cmdNode.Count; i++)
|
||
{
|
||
Dictionary<string, string> values = JsonConvert.DeserializeObject<Dictionary<string, string>>(cmdNode[i].ToString());
|
||
|
||
|
||
for (int k = 0; k < values.Count; k++)
|
||
{
|
||
if (values.ContainsKey("cmd"))
|
||
cmdName = values["cmd"];
|
||
if (values.ContainsKey("cmdval"))
|
||
cmdVal = values["cmdval"];
|
||
|
||
if (cmdName == "newtrans" || cmdName == "copytrans")
|
||
{
|
||
recordid = "0";
|
||
recordID = "0";
|
||
rid = "0";
|
||
ModifyAsNewRecord();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
public string GetMasterRowFlds()
|
||
{
|
||
string AxFlds = string.Empty;
|
||
for (int i = 0; i < AxMasterRowFlds.Count; i++)
|
||
{
|
||
if (AxFlds == string.Empty)
|
||
AxFlds = AxMasterRowFlds[i].ToString();
|
||
else
|
||
AxFlds += "," + AxMasterRowFlds[i].ToString();
|
||
}
|
||
|
||
return AxFlds == string.Empty ? "Ax-NA" : AxFlds;
|
||
}
|
||
|
||
private void SetDbRowsOnLoad(string changedRows, string dcNo, TStructDef strObj)
|
||
{
|
||
int frameNo = Convert.ToInt32(dcNo);
|
||
string[] rowStr = changedRows.Split(',');
|
||
|
||
for (int i = 0; i < rowStr.Length; i++)
|
||
{
|
||
string firstChar = rowStr[i].Substring(0, 1);
|
||
string rowNo = rowStr[i].Substring(1);
|
||
if (firstChar == "d")
|
||
{
|
||
if (rowNo == "*")
|
||
DeleteAllRowsInDc(dcNo);
|
||
else
|
||
DeleteRowInFldArrays(dcNo, rowNo);
|
||
}
|
||
}
|
||
}
|
||
|
||
public void SetSubGridRows(string subGridRows)
|
||
{//The string will be in the format of popdc1~row1,row2,row3¿popdc2~row1,row2
|
||
if (subGridRows != string.Empty)
|
||
{
|
||
string[] subrows = subGridRows.Split('¿');
|
||
for (int i = 0; i < subrows.Length; i++)
|
||
{
|
||
if (subrows[i].ToString() != string.Empty)
|
||
{
|
||
AxSubGridRows.Add(subrows[i].ToString());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private void SetDbRows(string changedRows, string dcNo, TStructDef strObj, string calledFrom)
|
||
{
|
||
int frameNo = Convert.ToInt32(dcNo);
|
||
string[] rowStr = changedRows.Split(',');
|
||
|
||
for (int i = 0; i < rowStr.Length; i++)
|
||
{
|
||
if (rowStr[i] == string.Empty)
|
||
continue;
|
||
try
|
||
{
|
||
string firstChar = rowStr[i].Substring(0, 1);
|
||
string rowNo = rowStr[i].Substring(1);
|
||
if (firstChar == "d")
|
||
{
|
||
if (rowNo == "*")
|
||
DeleteAllRowsInDc(dcNo);
|
||
else
|
||
DeleteRowInFldArrays(dcNo, rowNo);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
logobj.CreateLog(ex.StackTrace, HttpContext.Current.Session["nsessionid"].ToString(), "Exception", "new");
|
||
}
|
||
}
|
||
}
|
||
|
||
private string GetMaxDcRowNo(string dcNo)
|
||
{
|
||
int rowNo = 0;
|
||
for (int i = 0; i < fieldControlName.Count; i++)
|
||
{
|
||
if (fieldFrameNo[i].ToString() == dcNo)
|
||
{
|
||
string rNo = fieldRowNo[i].ToString();
|
||
if (Convert.ToInt32(rNo) > rowNo)
|
||
rowNo = Convert.ToInt32(rNo);
|
||
}
|
||
}
|
||
|
||
return GetRowNoHelper(Convert.ToString(rowNo + 1));
|
||
}
|
||
|
||
private string GetFieldsRowNo(string fldId)
|
||
{
|
||
int idx = fldId.LastIndexOf("F");
|
||
if (idx != -1)
|
||
return fldId.Substring(idx - 3, 3);
|
||
else
|
||
return "000";
|
||
}
|
||
|
||
private string GetRowNoHelper(string rowNo)
|
||
{
|
||
if (rowNo.Length == 1)
|
||
rowNo = "00" + rowNo;
|
||
else if (rowNo.Length == 2)
|
||
rowNo = "0" + rowNo;
|
||
return rowNo;
|
||
}
|
||
|
||
private string CreateDataJson(Boolean IsDc, string dcNo, string Value, string rowCnt, string dataJson)
|
||
{
|
||
string dcDataRowsStr = string.Empty;
|
||
if (IsDc)
|
||
dcDataRowsStr = "{\"n\":\"DC" + dcNo + "\",\"v\":\"" + rowCnt + "\",\"t\":\"dc\"}";
|
||
else
|
||
dcDataRowsStr = "{\"n\":\"axp_recid" + dcNo + "\",\"v\":\"0\",\"r\":\"" + rowCnt + "\",\"t\":\"s\"}";
|
||
if (dataJson.ToString() != "")
|
||
dcDataRowsStr = "," + dcDataRowsStr;
|
||
|
||
return dcDataRowsStr;
|
||
}
|
||
|
||
public void UpdateRowCount(string dcNo, string newRowCnt)
|
||
{
|
||
int index = -1;
|
||
for (int i = 0; i < dcRowCntVals.Count; i++)
|
||
{
|
||
string[] dcRCnt = dcRowCntVals[i].ToString().Split('~');
|
||
if (dcRCnt[0].ToString().ToLower() == dcNo.ToLower())
|
||
{
|
||
index = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (index == -1)
|
||
dcRowCntVals.Add(newRowCnt);
|
||
else
|
||
dcRowCntVals[index] = newRowCnt;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get the fields index from the fieldControlName array.
|
||
/// </summary>
|
||
/// <param name="fieldName"></param>
|
||
/// <returns></returns>
|
||
public int GetFieldIndex(string fldName)
|
||
{
|
||
for (int j = 0; j < fieldControlName.Count; j++)
|
||
{
|
||
if (fieldControlName[j] != null)
|
||
{
|
||
if (fieldControlName[j].ToString() == fldName)
|
||
{
|
||
return j;
|
||
}
|
||
}
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
public string CallDeleteDataWS(string s)
|
||
{
|
||
DateTime stTime = DateTime.Now;
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
s = s + HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString() + "</Transaction>";
|
||
string result = null;
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
DateTime asStart = DateTime.Now;
|
||
result = objWebServiceExt.CallDeleteDataWS(transid, s);
|
||
DateTime asEnd = DateTime.Now;
|
||
if (result.ToLower().IndexOf("data deleted successfully") > -1)
|
||
RemoveAttachFromServer(s, transid);
|
||
//RemoveAttachFromDir("");
|
||
if (logTimeTaken)
|
||
{
|
||
webTime1 = asStart.Subtract(stTime).TotalMilliseconds;
|
||
webTime2 = DateTime.Now.Subtract(asEnd).TotalMilliseconds;
|
||
asbTime = asEnd.Subtract(asStart).TotalMilliseconds;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public string CallAddRowWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string s, string dcNo)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "", "NG", dcNo);
|
||
s += tstData.fieldValueXml + memVarsData;
|
||
s += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
s += "</sqlresultset>";
|
||
string result = string.Empty;
|
||
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallAddRowWS(transid, s, ires);
|
||
return result;
|
||
}
|
||
|
||
public string CallAddRowPerfWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string s, string dcNo)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
tstData.GetPerfFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "", "NG", dcNo);
|
||
s += WsPerfAddRowLoadDc(dcNo, "AddRow");
|
||
s += memVarsData;
|
||
s += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
s += "</sqlresultset>";
|
||
string result = string.Empty;
|
||
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallAddRowWS(transid, s, ires);
|
||
return result;
|
||
}
|
||
|
||
private string WsPerfAddRowLoadDc(string dcno, string calledFrom)
|
||
{
|
||
string iXml = string.Empty;
|
||
int dcFrame = int.Parse(dcno);
|
||
TStructDef.DcStruct pfldDc = (TStructDef.DcStruct)tstStrObj.dcs[dcFrame - 1];
|
||
if (pfldDc.dcPList != "")
|
||
{
|
||
string[] parentFlds = pfldDc.dcPList.Replace("~", ",").Split(',');
|
||
string globalVars = HttpContext.Current.Session["axGlobalVars"].ToString();
|
||
string userVars = HttpContext.Current.Session["axUserVars"].ToString();
|
||
for (int i = 0; i < parentFlds.Length; i++)
|
||
{
|
||
int pIndx = tstStrObj.GetFieldIndex(parentFlds[i]);
|
||
if (pIndx == -1)
|
||
{
|
||
if (globalVars.ToLower().IndexOf("<" + parentFlds[i].ToLower() + ">") > -1)
|
||
continue;
|
||
else if (userVars.ToLower().IndexOf("<" + parentFlds[i].ToLower() + ">") > -1)
|
||
continue;
|
||
else
|
||
continue;
|
||
}
|
||
TStructDef.FieldStruct pfld = (TStructDef.FieldStruct)tstStrObj.flds[pIndx];
|
||
if (calledFrom == "AddRow" || calledFrom == "DeleteRow")
|
||
iXml += PerfGetDepFldValues(pfld.fldFrameNo, 0, calledFrom, pfld);
|
||
else if ((calledFrom == "LoadDc" || calledFrom == "FillGrid") && pfld.fldFrameNo != dcFrame)
|
||
iXml += PerfGetDepFldValues(pfld.fldFrameNo, 0, calledFrom, pfld);
|
||
}
|
||
}
|
||
return iXml;
|
||
}
|
||
|
||
private string WsPerfFieldToXML(string fldName, string rowNo, string value, string oldValue, string idvalue, string oldIdValue, string dcNo, Boolean fldSaveNormal, TStructDef.FieldStruct fld = new TStructDef.FieldStruct())
|
||
{
|
||
string dsDataXML = string.Empty;
|
||
rowNo = GetRowNoHelper(rowNo.ToString());
|
||
value = CheckSpecialChars(value);
|
||
oldValue = CheckSpecialChars(oldValue);
|
||
string oldVal = "";
|
||
if (recordid != "0")
|
||
{
|
||
if (value != oldValue)
|
||
oldVal = "ov=\"" + oldValue + "\"";
|
||
else
|
||
oldVal = "";
|
||
}
|
||
if (fldName.StartsWith(Constants.IMGPrefix))
|
||
return dsDataXML;
|
||
if (fld.datatype != null && fld.datatype.ToLower() == "image" && imgAttachPath != "")
|
||
return dsDataXML;
|
||
if (fldSaveNormal)
|
||
{
|
||
if (Convert.ToString(idvalue) == "") idvalue = "0";
|
||
if (Convert.ToString(oldIdValue) == "") oldIdValue = "0";
|
||
dsDataXML += "<" + fldName + " rowno=\"" + rowNo + "\" id=\"" + idvalue + "\" oldid=\"" + oldIdValue + "\" " + oldVal + ">" + value + "</" + fldName + ">";
|
||
}
|
||
else
|
||
{
|
||
dsDataXML += "<" + fldName + " rowno=\"" + rowNo + "\" " + oldVal + ">" + value + "</" + fldName + ">";
|
||
}
|
||
return dsDataXML;
|
||
}
|
||
|
||
public string CallDeleteRowWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string s, string dcNo)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "", "NG", dcNo);
|
||
s += tstData.fieldValueXml + memVarsData;
|
||
s += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
s += "</sqlresultset>";
|
||
string result = string.Empty;
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallDeleteRowWS(transid, s, ires);
|
||
return result;
|
||
}
|
||
|
||
public string CallDeleteRowPerfWS(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string s, string dcNo)
|
||
{
|
||
string news = GetTraceString(s);
|
||
if (news != "") s = news;
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
tstData.GetPerfFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "", "NG", dcNo);
|
||
s += WsPerfAddRowLoadDc(dcNo, "DeleteRow");
|
||
s += memVarsData;
|
||
s += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
s += "</sqlresultset>";
|
||
string result = string.Empty;
|
||
bool callService = false;
|
||
if (tstStrObj.wsPerfEnabled == true)
|
||
{
|
||
if (tstStrObj.wsPerfGRDDcs != null && tstStrObj.wsPerfGRDDcs.IndexOf(dcNo) != -1)
|
||
callService = true;
|
||
}
|
||
else
|
||
callService = true;
|
||
if (callService)
|
||
{
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallDeleteRowWS(transid, s, ires);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
public string LoadComboValues(TStructData tstData, ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string iXml, string dcNo)
|
||
{
|
||
DateTime stTime = DateTime.Now;
|
||
string strTrace = GetTraceString(iXml);
|
||
if (strTrace != "") iXml = strTrace;
|
||
string result = string.Empty;
|
||
//GetGlobalVars();
|
||
transid = tstData.transid.ToString();
|
||
ires = tstStrObj.structRes;
|
||
//tstData.GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "LoadTab", "NG", dcNo);
|
||
//iXml += tstData.fieldValueXml + memVarsData;
|
||
tstData.GetPerfFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "LoadTab", "NG", dcNo);
|
||
iXml += WsPerfAddRowLoadDc(dcNo, "LoadDc");
|
||
iXml += memVarsData;
|
||
iXml += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
iXml += "</sqlresultset>";
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
DateTime asStart = DateTime.Now;
|
||
|
||
if (CallWsPerfLoadDc(dcNo))
|
||
result = objWebServiceExt.CallLoadDCCombosWS(transid, iXml, ires);
|
||
DateTime asEnd = DateTime.Now;
|
||
if (logTimeTaken)
|
||
{
|
||
webTime1 = asStart.Subtract(stTime).TotalMilliseconds;
|
||
webTime2 = DateTime.Now.Subtract(asEnd).TotalMilliseconds;
|
||
asbTime = asEnd.Subtract(asStart).TotalMilliseconds;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
private bool CallWsPerfLoadDc(string dcNo)
|
||
{
|
||
bool isCallDcCombo = false;
|
||
//If dc has fillgrid
|
||
if (dcNo != "" && tstStrObj.wsPerfFGDcName != null && rid == "0")
|
||
{
|
||
string[] flGridDc = tstStrObj.wsPerfFGDcName;
|
||
var loaddcFG = flGridDc.Where(d => d.ToLower() == "dc" + dcNo).ToList();
|
||
if (loaddcFG.Count > 0)
|
||
isCallDcCombo = true;
|
||
}
|
||
//Below condition not required to now becuse of accept sql field will take cae either doformload, addrow or getdependency
|
||
////If dc has accept sql or select with auto select fields
|
||
//if (tstStrObj.wsPerfLDcName != null && isCallDcCombo == false && rid == "0")
|
||
//{
|
||
// string[] fldldCall = tstStrObj.wsPerfLDcName;
|
||
// var loaddcFld = fldldCall.Where(fd => fd.ToLower() == "dc" + dcNo).ToList();
|
||
// if (loaddcFld.Count > 0)
|
||
// isCallDcCombo = true;
|
||
//}
|
||
return isCallDcCombo;
|
||
}
|
||
|
||
public string GetSubGridCombos(ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string iXml, string dcNo, string parDcNo, int popRowNo, int parRowNo)
|
||
{
|
||
string strTrace = GetTraceString(iXml);
|
||
if (strTrace != "") iXml = strTrace;
|
||
string result = string.Empty;
|
||
ires = tstStrObj.structRes;
|
||
GetPopFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", parDcNo, parRowNo, dcNo, popRowNo);
|
||
iXml += fieldValueXml + memVarsData;
|
||
iXml += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
iXml += "</sqlresultset>";
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
result = objWebServiceExt.CallGetSubGridCCombosWS(transid, iXml, ires);
|
||
return result;
|
||
}
|
||
|
||
|
||
#endregion
|
||
|
||
#endregion
|
||
|
||
private void UpdateRowValues(string fldName, string rowNo, string dcNo, string comboValues, string dpValues)
|
||
{
|
||
int idx = GetFldIndex(Convert.ToInt32(dcNo), fldName, Convert.ToInt32(rowNo));
|
||
if (idx != -1)
|
||
{
|
||
fieldRowValues[idx] = comboValues;
|
||
fieldDPVals[idx] = dpValues;
|
||
}
|
||
}
|
||
|
||
public bool IsDcGrid(string dcNo, TStructDef strObj)
|
||
{
|
||
bool isGrid = false;
|
||
for (int i = 0; i < strObj.dcs.Count; i++)
|
||
{
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)strObj.dcs[i];
|
||
if (dc.frameno.ToString() == dcNo && dc.isgrid == true)
|
||
{
|
||
isGrid = true;
|
||
break;
|
||
}
|
||
}
|
||
return isGrid;
|
||
}
|
||
|
||
public int GetDcRowCount(string dcNo)
|
||
{
|
||
return dsDataSet.Tables["dc" + dcNo].Rows.Count;
|
||
}
|
||
|
||
#region PickList Methods
|
||
/// <summary>
|
||
/// Function to call the webservice which returns the filtered value for the picklist field.
|
||
/// </summary>
|
||
/// <param name="iXml"></param>
|
||
/// <returns></returns>
|
||
public string GetPickListResult(ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string iXml, string structXml, string fldName, string frameNo, string parentInfo, string subGridInfo, string activeRow, string includeDcs)
|
||
{
|
||
string res = "";
|
||
GetPicklistInputXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, fldName, frameNo, parentInfo, subGridInfo, activeRow);
|
||
iXml += this.fieldValueXml + memVarsData;
|
||
iXml += HttpContext.Current.Session["axApps"].ToString() + HttpContext.Current.Application["axProps"].ToString() + HttpContext.Current.Session["axGlobalVars"].ToString() + HttpContext.Current.Session["axUserVars"].ToString();
|
||
iXml += "</sqlresultset>";
|
||
//Call service
|
||
objWebServiceExt = new ASBExt.WebServiceExt();
|
||
iXml = util.CheckSplChrInputXML(iXml);
|
||
res = objWebServiceExt.CallGetSearchResultWS(transid, iXml, structXml);
|
||
if (res != "done" && res != "" && !res.StartsWith(Constants.ERROR))
|
||
{
|
||
res = ParsePickListJson(res);
|
||
}
|
||
return res;
|
||
}
|
||
|
||
public void GetPicklistInputXml(ArrayList fldArray, ArrayList fldDbRowNo, ArrayList fldValueArray, ArrayList fldDeletedArray, string fldName, string frameNo, string parentInfo, string subGridInfo, string activeRow)
|
||
{
|
||
int idx = tstStrObj.GetFieldIndex(fldName);
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[idx];
|
||
ArrayList AxDepFields = new ArrayList();
|
||
bool isDcGrid = false;
|
||
Dictionary<string, string> IncludeDcRows = new Dictionary<string, string>();
|
||
isDcGrid = IsDcGrid(frameNo, tstStrObj);
|
||
|
||
if (isDcGrid)
|
||
{
|
||
string DepFlds = fld.fieldSqlDepParents;
|
||
AxDepFields = GetParDepFlds(fld.fieldSqlDepParents);
|
||
}
|
||
|
||
if (fld.fieldSqlGridDeps != string.Empty)
|
||
{
|
||
string[] strSDeps = fld.fieldSqlGridDeps.Split(',');
|
||
for (int i = 0; i < strSDeps.Length; i++)
|
||
{
|
||
AxDepFields.Add(strSDeps[i].ToString());
|
||
}
|
||
|
||
//The below statement will add the current field to the dependent fields if the current dc is a grid dc
|
||
//and it has dependents in other grid, then all the row values for the field should be sent in the input xml.
|
||
if (isDcGrid)
|
||
AxDepFields.Add(fld.name);
|
||
}
|
||
|
||
|
||
//If the field has non grid sql dependents, then send the parent values for that dep field also
|
||
if (IsDcGrid(frameNo, tstStrObj))
|
||
{
|
||
//If the call is made from a parent grid, then all its subgriud and their respective rows for the given parent row
|
||
//will be sent in the given format: dcno~rowno1,rowno2¿dcno~rowno1,rowno2...
|
||
if (subGridInfo != "")
|
||
{
|
||
if (subGridInfo.IndexOf("¿") != -1)
|
||
{
|
||
string[] subgridDcs = subGridInfo.Split('¿');
|
||
for (int i = 0; i < subgridDcs.Length; i++)
|
||
{
|
||
string[] dcInfo = subgridDcs[i].ToString().Split('~');
|
||
IncludeDcRows.Add(dcInfo[0], dcInfo[1]);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
IncludeDcRows.Add(subGridInfo.Substring(0, subGridInfo.IndexOf("~")), subGridInfo.Substring(subGridInfo.IndexOf("~") + 1));
|
||
}
|
||
}
|
||
|
||
//If the call is made from sub grid, then the parentinfo will contain the parent dc no and parent row no in the given format : dcno~rowno
|
||
if (parentInfo != "")
|
||
{
|
||
IncludeDcRows.Add(parentInfo.Substring(0, parentInfo.IndexOf("~")), parentInfo.Substring(parentInfo.IndexOf("~") + 1));
|
||
}
|
||
|
||
|
||
//first update the list with the new fldArray.
|
||
UpdateDataList(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray);
|
||
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
|
||
CreateFieldValueXmlPerf(frameNo, activeRow, AxDepFields, fld.fieldDepGridDcs, IncludeDcRows, "");
|
||
}
|
||
else
|
||
{
|
||
if (AxDepFields.Count > 0)
|
||
{
|
||
//if a non grid fields has dependent grid dc fields, then send that dc fields data also.
|
||
//first update the list with the new fldArray.
|
||
UpdateDataList(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray);
|
||
DeleteDefaultRowInPopDc(project, user, transid, sessionid, AxRole);
|
||
CreateFieldValueXmlPerf(frameNo, activeRow, AxDepFields, fld.fieldDepGridDcs, IncludeDcRows, "");
|
||
}
|
||
else
|
||
{
|
||
//if a non grid fields has dependent grid Fill grid dc, then send that dc data also.
|
||
GetFieldValueXml(fldArray, fldDbRowNo, fldValueArray, fldDeletedArray, "-1", "GetDependents", "NG", fld.fieldDepFillDcs);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to parse the result of GetSearchResult service and construct the result string and return to the client.
|
||
/// </summary>
|
||
/// <param name="result"></param>
|
||
/// <returns></returns>
|
||
private string ParsePickListJson(string result)
|
||
{
|
||
StringBuilder pickDataArray = new StringBuilder();
|
||
JArray Data;
|
||
try
|
||
{
|
||
result = result.Replace("\\", ";bkslh");
|
||
JObject tstData = JObject.Parse(result);
|
||
Data = (JArray)tstData["pickdata"];
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw ex;
|
||
}
|
||
|
||
if (Data != null)
|
||
{
|
||
string fName = string.Empty;
|
||
string fValue = string.Empty;
|
||
for (int m = 0; m < Data.Count; m++)
|
||
{
|
||
if (Data[m]["rcount"] != null)
|
||
{
|
||
string rCount = Data[m]["rcount"].ToString();
|
||
rCount = rCount.Replace("\"", "");
|
||
if (rCount != "0")
|
||
pickDataArray.Append(rCount + "♣");
|
||
}
|
||
else if (Data[m]["fname"] != null)
|
||
{
|
||
fName = (string)Data[m]["fname"].ToString();
|
||
}
|
||
else
|
||
{
|
||
fValue = (string)Data[m]["fvalue"].ToString();
|
||
//Following Code was removing first and last character of fname and fvalue resulting in issues.. hence commented
|
||
//fName = fName.Remove(0, 1);
|
||
//fName = fName.Remove(fName.Length - 1, 1);
|
||
//fValue = fValue.Remove(0, 1);
|
||
//fValue = fValue.Remove(fValue.Length - 1, 1);
|
||
fValue = fValue.Replace("^^dq", "\"");
|
||
fValue = fValue.Replace(";bkslh", @"\");
|
||
string[] pickFldValues = fValue.Split('~');
|
||
for (int j = 0; j < pickFldValues.Length; j++)
|
||
{
|
||
if (j == 0)
|
||
pickDataArray.Append(pickFldValues[j].ToString());
|
||
else
|
||
pickDataArray.Append("¿" + pickFldValues[j].ToString());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return pickDataArray.ToString();
|
||
}
|
||
#endregion
|
||
|
||
private void GetGlobalVars()
|
||
{
|
||
project = HttpContext.Current.Session["project"].ToString();
|
||
user = HttpContext.Current.Session["user"].ToString();
|
||
AxRole = HttpContext.Current.Session["AxRole"].ToString();
|
||
sessionid = HttpContext.Current.Session["nsessionid"].ToString();
|
||
}
|
||
|
||
public string GetIncludeDcsForLoad()
|
||
{
|
||
string includeDcs = string.Empty;
|
||
string depDcs = string.Empty;
|
||
DataRow dr = DsGetRow("axp_mustloaddc", "001");
|
||
if (dr != null)
|
||
depDcs = dr["axp_mustloaddc"].ToString();
|
||
return depDcs;
|
||
}
|
||
|
||
public void AddToFasDDl(string fName, string fJson)
|
||
{
|
||
if (fastDDL.ContainsKey(fName))
|
||
fastDDL.Remove(fName);
|
||
|
||
fastDDL.Add(fName, fJson);
|
||
}
|
||
|
||
#region New Indexing Methods
|
||
|
||
/// <summary>
|
||
/// Function loops through the dcs in the tstruct and for every dc adds the default fields into the field arrays.
|
||
/// </summary>
|
||
/// <param name="strObj"></param>
|
||
private void CreateDefaultFArray(TStructDef strObj)
|
||
{
|
||
foreach (TStructDef.DcStruct dc in strObj.dcs)
|
||
UpdateRowCount(dc.frameno.ToString(), "DC" + dc.frameno.ToString() + "~1");
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function loops through the dcs in the tstruct and for every dc adds the default fields into the Data Table.
|
||
/// </summary>
|
||
/// <param name="strObj"></param>
|
||
private void CreateDataSets(TStructDef strObj)
|
||
{
|
||
DataSet ds = new DataSet("datacache");
|
||
// TODO: needs proper comment - Create a DataSet and put both tables in it.
|
||
foreach (TStructDef.DcStruct dc in strObj.dcs)
|
||
{
|
||
ds.Tables.Add(DSConstruct(dc.frameno, strObj));
|
||
ds.Tables.Add(DSConstructOld(dc.frameno, strObj));
|
||
ds.Tables.Add(DSSaveFalse(dc.frameno, strObj));
|
||
}
|
||
ds.Tables.Add(DSCreateDropDownTable());
|
||
dsDataSet = ds;
|
||
}
|
||
|
||
private DataTable DSCreateDropDownTable()
|
||
{
|
||
DataTable dtDropDownValue = new DataTable();
|
||
dtDropDownValue.TableName = "dsdropdown";
|
||
|
||
DataColumn[] keys1 = new DataColumn[1];
|
||
DataColumn column1 = dtDropDownValue.Columns.Add("dropdownkey");
|
||
keys1[0] = column1;
|
||
dtDropDownValue.PrimaryKey = keys1;
|
||
|
||
dtDropDownValue.Columns.Add("fldname");
|
||
dtDropDownValue.Columns.Add("axp__rowno");
|
||
dtDropDownValue.Columns.Add("rowvals");
|
||
dtDropDownValue.Columns.Add("dpmvalues");
|
||
dtDropDownValue.Columns.Add("dp");
|
||
dtDropDownValue.Columns.Add("mr");
|
||
dtDropDownValue.Columns.Add("idcol");
|
||
|
||
return dtDropDownValue;
|
||
}
|
||
|
||
private DataTable DSSaveFalse(int dcNo, TStructDef strObj)
|
||
{
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)strObj.dcs[dcNo - 1];
|
||
DataTable dtObj = new DataTable("dc_savefalse" + dcNo.ToString());
|
||
DataColumn[] keys = new DataColumn[1];
|
||
DataColumn column;
|
||
string dcFldRange = strObj.GetDcFieldRange(dcNo.ToString());
|
||
string[] fldRange = dcFldRange.Split(',');
|
||
int startIndex = Convert.ToInt32(fldRange[0]);
|
||
int endIndex = Convert.ToInt32(fldRange[1]);
|
||
|
||
for (int j = startIndex; j <= endIndex; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)strObj.flds[j];
|
||
|
||
if (fld.savevalue == false)
|
||
{
|
||
dtObj.Columns.Add(fld.name);
|
||
}
|
||
}
|
||
|
||
column = dtObj.Columns.Add("axp__rowno");
|
||
column.DataType = typeof(Int32);
|
||
keys[0] = column;
|
||
dtObj.PrimaryKey = keys;
|
||
|
||
return dtObj;
|
||
}
|
||
|
||
private DataTable DSConstructOld(int dcNo, TStructDef strObj)
|
||
{
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)strObj.dcs[dcNo - 1];
|
||
DataTable dtOldObj = new DataTable("dc_old" + dcNo.ToString());
|
||
DataColumn[] keys = new DataColumn[1];
|
||
DataColumn column;
|
||
|
||
string dcFldRange = strObj.GetDcFieldRange(dcNo.ToString());
|
||
string[] fldRange = dcFldRange.Split(',');
|
||
int startIndex = Convert.ToInt32(fldRange[0]);
|
||
int endIndex = Convert.ToInt32(fldRange[1]);
|
||
|
||
for (int j = startIndex; j <= endIndex; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)strObj.flds[j];
|
||
|
||
dtOldObj.Columns.Add("old__" + fld.name);
|
||
if (fld.savenormal)
|
||
dtOldObj.Columns.Add("oldid__" + fld.name);
|
||
}
|
||
|
||
column = dtOldObj.Columns.Add("axp__rowno");
|
||
column.DataType = typeof(Int32);
|
||
keys[0] = column;
|
||
dtOldObj.PrimaryKey = keys;
|
||
|
||
return dtOldObj;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to add every field in given dc into the field array and index array.
|
||
/// </summary>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="strObj"></param>
|
||
/// <param name="fldIdx"></param>
|
||
private DataTable DSConstruct(int dcNo, TStructDef strObj)
|
||
{
|
||
TStructDef.DcStruct dc = (TStructDef.DcStruct)strObj.dcs[dcNo - 1];
|
||
DataTable dtObj = new DataTable("dc" + dcNo.ToString());
|
||
|
||
DataColumn[] keys = new DataColumn[1];
|
||
DataColumn column;
|
||
|
||
string dcFldRange = strObj.GetDcFieldRange(dcNo.ToString());
|
||
string[] fldRange = dcFldRange.Split(',');
|
||
int startIndex = Convert.ToInt32(fldRange[0]);
|
||
int endIndex = Convert.ToInt32(fldRange[1]);
|
||
|
||
for (int j = startIndex; j <= endIndex; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)strObj.flds[j];
|
||
dtObj.Columns.Add(fld.name);
|
||
//dtObj.Columns.Add("old__" + fld.name);
|
||
|
||
if (fld.savenormal)
|
||
{
|
||
dtObj.Columns.Add("id__" + fld.name);
|
||
//dtObj.Columns.Add("oldid__" + fld.name);
|
||
}
|
||
}
|
||
//dtObj.Columns.Add("axp_recid" + dcNo);
|
||
column = dtObj.Columns.Add("axp__rowno");
|
||
column.DataType = typeof(Int32);
|
||
keys[0] = column;
|
||
dtObj.PrimaryKey = keys;
|
||
dtObj.Columns.Add("axp__delrow");
|
||
if (dc.isgrid)
|
||
dtObj.Columns.Add(Constants.AXPISROWVALID + dcNo);
|
||
|
||
return dtObj;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Function which loop though each dc till the given dc and appends the field count.
|
||
/// </summary>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="strObj"></param>
|
||
/// <returns></returns>
|
||
private int GetDcIndex(int dcNo)
|
||
{
|
||
int fldCnt = 0;
|
||
foreach (TStructDef.DcStruct dc in tstStrObj.dcs)
|
||
{
|
||
if (dc.frameno >= dcNo)
|
||
break;
|
||
|
||
fldCnt += dc.fieldCount;
|
||
}
|
||
return fldCnt;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to calculate the index of the field in the fieldIndexArray
|
||
/// and return the value from that item of the fieldIndexArray.
|
||
/// </summary>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="fieldOrder"></param>
|
||
/// <param name="rowNo"></param>
|
||
/// <returns></returns>
|
||
public int GetFldIndex(int dcNo, string fldName, int rowNo)
|
||
{
|
||
int idx = 0;
|
||
int index = 0;
|
||
if (rowNo == 0) rowNo = 1;
|
||
foreach (TStructDef.DcStruct dc in tstStrObj.dcs)
|
||
{
|
||
if (dc.frameno >= dcNo)
|
||
break;
|
||
|
||
idx += GetDcRowCount(dc.frameno.ToString()) * dc.fieldCount;
|
||
}
|
||
|
||
TStructDef.DcStruct currentDC = (TStructDef.DcStruct)tstStrObj.dcs[dcNo - 1];
|
||
int fieldOrder = GetFieldOrder(fldName, dcNo, currentDC);
|
||
//Formula = idx + FieldCountInDC * (RowNo-1) + (FieldOrder - StartOrderInDC)
|
||
idx += currentDC.fieldCount * (rowNo - 1) + (fieldOrder - GetDcIndex(dcNo));
|
||
if (idx >= fieldIndexArray.Count) index = -1;
|
||
else
|
||
index = (Int32)fieldIndexArray[idx];
|
||
return index;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get the field order for the given field in the given dc.
|
||
/// </summary>
|
||
/// <param name="fldName"></param>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="dc"></param>
|
||
/// <returns></returns>
|
||
private int GetFieldOrder(string fldName, int dcNo, TStructDef.DcStruct dc)
|
||
{
|
||
int fldOrd = 0;
|
||
string dcFldRange = tstStrObj.GetDcFieldRange(dcNo.ToString());
|
||
string[] fldRange = dcFldRange.Split(',');
|
||
int startIndex = Convert.ToInt32(fldRange[0]);
|
||
int endIndex = Convert.ToInt32(fldRange[1]);
|
||
|
||
for (int j = startIndex; j <= endIndex; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[j];
|
||
if (fld.name == fldName)
|
||
{
|
||
fldOrd = j;
|
||
break;
|
||
}
|
||
}
|
||
return fldOrd;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to add or update the field arrays.
|
||
/// </summary>
|
||
/// <param name="name"></param>
|
||
/// <param name="fldId"></param>
|
||
/// <param name="rowNo"></param>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="value"></param>
|
||
/// <param name="oldValue"></param>
|
||
/// <param name="idCol"></param>
|
||
/// <param name="mr"></param>
|
||
/// <param name="rowVals"></param>
|
||
/// <param name="id"></param>
|
||
/// <param name="oldId"></param>
|
||
/// <param name="status"></param>
|
||
/// <param name="index"></param>
|
||
private void SubmitFieldInArrays(string value, string oldValue, string idCol, string mr, string rowVals, string id, string oldId, string dpmValues, string dp, int index)
|
||
{
|
||
fieldValue[index] = value;
|
||
fieldOldValue[index] = value;
|
||
fldIdCol[index] = idCol;
|
||
fldMasterRow[index] = mr;
|
||
fieldRowValues[index] = rowVals;
|
||
fieldOldIdValue[index] = oldId;
|
||
fieldIdValue[index] = id;
|
||
fieldDPMVals[index] = dpmValues;
|
||
fieldDPVals[index] = dp;
|
||
//StringToFile("Replace Values - FieldName-" + fieldName[index].ToString() + " Rowno- " + fieldRowNo[index].ToString() + " Value- " + value + " Index- " + index);
|
||
}
|
||
|
||
private void DSSubmit(string fldName, int rowNo, string value, string idValue)
|
||
{
|
||
int dcNo = tstStrObj.GetFieldDc(fldName);
|
||
if (dcNo == 0 && fldName.StartsWith(Constants.AXPISROWVALID))
|
||
{
|
||
dcNo = Convert.ToInt32(fldName.Substring(13));
|
||
}
|
||
if (rowNo == 0) rowNo = 1;
|
||
DataTable dt = dsDataSet.Tables["dc" + dcNo];
|
||
DataRow foundRow = dsDataSet.Tables["dc" + dcNo].Rows.Find(rowNo);
|
||
if (foundRow == null)
|
||
{
|
||
foundRow = dt.NewRow();
|
||
|
||
foundRow["axp__rowno"] = Convert.ToInt32(rowNo);
|
||
foundRow["axp__delrow"] = 0;
|
||
dt.Rows.Add(foundRow);
|
||
}
|
||
if (!fldName.StartsWith("axp_recid"))
|
||
foundRow[fldName] = value;
|
||
string axp_recId = foundRow["axp_recid" + dcNo].ToString();
|
||
foundRow["axp_recid" + dcNo] = axp_recId == "" ? "0" : axp_recId;
|
||
if (dt.Columns.Contains("id__" + fldName))
|
||
foundRow["id__" + fldName] = idValue;
|
||
|
||
dt.AcceptChanges();
|
||
}
|
||
|
||
private void DSSubmitDropDownValues(string fldName, int rowNo, string rowVals, string dpmValues, string dp, string mr, string idCol)
|
||
{
|
||
DataTable thisDataTable = dsDataSet.Tables["dsdropdown"];
|
||
if (rowNo == 0) rowNo = 1;
|
||
DataRow thisDataRow = thisDataTable.Rows.Find(fldName + "-" + rowNo);
|
||
|
||
if (thisDataRow == null)
|
||
{
|
||
thisDataRow = thisDataTable.NewRow();
|
||
thisDataRow["dropdownkey"] = fldName + "-" + rowNo;
|
||
thisDataRow["fldname"] = fldName;
|
||
thisDataRow["axp__rowno"] = rowNo;
|
||
thisDataTable.Rows.Add(thisDataRow);
|
||
}
|
||
thisDataRow["rowvals"] = rowVals;
|
||
thisDataRow["dpmvalues"] = dpmValues;
|
||
thisDataRow["dp"] = dp;
|
||
thisDataRow["mr"] = mr;
|
||
thisDataRow["idcol"] = idCol;
|
||
|
||
dsDataSet.AcceptChanges();
|
||
}
|
||
|
||
private void DSUpdateRowValues(string fldName, int rowNo, string rowVals, string dp, string masterRow, string idCol)
|
||
{
|
||
DataTable thisDataTable = dsDataSet.Tables["dsdropdown"];
|
||
if (rowNo == 0) rowNo = 1;
|
||
DataRow thisDataRow = thisDataTable.Rows.Find(fldName + "-" + rowNo);
|
||
|
||
if (thisDataRow == null)
|
||
{
|
||
thisDataRow = thisDataTable.NewRow();
|
||
thisDataRow["dropdownkey"] = fldName + "-" + rowNo;
|
||
thisDataRow["fldname"] = fldName;
|
||
thisDataRow["axp__rowno"] = rowNo;
|
||
thisDataRow["idcol"] = idCol;
|
||
thisDataTable.Rows.Add(thisDataRow);
|
||
}
|
||
thisDataRow["rowvals"] = rowVals;
|
||
thisDataRow["dp"] = dp;
|
||
thisDataRow["mr"] = masterRow;
|
||
|
||
dsDataSet.AcceptChanges();
|
||
}
|
||
public DataRow DSGetDropdownRow(string fldName, string rowNo)
|
||
{
|
||
DataTable thisDataTable = dsDataSet.Tables["dsdropdown"];
|
||
int rNo = Convert.ToInt32(rowNo);
|
||
if (rNo == 0) rNo = 1;
|
||
return thisDataTable.Rows.Find(fldName + "-" + rNo);
|
||
}
|
||
|
||
private void DSSubmitWithOld(string fldName, int rowNo, string value, string idValue, string oldIdValue)
|
||
{
|
||
int dcNo = tstStrObj.GetFieldDc(fldName);
|
||
if (dcNo == 0) return;
|
||
if (rowNo == 0) rowNo = 1;
|
||
DataTable dt = dsDataSet.Tables["dc" + dcNo];
|
||
DataRow foundRow = dsDataSet.Tables["dc" + dcNo].Rows.Find(rowNo);
|
||
|
||
if (foundRow == null)
|
||
{
|
||
foundRow = dt.NewRow();
|
||
|
||
foundRow["axp__rowno"] = rowNo;
|
||
foundRow["axp__delrow"] = 0;
|
||
dt.Rows.Add(foundRow);
|
||
}
|
||
foundRow[fldName] = value;
|
||
|
||
if (dt.Columns.Contains("id__" + fldName))
|
||
foundRow["id__" + fldName] = idValue;
|
||
|
||
dt.AcceptChanges();
|
||
|
||
DSSubmitOldValues(fldName, rowNo, value, idValue, oldIdValue);
|
||
}
|
||
|
||
private void DSSubmitOldValues(string fldName, int rowNo, string value, string idValue, string oldIdValue)
|
||
{
|
||
int dcNo = tstStrObj.GetFieldDc(fldName);
|
||
if (rowNo == 0) rowNo = 1;
|
||
|
||
DataTable dtOld = dsDataSet.Tables["dc_old" + dcNo];
|
||
DataRow drOld = dtOld.Rows.Find(rowNo);
|
||
if (drOld == null)
|
||
{
|
||
drOld = dtOld.NewRow();
|
||
|
||
drOld["axp__rowno"] = rowNo;
|
||
dtOld.Rows.Add(drOld);
|
||
}
|
||
drOld["old__" + fldName] = value;
|
||
if (dtOld.Columns.Contains("oldid__" + fldName))
|
||
drOld["oldid__" + fldName] = oldIdValue;
|
||
|
||
dtOld.AcceptChanges();
|
||
}
|
||
|
||
private void DSInsertRow(int dcNo, int rowNo)
|
||
{
|
||
DataTable DCTable = dsDataSet.Tables["dc" + dcNo];
|
||
for (int i = DCTable.Rows.Count - 1; i >= 0; i--)
|
||
{
|
||
DataRow thisrow = DCTable.Rows[i];
|
||
int thisRowNo = Convert.ToInt32(thisrow["axp__rowno"]);
|
||
if (thisRowNo < rowNo)
|
||
break;
|
||
thisrow["axp__rowno"] = thisRowNo + 1;
|
||
}
|
||
DataRow newRow = DCTable.NewRow();
|
||
newRow["axp__rowno"] = rowNo;
|
||
DCTable.Rows.Add(newRow);
|
||
DCTable.AcceptChanges();
|
||
dsDataSet.AcceptChanges();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to delete all the rows in the given dc from the field arrays.
|
||
/// </summary>
|
||
/// <param name="dcNo"></param>
|
||
private void DeleteAllRowsInDc(string dcNo)
|
||
{
|
||
DSDeleteAllRows(dcNo);
|
||
}
|
||
|
||
private void DSDeleteAllRows(string dcNo)
|
||
{
|
||
int idx = AxDelDcNo.IndexOf("dc" + dcNo);
|
||
if (idx == -1)
|
||
AxDelDcNo.Add("dc" + dcNo);
|
||
|
||
StringBuilder strDelIds = new StringBuilder();
|
||
if (idx != -1)
|
||
strDelIds.Append(AxDelRecIds[idx].ToString());
|
||
DataTable DCTable = dsDataSet.Tables["dc" + dcNo];
|
||
|
||
for (int j = DCTable.Rows.Count; j > 0; j--)
|
||
{
|
||
DataRow foundRow = DCTable.Rows.Find(j);
|
||
if (foundRow != null)
|
||
{
|
||
if (strDelIds.ToString() == string.Empty)
|
||
strDelIds.Append(foundRow["axp_recid" + dcNo].ToString());
|
||
else
|
||
strDelIds.Append("," + foundRow["axp_recid" + dcNo].ToString());
|
||
}
|
||
DeleteRowInFldArrays(dcNo, j.ToString());
|
||
}
|
||
|
||
if (idx == -1)
|
||
AxDelRecIds.Add(strDelIds.ToString());
|
||
else
|
||
AxDelRecIds[idx] = strDelIds.ToString();
|
||
|
||
}
|
||
|
||
//Set the deleted rows from GetDependents, to the global array
|
||
private void SetPopDeletedRows(string dcNo, string delRecIds)
|
||
{
|
||
int idx = AxDelDcNo.IndexOf("dc" + dcNo);
|
||
if (idx == -1)
|
||
{
|
||
AxDelDcNo.Add("dc" + dcNo);
|
||
AxDelRecIds.Add(delRecIds);
|
||
}
|
||
else
|
||
{
|
||
AxDelRecIds[idx] = delRecIds;
|
||
}
|
||
}
|
||
|
||
public void DSDeleteRow(string dcNo, string rowNum)
|
||
{
|
||
DataTable DCTable = dsDataSet.Tables["dc" + dcNo];
|
||
DataTable DCOldTable = dsDataSet.Tables["dc_old" + dcNo];
|
||
|
||
int rNo = Convert.ToInt32(rowNum);
|
||
if (rNo == 0) rNo = 1;
|
||
DataRow foundRow = DCTable.Rows.Find(rNo);
|
||
DataRow oldRow = DCOldTable.Rows.Find(rNo);
|
||
|
||
DataTable DeletedRowsTable = dsDataSet.Tables["deldc" + dcNo];
|
||
if (DeletedRowsTable == null)
|
||
{
|
||
DeletedRowsTable = DCTable.Clone();
|
||
DeletedRowsTable.TableName = "deldc" + dcNo;
|
||
dsDataSet.Tables.Add(DeletedRowsTable);
|
||
}
|
||
|
||
if (foundRow != null)
|
||
{
|
||
DeletedRowsTable.ImportRow(foundRow);
|
||
DataRow DelTableRow = DeletedRowsTable.Rows.Find(rNo);
|
||
DelTableRow["axp__delrow"] = DelTableRow["axp__rowno"];
|
||
DelTableRow["axp__rowno"] = deletedCount--;
|
||
|
||
//copying delete contents to xml for sending to web service.
|
||
StringBuilder strDelRowFlds = new StringBuilder();
|
||
string axpRecidVal = "0";
|
||
string axpNode = string.Empty;
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
for (int j = startIdx; j <= endIdx; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[j];
|
||
if (recordid != "0")
|
||
{
|
||
if (oldRow != null)
|
||
{
|
||
if (fld.name == "axp_recid" + dcNo)
|
||
{
|
||
axpNode = "<" + fld.name + ">" + CheckSpecialChars(oldRow["old__" + fld.name].ToString()) + "</" + fld.name + ">";
|
||
axpRecidVal = foundRow[fld.name].ToString();
|
||
}
|
||
else
|
||
{
|
||
strDelRowFlds.Append("<" + fld.name + ">" + CheckSpecialChars(oldRow["old__" + fld.name].ToString()) + "</" + fld.name + ">");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
DelRowFldsXml.Add(axpRecidVal + "♦" + axpNode + strDelRowFlds.ToString());
|
||
|
||
foundRow.Delete();
|
||
DCTable.AcceptChanges();
|
||
DCTable.PrimaryKey = null;
|
||
DCTable = DeleteRowFalse(DCTable, DeletedRowsTable, dcNo);
|
||
int givenRow = Convert.ToInt32(rNo);
|
||
foreach (DataRow thisrow in DCTable.Rows)
|
||
{
|
||
int thisRowNo = Convert.ToInt32(thisrow["axp__rowno"]);
|
||
if (thisRowNo > givenRow)
|
||
thisrow["axp__rowno"] = thisRowNo - 1;
|
||
}
|
||
|
||
|
||
DCTable.PrimaryKey = new DataColumn[] { DCTable.Columns["axp__rowno"] };
|
||
|
||
if (oldRow != null)
|
||
{
|
||
oldRow.Delete();
|
||
DCOldTable.AcceptChanges();
|
||
}
|
||
|
||
DCOldTable.PrimaryKey = null;
|
||
foreach (DataRow thisrow in DCOldTable.Rows)
|
||
{
|
||
int thisRowNo = Convert.ToInt32(thisrow["axp__rowno"]);
|
||
if (thisRowNo > givenRow)
|
||
thisrow["axp__rowno"] = thisRowNo - 1;
|
||
}
|
||
DCOldTable.PrimaryKey = new DataColumn[] { DCOldTable.Columns["axp__rowno"] };
|
||
DSDeleteDropDown(dcNo, rowNum);
|
||
}
|
||
}
|
||
|
||
private void deleteRowOnSave()
|
||
{
|
||
try
|
||
{
|
||
for (int i = 0; i < deletedRowCount.Count; i++)
|
||
{
|
||
string dcNumber = deletedRowCount[i].ToString().Split('♦')[1];
|
||
string delRowNumber = (int.Parse(deletedRowCount[i].ToString().Split('♦')[0]) + 1).ToString();
|
||
DSDeleteRow(dcNumber, delRowNumber);
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{ }
|
||
}
|
||
|
||
private void UpdateGridDelRowVal(int dcNumner)
|
||
{
|
||
try
|
||
{
|
||
if (isDeletedRow)
|
||
{
|
||
int totRowCount = dsData.Tables["DC" + dcNumner].Rows.Count;
|
||
dsData.Tables["DC" + dcNumner].Rows[totRowCount - 1]["axp__isGrdVld" + dcNumner] = "";
|
||
dsData.Tables["DC" + dcNumner].AcceptChanges();
|
||
|
||
if (deletedRowCount.Count == 0)
|
||
{
|
||
deletedRowCount.Add(totRowCount + "♦" + dcNumner);
|
||
}
|
||
else
|
||
{
|
||
string checkValue = string.Join(",", deletedRowCount.Select(x => x.ToString()).ToList());
|
||
if (checkValue.IndexOf("♦" + dcNumner) != -1)
|
||
{
|
||
var prevValue = deletedRowCount.AsEnumerable().Where(x => x.Contains("♦" + dcNumner)).ToList();
|
||
deletedRowCount.Remove(prevValue[0]);
|
||
deletedRowCount.Add(totRowCount + "♦" + dcNumner);
|
||
}
|
||
else
|
||
{
|
||
deletedRowCount.Add(totRowCount + "♦" + dcNumner);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{ }
|
||
}
|
||
|
||
private DataTable DeleteRowFalse(DataTable DCTable, DataTable DeletedRowsTable, string dcNo)
|
||
{
|
||
try
|
||
{
|
||
isDeletedRow = true;
|
||
int delRowCount = DeletedRowsTable.Rows.Count;
|
||
int OrgRows = DCTable.Rows.Count;
|
||
if (delRowCount < OrgRows)
|
||
{
|
||
for (int i = 1; i <= delRowCount; i++)
|
||
{
|
||
bool flagRemff = true;
|
||
foreach (DataColumn dc in DCTable.Columns)
|
||
{
|
||
if (dc.ColumnName == "axp__rowno")
|
||
{
|
||
break;
|
||
}
|
||
else if (DCTable.Rows[OrgRows - i][dc].ToString() != "" && DCTable.Rows[OrgRows - i][dc].ToString() != "0")
|
||
{
|
||
flagRemff = false;
|
||
}
|
||
}
|
||
if (flagRemff)
|
||
{
|
||
DCTable.Rows[OrgRows - i]["axp__isGrdVld" + dcNo] = "false";
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
#region delete
|
||
int userValue = 0;
|
||
int ofrows = DCTable.Rows.Count;
|
||
for (int trc = 0; trc < DCTable.Rows.Count; trc++)
|
||
{
|
||
int dbValue = int.Parse(DCTable.Rows[trc]["axp__rowno"].ToString());
|
||
if (dbValue >= userValue)
|
||
{
|
||
userValue = dbValue;
|
||
DeleteRowTopNo = trc;
|
||
}
|
||
}
|
||
bool flagRem = true;
|
||
foreach (DataColumn dc in DCTable.Columns)
|
||
{
|
||
if (dc.ColumnName.ToLower() == "axp__rowno")
|
||
{
|
||
break;
|
||
}
|
||
else if (DCTable.Rows[DeleteRowTopNo][dc].ToString() != "" && DCTable.Rows[DeleteRowTopNo][dc].ToString() != "0")
|
||
{
|
||
flagRem = false;
|
||
}
|
||
}
|
||
if (flagRem)
|
||
{
|
||
int totRowCount = DCTable.Rows.Count;
|
||
if (totRowCount != 1 && totRowCount == ofrows)
|
||
{
|
||
DCTable.Rows[totRowCount - 1]["axp__isGrdVld" + dcNo] = "false";
|
||
DCTable.AcceptChanges();
|
||
}
|
||
}
|
||
#endregion
|
||
}
|
||
return DCTable;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return DCTable;
|
||
}
|
||
}
|
||
|
||
//Function to delete all the sub grid rows after the get dep call.
|
||
private void DeletePopRowsAfterDep()
|
||
{
|
||
//AxSubGridRows will have dcno~1,2,3 in every item
|
||
for (int i = 0; i < AxSubGridRows.Count; i++)
|
||
{
|
||
string[] dcData = AxSubGridRows[i].ToString().Split('~');
|
||
string dcNo = dcData[0].ToString();
|
||
int delIdx = AxDelDcNo.IndexOf("dc" + dcNo);
|
||
|
||
//This code will add the dr attribute recids sent from the getdep, and store the deleted row information for save.
|
||
ArrayList delRecIds = new ArrayList();
|
||
if (delIdx != -1)
|
||
{
|
||
string[] delIds = AxDelRecIds[delIdx].ToString().Split(',');
|
||
for (int ind = 0; ind < delIds.Length; ind++)
|
||
{
|
||
if (delIds[ind].ToString() != string.Empty)
|
||
delRecIds.Add(delIds[ind].ToString());
|
||
}
|
||
}
|
||
|
||
string[] popRows = dcData[1].ToString().Split(',');
|
||
//This loop is reversed as the array will be sorted in asc order. and while deleting it should always be in desc order.
|
||
for (int j = popRows.Length - 1; j >= 0; j--)
|
||
{
|
||
if (popRows[j] != "")
|
||
{
|
||
string rowNum = popRows[j].ToString();
|
||
DataTable DCTable = dsDataSet.Tables["dc" + dcNo];
|
||
DataTable DCOldTable = dsDataSet.Tables["dc_old" + dcNo];
|
||
|
||
int rNo = Convert.ToInt32(rowNum);
|
||
if (rNo == 0) rNo = 1;
|
||
DataRow foundRow = DCTable.Rows.Find(rNo);
|
||
DataRow oldRow = DCOldTable.Rows.Find(rNo);
|
||
|
||
if (foundRow != null)
|
||
{
|
||
StringBuilder strDelRowFlds = new StringBuilder();
|
||
string axpRecidVal = "0";
|
||
string axpNode = string.Empty;
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
for (int k = startIdx; k <= endIdx; k++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[k];
|
||
if (recordid != "0")
|
||
{
|
||
if (oldRow != null)
|
||
{
|
||
if (fld.name == "axp_recid" + dcNo)
|
||
{
|
||
axpNode = "<" + fld.name + ">" + CheckSpecialChars(oldRow["old__" + fld.name].ToString()) + "</" + fld.name + ">";
|
||
axpRecidVal = foundRow[fld.name].ToString();
|
||
}
|
||
else
|
||
{
|
||
strDelRowFlds.Append("<" + fld.name + ">" + CheckSpecialChars(oldRow["old__" + fld.name].ToString()) + "</" + fld.name + ">");
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (delRecIds.IndexOf(axpRecidVal) != -1)
|
||
DelRowFldsXml.Add(axpRecidVal + "♦" + axpNode + strDelRowFlds.ToString());
|
||
|
||
|
||
foundRow.Delete();
|
||
DCTable.AcceptChanges();
|
||
DCTable.PrimaryKey = null;
|
||
int givenRow = Convert.ToInt32(rNo);
|
||
foreach (DataRow thisrow in DCTable.Rows)
|
||
{
|
||
int thisRowNo = Convert.ToInt32(thisrow["axp__rowno"]);
|
||
if (thisRowNo > givenRow)
|
||
thisrow["axp__rowno"] = thisRowNo - 1;
|
||
}
|
||
|
||
|
||
|
||
DCTable.PrimaryKey = new DataColumn[] { DCTable.Columns["axp__rowno"] };
|
||
|
||
if (oldRow != null)
|
||
{
|
||
oldRow.Delete();
|
||
DCOldTable.AcceptChanges();
|
||
}
|
||
|
||
DCOldTable.PrimaryKey = null;
|
||
foreach (DataRow thisrow in DCOldTable.Rows)
|
||
{
|
||
int thisRowNo = Convert.ToInt32(thisrow["axp__rowno"]);
|
||
if (thisRowNo > givenRow)
|
||
thisrow["axp__rowno"] = thisRowNo - 1;
|
||
}
|
||
DCOldTable.PrimaryKey = new DataColumn[] { DCOldTable.Columns["axp__rowno"] };
|
||
//DSDeleteDropDown(dcNo, rowNum);
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
private void DSDeleteDropDown(string dcNo, string rowNum)
|
||
{
|
||
DataTable dsDropDown = dsDataSet.Tables["dsdropdown"];
|
||
if (dsDropDown == null) return;
|
||
int rNo = Convert.ToInt32(rowNum);
|
||
if (rNo == 0) rNo = 1;
|
||
|
||
StringBuilder strDelRowFlds = new StringBuilder();
|
||
string axpNode = string.Empty;
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
for (int j = startIdx; j <= endIdx; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[j];
|
||
DataRow dr = dsDropDown.Rows.Find(fld.name + "-" + Convert.ToString(rNo));
|
||
if (dr != null)
|
||
{
|
||
bool Proceed = false;
|
||
if (dr["mr"].ToString() == "0") Proceed = true;
|
||
|
||
Proceed = Custom_CanDelRowInEsti(fld, dr["mr"].ToString(), dcNo, rowNum);
|
||
if (Proceed)
|
||
{
|
||
dr.Delete();
|
||
dsDropDown.AcceptChanges();
|
||
foreach (DataRow drRow in dsDropDown.Rows)
|
||
{
|
||
int rowNo = Convert.ToInt32(drRow["axp__rowno"]);
|
||
if (rowNo > rNo && fld.name == drRow["fldname"].ToString())
|
||
{
|
||
drRow["axp__rowno"] = rowNo - 1;
|
||
drRow["dropdownkey"] = fld.name + "-" + Convert.ToString(rowNo - 1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
dsDropDown.AcceptChanges();
|
||
}
|
||
|
||
private bool Custom_CanDelRowInEsti(TStructDef.FieldStruct fld, string mr, string dcNo, string rowNum)
|
||
{
|
||
bool Proceed = false;
|
||
if (fld.name == "role") mr = "1";
|
||
if (fld.name == "activity")
|
||
{
|
||
Proceed = true;
|
||
}
|
||
if (mr == "0") Proceed = true;
|
||
return Proceed;
|
||
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to delete all the fields in the given row and dc from the field arrays.
|
||
/// </summary>
|
||
/// <param name="frameNo"></param>
|
||
/// <param name="rowNum"></param>
|
||
private void DeleteRowInFldArrays(string frameNo, string rowNum)
|
||
{
|
||
DSDeleteRow(frameNo, rowNum);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get the index of the given row and dc from the fieldindexarray.
|
||
/// </summary>
|
||
/// <param name="dcNo"></param>
|
||
/// <param name="rowNo"></param>
|
||
/// <returns></returns>
|
||
private int GetRowIndex(int dcNo, int rowNo)
|
||
{
|
||
int idx = 0;
|
||
if (rowNo == 0) rowNo = 1;
|
||
foreach (TStructDef.DcStruct dc in tstStrObj.dcs)
|
||
{
|
||
if (dc.frameno >= dcNo)
|
||
break;
|
||
|
||
idx += GetDcRowCount(dc.frameno.ToString()) * dc.fieldCount;
|
||
}
|
||
|
||
TStructDef.DcStruct currentDC = (TStructDef.DcStruct)tstStrObj.dcs[dcNo - 1];
|
||
//Formula = idx + FieldCountInDC * (RowNo-1) + (FieldOrder - StartOrderInDC)
|
||
idx += currentDC.fieldCount * (rowNo - 1);
|
||
return idx;
|
||
}
|
||
|
||
|
||
private void RefInMemOnSave()
|
||
{
|
||
try
|
||
{
|
||
if (tstStrObj.axp_inmemTids != String.Empty && (HttpContext.Current.Session["RapidTsTruct"] != null && HttpContext.Current.Session["RapidTsTruct"].ToString() == "true") && (HttpContext.Current.Session["AxIsPerfCode"] != null && HttpContext.Current.Session["AxIsPerfCode"].ToString().ToLower() == "true"))
|
||
{
|
||
string[] inMemTids = tstStrObj.axp_inmemTids.Split(',');
|
||
|
||
FDR fdrObj;
|
||
if (HttpContext.Current.Session["FDR"] != null)
|
||
fdrObj = (FDR)HttpContext.Current.Session["FDR"];
|
||
else
|
||
fdrObj = new FDR();
|
||
|
||
FDW fdwObj = FDW.Instance;
|
||
foreach (string Tid in inMemTids)
|
||
{
|
||
ArrayList arrKeys = fdrObj.GetPrefixedKeys(project + "-" + Tid + "-");
|
||
foreach (string key in arrKeys)
|
||
{
|
||
fdwObj.ClearRedisServerDataByKey(key, String.Empty, true);
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
catch (Exception Ex)
|
||
{
|
||
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region Json creation Functions
|
||
|
||
/// <summary>
|
||
/// Function to create json from the data arrays in the stored draft.
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
public string CreateJsonForDraft()
|
||
{
|
||
StringBuilder draftJson = new StringBuilder();
|
||
StringBuilder dcJson = new StringBuilder();
|
||
draftJson.Append("{\"data\":[");
|
||
string tmpStr = string.Empty;
|
||
|
||
//loop for constructing the field value xml based on the frame no, row no and field order
|
||
foreach (TStructDef.DcStruct dc in tstStrObj.dcs)
|
||
{
|
||
string dcNo = Convert.ToString(dc.frameno);
|
||
|
||
DataTable thisDataTable = dsDataSet.Tables["dc" + dcNo];
|
||
if (dc.isgrid)
|
||
{
|
||
errlog = logobj.CreateLog("CreateJsonForDraft", sessionid, "CreateJson-tstData", "new");
|
||
try
|
||
{
|
||
DataRow[] rows;
|
||
rows = thisDataTable.Select("axp__isGrdVld" + dcNo + " = 'false'"); // axp__isGrdVld is Column Name
|
||
foreach (DataRow r in rows)
|
||
thisDataTable.Rows.Remove(r);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
errlog = logobj.CreateLog(ex.Message + ex.StackTrace, sessionid, "CreateJson-tstData", "");
|
||
}
|
||
}
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
|
||
int rowCnt = 0;
|
||
string cr = string.Empty;
|
||
if (dc.isgrid)
|
||
{
|
||
rowCnt = thisDataTable.Rows.Count;
|
||
cr = GetCrAttrJson(rowCnt);
|
||
}
|
||
tmpStr = "{\"n\":\"DC" + dcNo + "\",\"v\":\"" + rowCnt + "\", " + cr + " \"t\":\"dc\", \"hasdatarows\":\"" + (rowCnt > 0 && !string.IsNullOrEmpty(cr) ? "yes" : "no") + "\"}";
|
||
//construct dc json tag
|
||
//{"n":"DC1","v":"1","t":"dc"}
|
||
if (dcJson.ToString() == string.Empty)
|
||
dcJson.Append(tmpStr);
|
||
else
|
||
dcJson.Append("," + tmpStr);
|
||
|
||
foreach (DataRow dr in thisDataTable.Rows)
|
||
{
|
||
int rowNo = Convert.ToInt32(dr["axp__rowno"]);
|
||
for (int j = startIdx; j <= endIdx; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[j];
|
||
dcJson.Append("," + GetFieldJson(rowNo.ToString(), dr, fld, thisDataTable));
|
||
}
|
||
}
|
||
//close here
|
||
}
|
||
draftJson.Append(dcJson + "]}");
|
||
|
||
return draftJson.ToString();
|
||
}
|
||
|
||
public string GetCurrTabStatus(string dcNo)
|
||
{
|
||
//DC1-1,DC2-2
|
||
string isTabOpened = "no";
|
||
dcNo = "DC" + dcNo;
|
||
if (!string.IsNullOrEmpty(TabDcStatus))
|
||
{
|
||
string[] dcAndStatusArray = TabDcStatus.Split(',');
|
||
foreach (string dcAndStatus in dcAndStatusArray)
|
||
{
|
||
string[] status = dcAndStatus.Split('-');
|
||
if (status[0].ToLower() == dcNo.ToLower())
|
||
{
|
||
if (status[1] == "1")
|
||
isTabOpened = "yes";
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return isTabOpened;
|
||
}
|
||
|
||
public string GetTabDCJson(string dcNo)
|
||
{
|
||
StringBuilder draftJson = new StringBuilder();
|
||
StringBuilder dcJson = new StringBuilder();
|
||
draftJson.Append("{\"data\":[");
|
||
string tmpStr = string.Empty;
|
||
bool isGrid = ((TStructDef.DcStruct)tstStrObj.dcs[int.Parse(dcNo) - 1]).isgrid;
|
||
DataTable thisDataTable = dsDataSet.Tables["dc" + dcNo];
|
||
if (isGrid)
|
||
{
|
||
errlog = logobj.CreateLog("CreateJsonForDraft-GetTabDCJson", sessionid, "GetTabDCJson-tstData", "new");
|
||
try
|
||
{
|
||
DataRow[] rows;
|
||
rows = thisDataTable.Select("axp__isGrdVld" + dcNo + " = 'false'"); // axp__isGrdVld is Column Name
|
||
foreach (DataRow r in rows)
|
||
thisDataTable.Rows.Remove(r);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
errlog = logobj.CreateLog(ex.Message + ex.StackTrace, sessionid, "GetTabDCJson-tstData", "");
|
||
}
|
||
}
|
||
|
||
string[] dcRange = tstStrObj.GetDcFieldRange(dcNo).Split(',');
|
||
int startIdx = Convert.ToInt32(dcRange[0]);
|
||
int endIdx = Convert.ToInt32(dcRange[1]);
|
||
int rowCnt = 0;
|
||
string cr = string.Empty;
|
||
if (isGrid)
|
||
{
|
||
rowCnt = thisDataTable.Rows.Count;
|
||
cr = GetCrAttrJson(rowCnt);
|
||
}
|
||
|
||
tmpStr = "{\"n\":\"DC" + dcNo + "\",\"v\":\"" + rowCnt + "\", " + cr + " \"t\":\"dc\", \"hasdatarows\":\"" + (rowCnt > 0 && !string.IsNullOrEmpty(cr) ? "yes" : "no") + "\"}";
|
||
|
||
if (dcJson.ToString() == string.Empty)
|
||
dcJson.Append(tmpStr);
|
||
else
|
||
dcJson.Append("," + tmpStr);
|
||
|
||
|
||
foreach (DataRow dr in thisDataTable.Rows)
|
||
{
|
||
int rowNo = Convert.ToInt32(dr["axp__rowno"]);
|
||
for (int j = startIdx; j <= endIdx; j++)
|
||
{
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[j];
|
||
dcJson.Append("," + GetFieldJson(rowNo.ToString(), dr, fld, thisDataTable));
|
||
}
|
||
}
|
||
|
||
draftJson.Append(dcJson + "]}");
|
||
return draftJson.ToString();
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Function to get the cr attribute for the dc based on the rowcount.
|
||
/// </summary>
|
||
/// <param name="rowCnt"></param>
|
||
/// <returns></returns>
|
||
private string GetCrAttrJson(int rowCnt)
|
||
{
|
||
StringBuilder strCr = new StringBuilder();
|
||
for (int i = 1; i <= rowCnt; i++)
|
||
{
|
||
if (i == 1)
|
||
{
|
||
strCr.Append("\"cr\":");
|
||
strCr.Append("\"i" + i);
|
||
}
|
||
else
|
||
strCr.Append(",i" + i);
|
||
}
|
||
if (strCr.ToString() != string.Empty)
|
||
strCr.Append("\",");
|
||
return strCr.ToString();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get the field json based on its type.
|
||
/// </summary>
|
||
/// <param name="fieldName"></param>
|
||
/// <param name="rowNo"></param>
|
||
/// <param name="fldIndex"></param>
|
||
/// <param name="fld"></param>
|
||
/// <returns></returns>
|
||
private string GetFieldJson(string rowNo, DataRow dr, TStructDef.FieldStruct fld, DataTable dt)
|
||
{
|
||
string fieldName = fld.name;
|
||
string type = string.Empty;
|
||
string value = string.Empty;
|
||
string idVal = string.Empty;
|
||
string oldIdVal = string.Empty;
|
||
string mr = string.Empty;
|
||
string idCol = string.Empty;
|
||
string fldJson = string.Empty;
|
||
string strId = string.Empty;
|
||
string strComboValues = string.Empty;
|
||
string dpm = string.Empty;
|
||
|
||
DataRow dsDataRow = DSGetDropdownRow(fieldName, rowNo);
|
||
|
||
string fldRowVals = string.Empty;
|
||
string dpVals = string.Empty;
|
||
if (dsDataRow != null)
|
||
{
|
||
fldRowVals = dsDataRow["rowvals"].ToString();
|
||
dpVals = dsDataRow["dp"].ToString();
|
||
idCol = dsDataRow["idcol"].ToString();
|
||
mr = dsDataRow["mr"].ToString();
|
||
dpm = dsDataRow["dpmvalues"].ToString();
|
||
}
|
||
|
||
type = GetFieldType(fld);
|
||
value = dr[fld.name].ToString();
|
||
if (dt.Columns.Contains("id__" + fieldName))
|
||
idVal = dr["id__" + fld.name].ToString();
|
||
|
||
|
||
if (dt.Columns.Contains("oldid__" + fld.name))
|
||
oldIdVal = dr["oldid__" + fld.name].ToString();
|
||
|
||
|
||
if (rowNo == "1" && mr == "1" && AxMasterRowFlds.IndexOf(fieldName) == -1)
|
||
AxMasterRowFlds.Add(fieldName);
|
||
|
||
if (rowNo != "1" && AxMasterRowFlds.IndexOf(fieldName) != -1)
|
||
mr = "1";
|
||
|
||
if (mr != "1" && fld.fieldIsFrmList)
|
||
mr = "1";
|
||
|
||
if (mr != string.Empty)
|
||
mr = "\"mr\":\"" + mr + "\",";
|
||
|
||
if (idCol != string.Empty)
|
||
{
|
||
if (idCol == "0") idCol = "no";
|
||
else idCol = "yes";
|
||
idCol = "\"idcol\":\"" + idCol + "\",";
|
||
if (type == "s")
|
||
idCol = string.Empty;
|
||
}
|
||
|
||
if (type == "m")
|
||
value = value.Replace("\n", "<br>");
|
||
|
||
value = CheckSpecialCharsForClient(value);
|
||
|
||
strId = "\"id\":\"" + idVal + "\", \"oldid\":\"" + oldIdVal + "\",";
|
||
|
||
if (dpm != string.Empty)
|
||
dpm = "\"dpm\":\"" + dpm + "\",";
|
||
|
||
if (type == "c")
|
||
strComboValues = GetComboItemsJson(fldRowVals, dpVals);
|
||
|
||
//This is a dummy json example for dropdown
|
||
//{"n":"sponsor","v":"abc","r":"0","idcol":"yes","id":"10032000001017","oldid":"0","mr":"0","dpm":"suffix,title","t":"c"},
|
||
if (fld.savenormal)
|
||
fldJson = "{\"n\":\"" + fld.name + "\",\"v\":\"" + value + "\",\"r\":\"" + rowNo + "\"," + idCol + mr + strId + dpm + " \"t\":\"" + type + "\"}";
|
||
else
|
||
fldJson = "{\"n\":\"" + fld.name + "\",\"v\":\"" + value + "\",\"r\":\"" + rowNo + "\"," + idCol + mr + dpm + "\"t\":\"" + type + "\"}";
|
||
|
||
if (strComboValues != string.Empty)
|
||
fldJson = fldJson + "," + strComboValues;
|
||
return fldJson;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Function to get the json for the dv nodes for a given combo box.
|
||
/// </summary>
|
||
/// <param name="fldIndex"></param>
|
||
/// <returns></returns>
|
||
private string GetComboItemsJson(string fldRowValues, string fldDpValues)
|
||
{
|
||
StringBuilder strItems = new StringBuilder();
|
||
//sample json for dropdown item
|
||
//{"v":"15146000000000~EST-000274-Rev1","t":"dv","dp":"EST-000274~1~001~001~002"},
|
||
string[] choices = fldRowValues.Split('♣');
|
||
string[] dpValues = fldDpValues.Split('♣');
|
||
string tmpStr = string.Empty;
|
||
for (int i = 0; i < choices.Length; i++)
|
||
{
|
||
string strChoice = choices[i].ToString();
|
||
strChoice = CheckSpecialCharsForClient(strChoice);
|
||
if (strChoice != "" && i <= dpValues.Length)
|
||
{
|
||
tmpStr = "{\"v\":\"" + strChoice + "\", \"t\":\"dv\", \"dp\":\"" + dpValues[i].ToString() + "\"}";
|
||
if (strItems.ToString() == string.Empty)
|
||
strItems.Append(tmpStr);
|
||
else
|
||
strItems.Append("," + tmpStr);
|
||
}
|
||
}
|
||
return strItems.ToString();
|
||
}
|
||
|
||
private string CheckSpecialCharsForClient(string value)
|
||
{
|
||
//single quote is handled in the tstruct.aspx.cs file before renddering the json to client.
|
||
//Hence handling only double quote and backward slash.
|
||
//fValue = fValue.Replace("^^dq", "\"");
|
||
//fValue = fValue.Replace(";bkslh", "\\");
|
||
value = value.Replace("\"", "^^dq");
|
||
value = value.Replace("\\", ";bkslh");
|
||
return value;
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// Function to get the field type of the given field and return the type attribute 't' in the json.
|
||
/// </summary>
|
||
/// <param name="fld"></param>
|
||
/// <returns></returns>
|
||
private string GetFieldType(TStructDef.FieldStruct fld)
|
||
{
|
||
string type = string.Empty;
|
||
type = fld.ctype.ToUpper();
|
||
string moe = string.Empty;
|
||
|
||
if (fld.moe.ToLower() == "select")
|
||
{
|
||
if (fld.editcombo)
|
||
return "s";
|
||
else
|
||
return "c";
|
||
}
|
||
else
|
||
{
|
||
switch (type)
|
||
{
|
||
case "CHECK LIST":
|
||
return "cl";
|
||
case "MEMO":
|
||
return "m";
|
||
case "IMAGE":
|
||
return "i";
|
||
case "CHECK BOX":
|
||
return "s";
|
||
default:
|
||
if (type.IndexOf("AXPBUTTON") != -1)
|
||
return "b";
|
||
else
|
||
return "s";
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
public string GetFieldSqlQuery(string fldName, string fldValues, string globalVar, string userVars, int activeRow, string parentFlds)
|
||
{
|
||
int fldidx = tstStrObj.GetFieldIndex(fldName);
|
||
TStructDef.FieldStruct fld = (TStructDef.FieldStruct)tstStrObj.flds[fldidx];
|
||
string sqlQuery = fld.fieldSqlQuery;
|
||
string sqlParamsXML = string.Empty, appVarTypes = string.Empty, parentFldVals = string.Empty;
|
||
try
|
||
{
|
||
sqlQuery = "<sqltext>" + CheckSpecialChars(sqlQuery) + "</sqltext>";
|
||
fldValues = "<fldXML>" + fldValues + "</fldXML>";
|
||
XmlDocument xmlDoc = new XmlDocument();
|
||
xmlDoc.LoadXml(fldValues);
|
||
sqlParamsXML += "<globalvars>";
|
||
// in cluase paramets for grid field {invioceno*} for non grid field {invioceno}
|
||
if (Regex.Match(sqlQuery.ToLower(), @"{\b\w+\b}", RegexOptions.IgnoreCase).Success || Regex.Match(sqlQuery.ToLower(), @"{\b\w+\b\*}", RegexOptions.IgnoreCase).Success)
|
||
{
|
||
MatchCollection matchListSt = Regex.Matches(sqlQuery, @"{\b\w+\b\*}");
|
||
var listSt = matchListSt.Cast<Match>().Select(match => match.Value).Distinct().ToList();
|
||
MatchCollection matchList = Regex.Matches(sqlQuery, @"{\b\w+\b}");
|
||
var list = matchList.Cast<Match>().Select(match => match.Value).Distinct().ToList();
|
||
if (listSt.Count > 0)
|
||
{
|
||
foreach (var lst in listSt)
|
||
{
|
||
string strFld = lst.Split('{')[1].Split('*')[0];
|
||
XmlNodeList slctNode = xmlDoc.SelectNodes("fldXML/" + strFld + "");
|
||
int ic = 0;
|
||
string stFldValue = string.Empty;
|
||
foreach (XmlElement strText in slctNode)
|
||
{
|
||
if (strText.InnerText != "")
|
||
stFldValue += strText.InnerText + "~";
|
||
if (ic == 0)
|
||
{
|
||
int fldidxs = tstStrObj.GetFieldIndex(strFld);
|
||
TStructDef.FieldStruct flds = (TStructDef.FieldStruct)tstStrObj.flds[fldidxs];
|
||
if (flds.datatype == "Character" || flds.datatype == "Text")
|
||
appVarTypes += "c";
|
||
else if (flds.datatype == "Numeric")
|
||
appVarTypes += "n";
|
||
else if (flds.datatype == "Date/Time")
|
||
appVarTypes += "d";
|
||
}
|
||
ic++;
|
||
}
|
||
if (stFldValue != string.Empty)
|
||
stFldValue = stFldValue.Remove(stFldValue.Length - 1);
|
||
sqlParamsXML += "<" + strFld + ">" + stFldValue + "</" + strFld + ">";
|
||
parentFldVals += strFld + ":" + stFldValue + "~";
|
||
}
|
||
}
|
||
if (list.Count > 0)
|
||
{
|
||
foreach (var lst in list)
|
||
{
|
||
string strFld = lst.Split('{')[1].Split('}')[0];
|
||
sqlParamsXML += xmlDoc.SelectSingleNode("fldXML/" + strFld + "").OuterXml;
|
||
parentFldVals += strFld + ":" + xmlDoc.SelectSingleNode("fldXML/" + strFld + "").InnerXml + "~";
|
||
int fldidxs = tstStrObj.GetFieldIndex(strFld);
|
||
TStructDef.FieldStruct flds = (TStructDef.FieldStruct)tstStrObj.flds[fldidxs];
|
||
if (flds.datatype == "Character" || flds.datatype == "Text")
|
||
appVarTypes += "c";
|
||
else if (flds.datatype == "Numeric")
|
||
appVarTypes += "n";
|
||
else if (flds.datatype == "Date/Time")
|
||
appVarTypes += "d";
|
||
}
|
||
}
|
||
}
|
||
if (sqlQuery.Contains(":"))// to check any of tstruct fields & global Vars
|
||
{
|
||
if (Regex.Match(sqlQuery, String.Format(@":\b{0}\b", "recordid"), RegexOptions.IgnoreCase).Success)
|
||
{
|
||
if (xmlDoc.InnerText != "")
|
||
{
|
||
//sqlParamsXML += xmlDoc.SelectSingleNode("fldXML/axp_recid1").OuterXml;
|
||
string StrRecId = xmlDoc.SelectSingleNode("fldXML/axp_recid1").OuterXml;
|
||
StrRecId = StrRecId.Replace("axp_recid1", "recordid");
|
||
sqlParamsXML += StrRecId;
|
||
parentFldVals += "recordid:" + xmlDoc.SelectSingleNode("fldXML/axp_recid1").InnerXml + "~";
|
||
}
|
||
else
|
||
{
|
||
sqlParamsXML += "recordid";
|
||
parentFldVals += "recordid:0~";
|
||
}
|
||
int fldidxs = tstStrObj.GetFieldIndex("axp_recid1");
|
||
TStructDef.FieldStruct flds = (TStructDef.FieldStruct)tstStrObj.flds[fldidxs];
|
||
if (flds.datatype == "Character" || flds.datatype == "Text")
|
||
appVarTypes += "c";
|
||
else if (flds.datatype == "Numeric")
|
||
appVarTypes += "n";
|
||
else if (flds.datatype == "Date/Time")
|
||
appVarTypes += "d";
|
||
}
|
||
foreach (XmlNode parms in xmlDoc.ChildNodes[0].ChildNodes)
|
||
{
|
||
if (Regex.Match(sqlQuery, String.Format(@":\b{0}\b", parms.Name.ToString()), RegexOptions.IgnoreCase).Success)
|
||
{
|
||
int fldidxs = tstStrObj.GetFieldIndex(parms.Name);
|
||
TStructDef.FieldStruct flds = (TStructDef.FieldStruct)tstStrObj.flds[fldidxs];
|
||
bool isDcGrid = false;
|
||
isDcGrid = IsDcGrid(flds.fldframeno.ToString(), tstStrObj);
|
||
if (isDcGrid == true && int.Parse(parms.Attributes["rowno"].Value) == activeRow)
|
||
{
|
||
sqlParamsXML += parms.OuterXml;
|
||
parentFldVals += parms.Name + ":" + parms.InnerXml + "~";
|
||
if (flds.datatype == "Character" || flds.datatype == "Text")
|
||
appVarTypes += "c";
|
||
else if (flds.datatype == "Numeric")
|
||
appVarTypes += "n";
|
||
else if (flds.datatype == "Date/Time")
|
||
appVarTypes += "d";
|
||
}
|
||
else if (isDcGrid == false)
|
||
{
|
||
sqlParamsXML += parms.OuterXml;
|
||
parentFldVals += parms.Name + ":" + parms.InnerXml + "~";
|
||
if (flds.datatype == "Character" || flds.datatype == "Text")
|
||
appVarTypes += "c";
|
||
else if (flds.datatype == "Numeric")
|
||
appVarTypes += "n";
|
||
else if (flds.datatype == "Date/Time")
|
||
appVarTypes += "d";
|
||
}
|
||
}
|
||
}
|
||
XmlDocument xmlDocgbl = new XmlDocument();
|
||
xmlDocgbl.LoadXml(globalVar);
|
||
string blgAppVar = string.Empty;
|
||
if (xmlDocgbl.SelectSingleNode("globalvars/appvartypes") != null)
|
||
blgAppVar = xmlDocgbl.SelectSingleNode("globalvars/appvartypes").InnerXml;
|
||
int gblIcnt = 1;
|
||
foreach (XmlNode parms in xmlDocgbl.ChildNodes[0].ChildNodes)
|
||
{
|
||
if (Regex.Match(sqlQuery, String.Format(@":\b{0}\b", parms.Name.ToString()), RegexOptions.IgnoreCase).Success && parms.Name != "appvartypes" && !Regex.Match(sqlParamsXML, System.String.Format(@"<\b{0}\b", parms.Name.ToString()), RegexOptions.IgnoreCase).Success)
|
||
{
|
||
sqlParamsXML += parms.OuterXml;
|
||
parentFldVals += parms.Name + ":" + parms.InnerXml + "~";
|
||
if (blgAppVar.Length >= gblIcnt)
|
||
appVarTypes += blgAppVar[gblIcnt - 1].ToString();
|
||
else if (blgAppVar.Length < gblIcnt)
|
||
appVarTypes += "c";
|
||
}
|
||
gblIcnt++;
|
||
}
|
||
|
||
XmlDocument xmlDocUv = new XmlDocument();
|
||
xmlDocUv.LoadXml(userVars);
|
||
foreach (XmlNode parms in xmlDocUv.ChildNodes[0].ChildNodes)
|
||
{
|
||
if (Regex.Match(sqlQuery, String.Format(@":\b{0}\b", parms.Name.ToString()), RegexOptions.IgnoreCase).Success)
|
||
{
|
||
sqlParamsXML += parms.OuterXml;
|
||
parentFldVals += parms.Name + ":" + parms.InnerXml + "~";
|
||
appVarTypes += "c";
|
||
}
|
||
}
|
||
}
|
||
if (sqlParamsXML != "<globalvars>")
|
||
sqlParamsXML += "<appvartypes>" + appVarTypes + "</appvartypes>";
|
||
sqlParamsXML += "</globalvars>";
|
||
if (activeRow == 0)
|
||
{
|
||
string SessAutKey = "autocomplete♦" + transid + "-" + fldName + "-" + parentFlds;
|
||
HttpContext.Current.Session[SessAutKey] = sqlQuery + sqlParamsXML + "♠" + parentFldVals;
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
}
|
||
return sqlQuery + sqlParamsXML + "♠" + parentFldVals;
|
||
}
|
||
}
|
||
#endregion
|