/// <summary> /// Version Feb13-17 /// Execute method when timer is due /// Must retreive etlTimer information to validate if service is active / running (busy) /// Validate the following for each of the services: /// 1 - The service exist in the EtlTimer table. /// 2 - The service is active. /// 3 - The service is not currently busy running another thread. /// </summary> /// <param Object name="e"></param>False private void SchedularCallback(object e) { // Get etlTimer info. for this service syncRow = wtf.getImportControl(serviceId); // if (syncRow.IsActive) { if (syncRow.IsRunning) { // Ignore process if service is busy performing another thread wtf.writeSyncLog(9, syncRow.MwEtlTimerId, 1, syncRow.ServiceName, "Sync service for " + syncRow.ServiceName + " not processed, is busy in other thread."); // this.WriteToFile("NAV Service Log - not processed, service is busy in other thread: {0}"); } else { // Input Files services is performed here. // SyncControl(); /// Version 2.0 // SyncControl(syncRow); /// Version 3.0 if (syncRow.MwEtlTimerId == 17 || syncRow.MwEtlTimerId == 1 || syncRow.MwEtlTimerId == 2 || syncRow.MwEtlTimerId == 18) { // Input files comming from db tables SyncControl_Disk(syncRow); /// Version 3.1 } else { // Input files comming from windows folders SyncControl(syncRow); /// Version 3.1 } } } else { // Ignore process when service is not active. wtf.writeSyncLog(9, syncRow.MwEtlTimerId, 1, syncRow.ServiceName, "Sync service for " + syncRow.ServiceName + " is not active"); // this.WriteToFile("NAV Service Log - not processed, service is inactive: {0}"); } this.ScheduleService(); }
int serviceId = 0; // Convert.ToInt16(ConfigurationManager.AppSettings["ServiceID"]); /// // EtlTimer sync = new EtlTimer(); /// ************************************************************************************** /// Replaced in Version 3.0 /// Perform Directory File search process when task time is due /// Look for existing files in the new files folder /// Same method is used in the WindowsService version.... /// -------------------------------------------------------------------------------------- ///public void FileSearch(object e, EtlTimer sync) //{ // if (serviceId == 0) // { // //serviceId = Convert.ToInt16(ConfigurationManager.AppSettings["ServiceID"]); ; // //sync = wtf.getImportControl(serviceId); // serviceId = sync.MwEtlTimerId; // } // List<string> li = new List<string>(); // // // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, " > (GK FileSearch) Start Directory scanning. for " + sync.ServiceName + "."); // // // //li.Add(ConfigurationManager.AppSettings["NewFilesDirectory"].ToString()); // C:\\AppData // li.Add(sync.InputFileFolder); // if (li.Count == 0) // { // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, " > (GK FileSearch) No Folder to process. for " + sync.ServiceName); // } // foreach (string path in li) // { // if (File.Exists(path)) // { // // This path is a file // ProcessFile(path, sync); // } // else if (Directory.Exists(path)) // { // // This path is a directory // ProcessDirectory(path, sync); // } // else // { // // Invalid File or Directory exit // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, "(GK FileSearch) <" + path + " > is not a valid file or directory."); // } // } // /// ******************************************************************************* // /// Back to Service SchedularCallback Function // /// When FileSearch is completed process flow return to Service1.SchedularCallback. // /// ------------------------------------------------------------------------------- //} //// ************************************************************************ //// Process all files in the directory passed in, recurse on any directories //// that are found, and process the files they contain. //// ------------------------------------------------------------------------ //public void ProcessDirectory(string targetDirectory, EtlTimer sync) //{ // /// // string[] fileEntries = Directory.GetFiles(targetDirectory); // foreach (string fileName in fileEntries) // { // ProcessFile(fileName, sync); // } // // Recurse into subdirectories of this directory. // string[] subdirectoryEntries = Directory.GetDirectories(targetDirectory); // foreach (string subdirectory in subdirectoryEntries) // ProcessDirectory(subdirectory, sync); //} /// ***************************************************************************************** /// Version 3.0 /// General files process - Only Text valid Files are processed here: /// (1) - Select files to process depending on file extension and/or file name. /// (2) - Route process to the corresponding file types import process using delegates. /// (3) - Unrecognized file types and Service reading errors are detected here. /// (4) - Errors are logged in service log and reported through web services. /// /// USE THIS SECTION TO ADD ALL FILE TYPES TO BE INCLUDED IN THE IMPORT PROCESS /// ----------------------------------------------------------------------------------------- private void ProcessFile(string path, EtlTimer sync) { int dirLen = (ConfigurationManager.AppSettings["NewFilesDirectory"].ToString()).Length + 1; /// string extension = (Path.GetExtension(path)).ToString(); string fileName = Path.GetFileNameWithoutExtension(path); /// Initialize Error messages object basic information ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "5"; errMsg.FileName = fileName + extension; errMsg.NISOrderId = "0"; errMsg.Status = "Not Processed"; errMsg.Message = string.Empty; try { /// ********************************************************************************* /// Select files acceptable to be process, all other file types (extension) will not /// be processed (they stay in the newFiles folder) and an error message is generated /// to the WebServices. /// --------------------------------------------------------------------------------- if (extension == ".txt") { /// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /// Process all txt files here, they must belong to WE or G&K /// --------------------------------------------------------------------------------- DelTxt handler = null; // Declare a class instance txt: ImportProcedure_GK_PO.TextFiles.ImportProcess txt = new ImportProcedure_GK_PO.TextFiles.ImportProcess(); /// Declare an interface instance txtFile: ITextFiles txtfile = (ITextFiles)txt; if (fileName.Substring(0, 6) == "WE XML") { // WE - XML Order Files handler = txtfile.ProcessWEFiles; } else { // G&K Text files handler = txtfile.ProcessGKFiles; } /// =========== > ProcessTxt(path, fileName, handler, sync); /// < =========== } else { /// Unrecognized file type errMsg.NISOrderId = fileName; errMsg.Message = "GK ProcessFile) File <" + fileName + extension + ">, unrecognized file type."; wtf.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, errMsg.Message); /// Move file to problem directory icr.SaveProcessedFile(path, false, sync, "GK"); } } catch (Exception fle) { int res = wtf.updImportControl(sync.MwEtlTimerId, 0); // set EtlTimer for this service to not Running (isRunning = false) errMsg.Message = "((GK_PO ProcessFile) txt reading error - File in " + errMsg.FileName + ". " + fle; wtf.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, errMsg.Message); } }
/// <summary> /// Version 3.0 /// Route process to the corresponding service ProcessFile Method depending on the /// service id. /// Control the start/end of each service, /// </summary> /// <param name="path"></param> /// <param name="sync"></param> private void ProcessFile(string path, EtlTimer sync) { int res = wtf.updImportControl(serviceId, 1); // set EtlTimer for this service to InUse object e = new object(); // ================================================================================= switch (serviceId) { case 10: ImportProcedure_NIS.FileManagement FileNis = new ImportProcedure_NIS.FileManagement(); FileNis.ProcessFile(path, sync); break; case 15: ImportProcedure_NBI.FileManagement FileNbiT = new ImportProcedure_NBI.FileManagement(); FileNbiT.ProcessFile(path, sync); break; case 16: ImportProcedure_STK.FileManagement FileStkT = new ImportProcedure_STK.FileManagement(); FileStkT.ProcessFile(path, sync); break; } res = wtf.updImportControl(serviceId, 0); // set EtlTimer for this service to Inactive }
//private void WriteToFile(string text) //{ // string path = "C:\\ServiceLogNAVTest.txt"; // using (StreamWriter writer = new StreamWriter(path, true)) // { // writer.WriteLine(string.Format(text, DateTime.Now.ToString("dd/MM/yyyy hh:mm:ss tt"))); // writer.Close(); // } //} /// <summary> Version 2.0 /// Controls all windows services related with the import function. /// Route the process flow to the corresponding service depending in the process id. /// </summary> //public void SyncControl() //{ // // int res = wtf.updImportControl(serviceId, 1); // set EtlTimer for this service to InUse // object e = new object(); // // ================================================================================= // if (serviceId == 10) // { // ImportProcedure_NIS.FileManagement fileManagement = new ImportProcedure_NIS.FileManagement(); // fileManagement.FileSearch(e, syncRow); // } // else if (serviceId == 11) // { // ImportProcedure_GK_PO.FileManagement fileManagement = new ImportProcedure_GK_PO.FileManagement(); // fileManagement.FileSearch(e, syncRow); // } // else if (serviceId == 12) // { // ImportProcedure_ArrowFtp.FileManagement fileManagement = new ImportProcedure_ArrowFtp.FileManagement(); // fileManagement.FileSearch(e, syncRow); // } // else if (serviceId == 13) // { // ImportProcedure_NBI.FileManagement fileManagement = new ImportProcedure_NBI.FileManagement(); // fileManagement.FileSearch(e, syncRow); // } // else if (serviceId == 15) // { /// Nav NBI Import test option // ImportProcedure_NBI.FileManagement fileManagement = new ImportProcedure_NBI.FileManagement(); // fileManagement.FileSearch(e, syncRow); // } // res = wtf.updImportControl(serviceId, 0); // set EtlTimer for this service to Inactive // ================================================================================ ///} /// ************************************************************************************ /// Version 3.0 methods start here, they replace the SyncControl Method /// All import services share the same input (directory/files) access methods /// ------------------------------------------------------------------------------------ public void SyncControl(EtlTimer sync) { List <string> li = new List <string>(); // wtf.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, " > (FileSearch) Start Directory scanning. for " + sync.ServiceName + "."); // li.Add(sync.InputFileFolder); if (li.Count == 0) { wtf.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, " > (FileSearch) No Folder to process. for " + sync.ServiceName); } else { // Input files folder found foreach (string path in li) { if (File.Exists(path)) { // This path is a file ProcessFile(path, sync); } else if (Directory.Exists(path)) { // This path is a directory ProcessDirectory(path, sync); } else { // Invalid File or Directory exit wtf.writeSyncLog(2, sync.MwEtlTimerId, 1, sync.ServiceName, "(FileSearch) <" + path + " > is not a valid file or directory."); } } } }
/// <summary> /// Version 3.0 /// Process text files, text files are routed here the corresponding import process and /// WebService depending on the Process method assigned through the delegate specified /// in the handler parameter. /// Does not apply to version 3.0 [After processing, the complete original file content is send to the webServices for /// storage in OrderRaw table.] /// </summary> /// <param name="path">Incoming file complete path</param> /// <param name="tst">file name without extnsion</param> /// <param name="handler">Delegate that points to the corresponding process method</param> private void ProcessTxt(string path, string tst, DelTxt handler, EtlTimer sync) { bool ok = false; /// =============== > Process file and WebService using sync method //bool processResult = handler(path, tst, sync); ok = handler(path, tst, sync); /// PERFORM getTextFileContent while waiting for 'processResult' response. /// /// DO NOT SAVE INPUT FILE AS RAW DATA IN THE MIDDLEWARE - Version 2.0 up /// **************************************************************************************** /// Call Web Service to transfer a copy of the processed file through RawData /// ---------------------------------------------------------------------------------------- // NO RAW DATA IS SEND TO THE MIDDLEWARE /// ========================================= // bool r = getTextFileContent(path, sync); // ========================================= /// DON't PERFORM THE FOLLOWING STEPS UNTIL 'processResult' IS COMPLETED //bool ok = processResult; /// Exit to final file process step. //if (ok) //{ ///DAL.ImportControl.ImportControlRepository icr = new DAL.ImportControl.ImportControlRepository(); wtf.SaveProcessedFile(path, ok, sync, "Arrow"); //} }
/// ***************************************************************************************** /// General Tables process - Only Web/convert orders rows are processed here: /// (1) - Select order type process depending on order type. /// (2) - Route process to the corresponding order types import process using delegates. /// (3) - Unrecognized data types and Service reading errors are detected here. /// (4) - Errors are logged in service log and reported through web services. /// ----------------------------------------------------------------------------------------- public void ProcessOrder(string order, EtlTimer sync) { /// Initialize Error messages object basic information string OrdNumber = ""; ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; errMsg.FileName = "Catalog Design Request: " + order.ToString(); errMsg.NISOrderId = "0"; errMsg.Status = "Not Processed"; errMsg.Message = string.Empty; try { /// ********************************************************************************* /// Select files acceptable to be process, all other file types (extension) will not /// be processed (they stay in the newFiles folder) and an error message is generated /// to the WebServices. /// Only Catalog Web Order (1) row are processed by entry. /// --------------------------------------------------------------------------------- // access catalog convert orders list if (sync.OrderType == 0) { /// ======== > DesignRequest designRequest = new DesignRequest(); designRequest = idr.getDesignRequest(order); /// <========= OrdNumber = designRequest.DesignId; // /// Instanciate NBI Tables methods delegate Del handler = null; // Declare a class instance: ImportProcedure_DesignRequest.DesignRequestJson.ImportProcess table = new ImportProcedure_DesignRequest.DesignRequestJson.ImportProcess(); /// Declare an interface instance Table: ImportProcedure_DesignRequest.DesignRequestJson.IDesignRequestTables designClass = (ImportProcedure_DesignRequest.DesignRequestJson.IDesignRequestTables)table; /// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /// Identify Catalog Web order table and route them to the corresponding import procedure /// ---------------------------------------------------------------------------- // Catalog Web Order table process handler = designClass.ProcessDesignRequestOrder; // /// =========== > bool ok = false; ok = handler(designRequest, order, sync); // Process file and WebService // OrdNumber = (designRequest.DesignId).ToString(); // } else { // update error order - set imported on and import problem on ikr.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, "Table reading error order header not found or no items in file, order " + OrdNumber); } } catch (Exception fle) { int res = ikr.updImportControl(sync.MwEtlTimerId, 0); // set EtlTimer for this service to not Running (isRunning = false) errMsg.Message = "(Catalog Design request Process) Table reading error - in order " + errMsg.FileName + ". " + fle; ikr.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, errMsg.Message); } }
protected override void OnStart(string[] args) { // this.WriteToFile("NAV Service Test started {0}"); if (syncRow.MwEtlTimerId == 0) { syncRow = wtf.getImportControl(serviceId); } //string ret = wtf.writeSyncLog(1, serviceId, 1, syncRow.ServiceName, "==> Window service for: " + syncRow.ServiceName + " started "); string ret = wtf.writeSyncLog(1, syncRow.MwEtlTimerId, 1, syncRow.ServiceName, "==> Window service for: " + syncRow.ServiceName + " started "); this.ScheduleService(); }
/// ***************************************************************************************** /// General files process - Only NIS XML valid Files are processed here: /// (1) - Select orders to process depending on WasImported status. /// (2) - Route process to the corresponding import process using delegates. /// (3) - NIS table reading errors are detected here. /// (4) - Errors are logged in service log and reported through web services. /// ----------------------------------------------------------------------------------------- public void ProcessOrder(int order, EtlTimer sync) { /// Initialize Error messages object basic information ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; errMsg.FileName = "Order: " + order.ToString(); errMsg.NISOrderId = "0"; errMsg.Status = "Not Processed"; errMsg.Message = string.Empty; try { /// ********************************************************************************* /// Select files acceptable to be process, all other file types (extension) will not /// be processed (they stay in the newFiles folder) and an error message is generated /// to the WebServices. /// Only NIS (1) row are processed by entry. /// --------------------------------------------------------------------------------- NisTables NisOrder = new NisTables(); NisOrder = Inr.getNisOrder(order); if (NisOrder != null && NisOrder.items != null) { /// Instanciate NBI Tables methods delegate Del handler = null; // Declare a class instance xml: ImportProcedure_NIS_V2.BuildJason.ImportProcess table = new ImportProcedure_NIS_V2.BuildJason.ImportProcess(); /// Declare an interface instance Table: ImportProcedure_NIS_V2.BuildJason.INISTables orderClass = (ImportProcedure_NIS_V2.BuildJason.INISTables)table; /// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /// Route to the corresponding NIS import procedure /// ---------------------------------------------------------------------------- handler = orderClass.ProcessNisOrder; bool ok = false; ok = handler(NisOrder, order, sync); // Process file and WebService } else { // update error order - set imported on and import problem on int ret = Inr.updNisOrder(order, 0, 1, 0); icr.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, "Table reading error order header or no items found, order " + order); } } catch (Exception fle) { int res = icr.updImportControl(sync.MwEtlTimerId, 0); // set EtlTimer for this service to not Running (isRunning = false) errMsg.Message = "(NIS ProcessFile) Table reading error - in order " + errMsg.FileName + ". " + fle; icr.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, errMsg.Message); int resp = Inr.updNisOrder(Convert.ToInt32(errMsg.FileName), 0, 1, 0); } }
/// <summary> /// Get syncControlTable status for an specific type of table. /// 10 - NIS Imports /// 11 - NIB Imports /// 12 - Shipping address /// </summary> /// <param name="type">Service type code</param> /// <returns>Boolean true if service is active and not busy</returns> public EtlTimer getImportControl(int type) { SqlDataReader dr = null; //Boolean active = false; EtlTimer row = new EtlTimer(); try { System.Collections.Specialized.NameValueCollection args = new NameValueCollection(); args.Add("@etlTaskId", type.ToString()); //DBContext.DBAccess access = new DBContext.DBAccess(); // dr = access.ExecuteReader("[MW_GetETLTaskTimer]", DBContext.DBAccess.DBConnection.SqlMainNew, args); // //EtlTimer row = new EtlTimer(); //string serviceAvailability = "not active"; while (dr != null && dr.Read()) { row.MwEtlTimerId = (Int32)(dr["MwEtlTimerId"].ToString().Length > 0 ? Int32.Parse(dr["MwEtlTimerId"].ToString()) : 0); row.Description = dr["Description"].ToString().Length > 0 ? dr["Description"].ToString() : ""; row.ServiceName = dr["ServiceName"].ToString().Length > 0 ? dr["ServiceName"].ToString() : ""; row.IsActive = Convert.ToBoolean(dr["IsActive"]); row.FrequencyInSecs = (Int64)(dr["FrequencyInSecs"].ToString().Length > 0 ? Int64.Parse(dr["FrequencyInSecs"].ToString()) : 0); row.IsRunning = Convert.ToBoolean(dr["IsRunning"]); row.DailyRunTime = dr["DailyRunTime"].ToString().Length > 0 ? TimeSpan.Parse(dr["DailyRunTime"].ToString()) : TimeSpan.Zero; row.LastRunDate = dr["LastRunDate"].ToString().Length > 0 ? DateTime.Parse(dr["LastRunDate"].ToString()) : DateTime.MinValue; row.IsApiRunning = Convert.ToBoolean(dr["IsApiRunning"]); row.WebServiceOrders = dr["WebServiceOrders"].ToString().Length > 0 ? dr["WebServiceOrders"].ToString() : ""; row.WebServiceAccounts = dr["WebServiceAccounts"].ToString().Length > 0 ? dr["WebServiceAccounts"].ToString() : ""; row.WebServiceDesigns = dr["WebServiceDesigns"].ToString().Length > 0 ? dr["WebServiceDesigns"].ToString() : ""; row.WebServiceRaw = dr["WebServiceRaw"].ToString().Length > 0 ? dr["WebServiceRaw"].ToString() : ""; row.WebServiceErrors = dr["WebServiceErrors"].ToString().Length > 0 ? dr["WebServiceErrors"].ToString() : ""; row.InputFileFolder = dr["InputFileFolder"].ToString().Length > 0 ? dr["InputFileFolder"].ToString() : ""; row.ExcelFileFolder = dr["ExcelFileFolder"].ToString().Length > 0 ? dr["ExcelFileFolder"].ToString() : ""; row.ProblemFileFolder = dr["ProblemFileFolder"].ToString().Length > 0 ? dr["ProblemFileFolder"].ToString() : ""; row.ProcessedFileFolder = dr["ProcessedFileFolder"].ToString().Length > 0 ? dr["ProcessedFileFolder"].ToString() : ""; } return(row); } finally { if ((dr != null) && (!dr.IsClosed)) { dr.Close(); } } }
// ************************************************************************ // Process all files in the directory passed in, recurse on any directories // that are found, and process the files they contain. // ------------------------------------------------------------------------ public void ProcessDirectory(string targetDirectory, EtlTimer sync) { int read = 0; /// string[] fileEntries = Directory.GetFiles(targetDirectory); foreach (string fileName in fileEntries) { ProcessFile(fileName, sync); read = read + 1; } wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, " > (FileSearch) " + sync.ServiceName + " Files read: " + read.ToString()); // Recurse into subdirectories of this directory. string[] subdirectoryEntries = Directory.GetDirectories(targetDirectory); foreach (string subdirectory in subdirectoryEntries) { ProcessDirectory(subdirectory, sync); } }
/// ***************************************************************************** /// <summary> /// Write error messages to the WindowsService serviceLog and send same message to /// the WebService (Errors) /// </summary> /// /// "MwOrderMasterId": "1", /// "OrderTypeId" : "1", () from MW_OrderType /// (WebAccount / WebDesign / WebOrder = 2) /// (Nis - Name System = 1 ) /// (Text file - G&K system = 5) /// "Filename" : "test.txt", /// "Message" : "test error" /// ----------------------------------------------------------------------------- //public async Task WriteErrorFile(ServiceResponse source, EtlTimer syncRow) public void WriteErrorFile(ServiceResponse source, EtlTimer syncRow) { /// ****************************************************************************** /// Call Web Service to transfer Error Message /// ------------------------------------------------------------------------------ XDocument doc = new XDocument(); string cleanContent = string.Empty; try { doc = XDocument.Load(JsonReaderWriterFactory.CreateJsonReader( new MemoryStream(Encoding.ASCII.GetBytes(source.Request)), new XmlDictionaryReaderQuotas())); string fileContent = doc.ToString(); cleanContent = fileContent.Replace("\"", "\\\""); } catch (Exception e) { cleanContent = e.Message; } /// Build the error message json string string frame2 = "{\"MwOrderMasterId\" : \"" + "1" + "\", \"OrderTypeId\": " + "\"" + source.FileType + "\"" + ", \"FileName\" : \"" + source.FileName + "\", \"Error\": \"" + source.Message + "\", \"Request\": \"" + cleanContent + "\" }"; /// ==========> /// ServiceResponse resp = ConsumeWebService(frame2, source.FileName, syncRow.WebServiceErrors, syncRow); /// <========== /// ****************************************************************************** /// Write ServiceLog /// ------------------------------------------------------------------------------ //string logPath = (ConfigurationManager.AppSettings["WindowsServiceLog"].ToString()); string message = " > File: <"; /// Set message prefix message = message + source.FileName + ">, Status: <" + source.Status + "> message: <" + source.Message + ">."; wtf.writeSyncLog(1, syncRow.MwEtlTimerId, 1, syncRow.ServiceName, message); }
/// ***************************************************************************************** /// General files process - Only NIS XML valid Files are processed here: /// (1) - Select orders to process depending on Imported conditions. /// (2) - Route process to the corresponding late orders process using delegates. /// (3) - NIS table reading errors are detected here. /// (4) - Errors are logged in service log and reported through web services. /// ----------------------------------------------------------------------------------------- public void ProcessOrder(NISLateOrders order, EtlTimer sync) { /// Initialize Error messages object basic information ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; errMsg.FileName = "Late Order: " + order.ToString(); errMsg.NISOrderId = "0"; errMsg.Status = "Not Processed"; errMsg.Message = string.Empty; try { /// ********************************************************************************* /// Select files acceptable to be process, all other file types (extension) will not /// be processed (they stay in the newFiles folder) and an error message is generated /// to the WebServices. /// Only NIS (1) row are processed by entry. /// --------------------------------------------------------------------------------- if (order != null) { /// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /// Route to the corresponding NIS procedure /// ---------------------------------------------------------------------------- int res = Inr.insertNisLateOrder(order); icr.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, "late order inserted: " + order.ID); } else { // update error order - set imported on and import problem on int ret = Inr.updNisOrder(order.ID, 0, 1, 0); icr.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, "Table reading error Late orders, order " + order); } } catch (Exception fle) { int res = icr.updImportControl(sync.MwEtlTimerId, 0); // set EtlTimer for this service to not Running (isRunning = false) errMsg.Message = "(NIS LateOrders) Table reading error - in order " + errMsg.FileName + ". " + fle; icr.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, errMsg.Message); int resp = Inr.updNisOrder(Convert.ToInt32(errMsg.FileName), 0, 1, 0); } }
/// ******************************************************************************************* /// <summary> /// Final file processing stage - Only XML and txt Files are processed here by moving the file /// from their original folder to AppProcess (when the file was processed ok), or to AppProblem /// if there was a problem with it. In both cases, the file is eliminated from AppData. /// </summary> // -------------------------------------------------------------------------------------------- public void SaveProcessedFile(string path, bool ok, EtlTimer sync, string source) { //WriteLogFile wlf = new WriteLogFile(); DAL.ImportControl.ImportControlRepository wlf = new DAL.ImportControl.ImportControlRepository(); /// string fStatus = "processed"; string fileName = Path.GetFileName(path); string newPath; if (ok) { // Save processesd file in succeeded folder as defined in etlCtrol newPath = sync.ProcessedFileFolder + @"\" + fileName; //newPath = (ConfigurationManager.AppSettings["ProcessedFilesDirectory"].ToString()) + @"\" + fileName; int src = Convert.ToInt32(ConfigurationManager.AppSettings["ServiceID"]); /// /// Save processed files log - May16-2017 /// int res = writeImportLog(src, source, fileName); } else { newPath = sync.ProblemFileFolder + @"\" + fileName; //newPath = (ConfigurationManager.AppSettings["ProblemFilesDirectory"].ToString()) + @"\" + fileName; fStatus = "rejected with errors."; } // delete file, if exist if (File.Exists(newPath)) { File.Delete(newPath); } // Move File from processed to problem directory File.Move(path, newPath); // ************************************************************************* // End of file process message in service log // ------------------------------------------------------------------------- //string tableName = ConfigurationManager.AppSettings["TableName"]; string ret = wlf.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, "> " + sync.Description + " File: <" + fileName + "> " + fStatus + "."); }
/// <summary> /// Process orders to import retreived in SyncControl_Disk, earch order will be process individually. /// Will handle: /// - Catalog Web Orders and Convert orders (Service Id 2) /// - Name System Orders (Service Id 17) /// </summary> /// <param name="order">Order Number</param> /// <param name="sync">Import control parameters</param> /// <param name="item">Order type (1 - Convert. 2 - web orders), apply only for catalog Web Orders</param> private void ProcessRow(int order, EtlTimer sync, string item = "") { int res = wtf.updImportControl(serviceId, 1); // set EtlTimer for this service to InUse object e = new object(); // ================================================================================= if (serviceId == 17) { ImportProcedure_NIS_V2.FileManagement TableNis = new ImportProcedure_NIS_V2.FileManagement(); TableNis.ProcessOrder(order, sync); } else if (serviceId == 1) { ImportProcedure_DesignRequest.FileManagement TableCatalogDesignRequest = new ImportProcedure_DesignRequest.FileManagement(); TableCatalogDesignRequest.ProcessOrder(item, sync); } else if (serviceId == 2) { ImportProcedure_Catalog.FileManagement TableCatalogWorkOrder = new ImportProcedure_Catalog.FileManagement(); TableCatalogWorkOrder.ProcessOrder(item, sync); } res = wtf.updImportControl(serviceId, 0); // set EtlTimer for this service to Inactive }
/// *************************************************************************************** /// <summary> /// Version 10/15/2015 - 14:48 /// Consume web services, in case of error, an error description entry is included /// in the log file. /// WeServiceTimer (method performance measure) and WebServiceOption (Production /// or test) options are controlled through AppConfig.File. /// </summary> /// <param name="frame">Json Data string</param> /// <param name="fName">Processed File name</param> /// <param name="fType">File type (Raw Data or File data) </param> unused /// <param name="fData">WebService url </param> /// <returns>Bool value to true if procces was OK</returns> /// -------------------------------------------------------------------------------------- public ServiceResponse ConsumeWebService(string frame, string fName, string fData, EtlTimer syncRow) //string fType, string fData) { /// Process measurement option, only apply when WebServicesTimer has been set to Yes /// in the AppConfig.file Will measure the process time from starting this method, until /// the response from the WebService is received. Stopwatch stopWatch = new Stopwatch(); if ((ConfigurationManager.AppSettings["WebServicesTimer"].ToString()) == "Yes") { stopWatch.Start(); } /// ---------------------------------------------------------------------------------- //WriteLogFile wlf = new WriteLogFile(); //WriteErrorFile wef = new WriteErrorFile(); ServiceResponse err = new ServiceResponse(); /// process errors description object ServiceResponse resp = new ServiceResponse(); /// Response from web service /// err.FileName = fName; err.Request = frame; /// //bool res = true; var result = string.Empty; try { /// ****************************************************************************** /// Call Web Service /// Web service return string message with operation result. /// Access to Middleware API is controlled through etlTimer Table (IsApiRunning) /// ------------------------------------------------------------------------------ if (syncRow.IsApiRunning) { string uri = fData; var request = (HttpWebRequest)WebRequest.Create(uri); request.ContentType = "text/json"; request.Method = "POST"; using (var client = new WebClient()) { /// Send json data to api supporting special characters within the json data client.Headers[HttpRequestHeader.ContentType] = "application/json"; // Optionally specify an encoding for uploading and downloading strings. client.Encoding = System.Text.Encoding.UTF8; // Upload the data. result = client.UploadString(uri, "POST", frame); //resp.Status = "Error"; // force error response only for testing purposes } resp = JsonConvert.DeserializeObject <ServiceResponse>(result); // ----------------------------------------------------------------------------------------- // When api service return an error response (status not 'OK'), // save the data file information in MW_NavImportProblems table // ----------------------------------------------------------------------------------------- if (resp.Status != "OK") { resp.IsOk = false; // Set response flag to no ok int position = fName.LastIndexOf('-'); ProblemFiles prob = new ProblemFiles(); prob.FileName = fName; if (position == -1) { prob.FileNumber = "n/a"; } else { prob.FileNumber = fName.Substring(position + 1); } prob.JsonData = frame; prob.FileType = ConfigurationManager.AppSettings["FileType"]; // ================ > int write = wtf.writeProblemFile(prob); // < ================ } } else { /// ---------------------------------------------------------------------------- /// Testing webService (using proxy) option, apply only when WebServices Option /// is not set to IsApiRunning in the etlTimer table. /// To use the ApiTest option, uncomment the following code /// ---------------------------------------------------------------------------- //ServiceOrdersClient proxy = new ServiceOrdersClient(); //// route webservice based on file type //result = proxy.AddOrder(frame, fName, fType); resp.Status = "OK"; resp.IsOk = true; } /// -------------------------------------------------------------------------------- /// /// -------------------------------------------------------------------------------- if (!String.IsNullOrEmpty(resp.Status) && (resp.Status != "OK")) { // res = false; resp.IsOk = false; err.NISOrderId = resp.NISOrderId; err.Status = resp.Status; err.Message = "Order id.: " + resp.NISOrderId + " Message: " + resp.Message; /// WriteErrorFile(err, syncRow); } } catch (Exception ex) { int position = fName.LastIndexOf('-'); ProblemFiles prob = new ProblemFiles(); prob.FileName = fName; if (position == -1) { prob.FileNumber = "n/a"; } else { prob.FileNumber = fName.Substring(position + 1); } prob.JsonData = frame; prob.FileType = ConfigurationManager.AppSettings["FileType"]; // ================ > int write = wtf.writeProblemFile(prob); // < ================ /// Replace service log error by WebService call err.NISOrderId = resp.NISOrderId; err.Status = "Not processed"; err.Message = "An error occured while running " + fData + " Web Service, : " + ex.Message; /// WriteErrorFile(err, syncRow); // res = false; resp.IsOk = false; } if ((ConfigurationManager.AppSettings["WebServicesTimer"].ToString()) == "Yes") { stopWatch.Stop(); // Get the elapsed time as a TimeSpan value. TimeSpan ts = stopWatch.Elapsed; // Format and display the TimeSpan value. string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10); Console.WriteLine("File: " + fName + " WebService RunTime " + elapsedTime); } if (resp.Status == "OK") { resp.IsOk = true; } return(resp); }
/// ************************************************************************************************* /// <summary> /// 07/06/2017 10:23 version /// Catalog Web Orders process, un-imported web orders are retreived and mapped to an object (header/detail /// sections). /// Each section is send to WebServices as a JSON string if header/detail information is complete, /// when detail info. /// All errors are send to a Webservice (Error) and included in the Service log. /// </summary> /// <param name="doc">Imported Web orders</param> /// <param name="oNumber">Web Order number</param> /// <param name="syncRow">EtlTimer sync control data)</param> /// <returns>Process status true if procees was completed ok, else false</returns> /// ------------------------------------------------------------------------------------------------- bool ICatalogTables.ProcessCatalogOrder(CatalogOrderTables doc, string oNumber, EtlTimer syncRow) { //bool rStatus = false; // WebService return status (default=false) ServiceResponse rStatus = new ServiceResponse(); DAL.SupportServices.SupportServices wsm = new DAL.SupportServices.SupportServices(); // Set WebService methods pointer /// Create error message object and initialice it ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; // Set Nis Type errMsg.FileName = "Catalog Web orders Table"; errMsg.NISOrderId = oNumber.ToString(); errMsg.Status = "Not Processed"; errMsg.Message = "No items found for this order header"; /// ********************************************************************************************* // Order header section /// --------------------------------------------------------------------------------------------- string jsonHead = "{ \"WebOrderSummary\":" + Newtonsoft.Json.JsonConvert.SerializeObject(doc.CatalogWebOrderSummary); /// ********************************************************************************************* /// Order Detail Section /// -------------------------------------------------------------------------------------------- /// =============================================================================== /// Send Imported files data content to webServices - information must be complete /// Order Header + all related Order Items. /// ------------------------------------------------------------------------------- if (doc.CatalogWebOrderItems.Count > 0) { /// Serialize Items list and complete json string for Header and Items string json2 = jsonHead + ", \"WebOrderItems\" : " + Newtonsoft.Json.JsonConvert.SerializeObject(doc.CatalogWebOrderItems) + "}"; /// ****************************************************************************** /// Call Web Service /// <param name="json2"> Header/detail object Json serialized string.</param> /// <param name="fname"> Xml file name </param> /// <param name="syncRow.WebServiceOrders">File Type, route to web service(url)</param> /// <param name="syncRow"> EtlTimer control data. /// <returns>"rStatus.IsOk" true if WebService was processed, else false</returns> /// *** Web service url is defined in the App.Config file key 'NisOrder'. /// ------------------------------------------------------------------------------ /// ==============> save order data through the defined web service rStatus = wsm.ConsumeWebService(json2, oNumber, syncRow.WebServiceOrders, syncRow); //"OrderData", syncRow); //// TEMPORARY UNCOMMENT TO SEND JSON INFO /// ------------------------------------------------------------------------------ /// UNCOMMENT IF WEB SERVICE IS USED TO SEND JSON INFO // rStatus.IsOK = true; /// set order process to ok TEMPORARY, // rStatus.NISOrderId = "Nav1234567"; /// ------------------------------------------------------------------------------ string apiMsg = ""; int resp = 0; // Order update response DAL.ImportControl.ImportControlRepository ikr = new DAL.ImportControl.ImportControlRepository(); DAL.ImportControl.ImportCatalogRepository icr = new DAL.ImportControl.ImportCatalogRepository(); // if (rStatus.IsOk) { // set order condition to imported apiMsg = " Imported"; resp = icr.updCatalogOrder(oNumber, rStatus.NISOrderId, 1); } else { // Set order contion to imported with errors. apiMsg = " Not Imported - API errors"; } string ret = ikr.writeSyncLog(1, syncRow.MwEtlTimerId, 1, syncRow.ServiceName, "> " + syncRow.Description + " Catalog Web Order: <" + doc.CatalogWebOrderSummary.OrderNumber + "> " + apiMsg + "."); // <============== } else { /// Incomplete order (No order items included and no xls file Name reported in orderHeader) jsonHead = jsonHead + " }"; /// Send Message to WebService wsm.WriteErrorFile(errMsg, syncRow); //// TEMPORARY UNCOMMENT TO SEND JSON INFO } return(rStatus.IsOk); }
int serviceId = 0; // Convert.ToInt16(ConfigurationManager.AppSettings["ServiceID"]); // EtlTimer sync = new EtlTimer(); // Version 2.0 /// ************************************************************************************** /// Version 2.0 Feb13-17 /// Perform Directory File search process when task time is due /// Look for existing files in the NIB new files folder /// Same method is used in the WindowsService version.... /// -------------------------------------------------------------------------------------- //public void FileSearch(object e, EtlTimer sync) /// NOT USED IN Version 3.0 //{ // if (serviceId == 0) // { // //serviceId = Convert.ToInt16(ConfigurationManager.AppSettings["ServiceID"]); ; // //sync = wtf.getImportControl(serviceId); // serviceId = sync.MwEtlTimerId; // } // List<string> li = new List<string>(); // // // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, " > (NBI FileSearch) Start Directory scanning. for " + sync.ServiceName + "."); // // // //li.Add(ConfigurationManager.AppSettings["NewFilesDirectory"].ToString()); // C:\\ImportNIBData_xml // li.Add(sync.InputFileFolder); // if (li.Count == 0) // { // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, " > (NBI FileSearch) No Folder to process. for " + sync.ServiceName); // } // foreach (string path in li) // { // if (File.Exists(path)) // { // This path is a file // ProcessFile(path, sync); // } // else if (Directory.Exists(path)) // { // This path is a directory // ProcessDirectory(path, sync); // } // else // { // Invalid File or Directory exit // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, "(NBI FileSearch) <" + path + " > is not a valid file or directory."); // } // } // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, " > (FileSearch) " + sync.ServiceName + " Files read: " + FilesRead); // /// ******************************************************************************* // /// Back to Service SchedularCallback Function // /// When FileSearch is completed process flow return to Service1.SchedularCallback. // /// ------------------------------------------------------------------------------- //} // ************************************************************************ // Process all files in the directory passed in, recurse on any directories // that are found, and process the files they contain. // ------------------------------------------------------------------------ //public void ProcessDirectory(string targetDirectory, EtlTimer sync) /// NOT USED IN Version 3.0 //{ // /// // string[] fileEntries = Directory.GetFiles(targetDirectory); // foreach (string fileName in fileEntries) // { // ProcessFile(fileName, sync); // } // // Recurse into subdirectories of this directory. // string[] subdirectoryEntries = Directory.GetDirectories(targetDirectory); // foreach (string subdirectory in subdirectoryEntries) // ProcessDirectory(subdirectory, sync); //} /// ***************************************************************************************** /// Version 3.0 (Feb17-17) /// General files process - Only NIB XML valid Files are processed here: /// (1) - Select files to process depending on file extension and/or file name. /// (2) - Route process to the corresponding file types import process using delegates. /// (3) - Unrecognized file types and Service reading errors are detected here. /// (4) - Errors are logged in service log and reported through web services. /// ----------------------------------------------------------------------------------------- public void ProcessFile(string path, EtlTimer sync) { ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "2"; // NIB file type errMsg.FileName = Path.GetFileName(path); //fileName + extension; errMsg.Status = "Not Processed"; errMsg.NISOrderId = Path.GetFileNameWithoutExtension(path);; /// string extension = (Path.GetExtension(path)).ToString(); string fileName = Path.GetFileNameWithoutExtension(path); try { /// ********************************************************************************* /// Select files acceptable to be process, all other file types (extension) will not /// be processed (they stay in the newFiles folder) and an error message is generated /// to the WebServices. /// NIB (2) files process /// All NIB files have .xml and or sent extension. /// --------------------------------------------------------------------------------- string prefix = fileName; prefix = prefix .Replace("website-account-", "Acc").Replace("website-design-", "Dsn").Replace("website-order-", "Ord"); prefix = prefix.Substring(0, 3); /// /// Validate if this file was already processed May16-2017 /// int dupFile = wtf.getImportLog(serviceId, "NBI", fileName + extension); //if (((extension == ".xml") || (extension == ".sent")) && ((prefix == "Acc") || (prefix == "Dsn") || (prefix == "Ord"))) if (dupFile == 0 && (((extension == ".xml") || (extension == ".sent")) && ((prefix == "Acc") || (prefix == "Dsn") || (prefix == "Ord")))) { XmlDocument doc = new XmlDocument(); // Read / Load selected file content as xml doc.Load(path); /// Instanciate Xml methods delegate Del handler = null; // Declare a class instance xml: ImportProcedure_NBI.XmlFiles.ImportProcess xml = new ImportProcedure_NBI.XmlFiles.ImportProcess(); /// Declare an interface instance xmlFile: ImportProcedure_NBI.XmlFiles.IXmlFiles xmlfile = xml; // (ImportProcedure_NBI.XmlFiles.IXmlFiles)xml /// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /// Identify all xml files and route them to the corresponding import procedure /// Replace FileName with prefix's to simplify file type identification. /// ---------------------------------------------------------------------------- if (prefix == "Acc") { // NBI - Website-Accounts Files handler = xmlfile.ProcessWebsiteAccountFiles; } else if (prefix == "Dsn") { // NBI - Website-Designs Files handler = xmlfile.ProcessWebsiteDesignFiles; } else if (prefix == "Ord") { // NBI - Website-Order Files process handler = xmlfile.ProcessWebsiteOrderFiles; } /// =========== > bool ok = handler(doc, fileName, sync); // Process file and WebService icr.SaveProcessedFile(path, ok, sync, "NBI"); /// ===========> //ProcessXml(path, doc, fileName, handler, sync); /// < =========== } else { /// Unrecognized file type /// Initialize Error messages object basic information /// errMsg.Status = "Not Processed"; errMsg.NISOrderId = fileName; if (dupFile > 0) { errMsg.Message = "(NBI ProcessFile) File <" + fileName + extension + ">, duplicate file - already processed."; } else { errMsg.Message = "(NBI ProcessFile) File <" + fileName + extension + ">, unrecognized file type."; } wtf.writeSyncLog(1, Convert.ToInt16(ConfigurationManager.AppSettings["ServiceID"]), 1, sync.ServiceName, errMsg.Message); /// Duplicate file control May16-2017 /// if (dupFile == 0) { icr.SaveProcessedFile(path, false, sync, "STK"); } else { File.Delete(path); } /// < =========== } } catch (Exception fle) { int res = wtf.updImportControl(serviceId, 0); // set EtlTimer for this service to not Running (isRunning = false) errMsg.Message = "(NBI ProcessFile) Xml reading error - File in " + errMsg.FileName + ". " + fle; wtf.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, errMsg.Message); } }
DAL.SupportServices.SupportServices wsm = new DAL.SupportServices.SupportServices(); // Set WebService methods pointer // <summary> /// Process WE text files, built an object, generate a Json string and submit it to the /// webServices. /// If any processing errors are detected, the corresponding message is send to WebServices /// </summary> /// <param name="path">The complete path to the file in process</param> /// <param name="fileName">File name without the extension</param> /// <returns>Process result in a boolean var. if OK (true) else (false) </returns> public bool ProcessArrowFtpFiles(string path, string fileName, EtlTimer sync) { bool head = false; /// Header info detection flag bool newIsa = false; /// Detail info detection flag bool item1 = false; /// Items 1 / 2 sequence control // bool resp = false; /// Process final status return flag ServiceResponse resp = new ServiceResponse(); bool process = true; /// control that process was completed ok /// int itemsCounter = 0; /// Detail items counter int lineCounter = 0; /// Count the number of rows(records) in file /// string line; string[] separators = { "^" }; /// WEFiles weFiles = new WEFiles(); List <WEItems> items = new List <WEItems>(); //WriteErrorFile wef = new WriteErrorFile(); /// --------------------------------------------------------------------------- /// Read the file line by line. OADS_F00001 File type (Arrow FTP) /// --------------------------------------------------------------------------- System.IO.StreamReader file = new System.IO.StreamReader(path); try { while ((line = file.ReadLine()) != null) { line = line.Replace("~", ""); ///// Count lines in file lineCounter++; /// Split input record into string array elements string[] words = line.Split(separators, StringSplitOptions.None); /// ------------------------------------------------------------------- /// Start file Identifier processing (Only one per file) /// ------------------------------------------------------------------- if (words[0] == "ISA" && !newIsa) { if (words.Count() < 8) { throw new Exception("ISA record without complete info."); } newIsa = true; string isaDate = words[3]; string isaTime = words[4]; string isaLan = words[5]; string isaCurr = words[6]; string isaNumb = words[7]; string isaDatp = words[8]; } /// ------------------------------------------------------------------- /// Header entry processing /// ------------------------------------------------------------------- else if (words[0] == "HDR" && newIsa) { head = true; string hdrCust = words[2]; string hdrDat1 = words[3]; string hdrUsr1 = words[5]; string hdrUsr2 = words[6]; string hdrDate = words[8]; string hdrTime = words[9]; string hdrDat3 = words[18]; } /// ------------------------------------------------------------------- /// Address 1 entry processing /// ------------------------------------------------------------------- else if (words[0] == "N1" && head) { string n1Company = words[3]; string n1Address1 = words[4]; string n1Address2 = words[5]; string n1Contact = words[6]; string n1State = words[7]; string n1PostalCode = words[8]; string n1Country = words[9]; string n1Dat1 = words[10]; string n1Dat2 = words[11]; string n1Dat3 = words[20]; } /// ------------------------------------------------------------------- /// Address 2 entry processing /// ------------------------------------------------------------------- else if (words[0] == "N2" && head) { string n2Company = words[3]; string n2Address1 = words[4]; string n2Address2 = words[5]; string n2Contact = words[6]; string n2State = words[7]; string n2PostalCode = words[8]; string n2Country = words[9]; } /// ------------------------------------------------------------------- /// Item 1 entry processing /// ------------------------------------------------------------------- else if (words[0] == "IT1" && head) { string it1Sequence = words[1]; string it1Dat1 = words[2]; string it1Sku = words[5]; string it1Description = words[11]; string it1Dat2 = words[12]; string it1Dat3 = words[13]; string it1Date = words[14]; string it1Dat4 = words[15]; string it1Dat5 = words[16]; string it1Comments = words[19]; item1 = true; } /// ------------------------------------------------------------------- /// Item 2 entry processing /// ------------------------------------------------------------------- else if (words[0] == "IT2" && item1) { item1 = false; string it2Sequence = words[1]; string it2Dat1 = words[2]; string it2Dat2 = words[3]; string it2Dat3 = words[4]; } /// ------------------------------------------------------------------- /// GRM entry processing /// ------------------------------------------------------------------- else if (words[0] == "GRM" && head) { item1 = false; string grmSequence = words[1]; string grmClientId = words[2]; string grmDescription = words[3]; string grmColor = words[4]; string grmText = words[5]; string grmDat1 = words[6]; } /// ------------------------------------------------------------------- /// EOF entry processing /// ------------------------------------------------------------------- else if (words[0] == "EOF" && newIsa) { newIsa = false; } else { /// throw error - unrecognized data line (lineCounter) throw new Exception("Invalid data <" + words[0] + "> in row: " + lineCounter); } } } catch (Exception e) { /// error while reading the file process = false; resp.IsOk = false; ServiceResponse errMsg = new ServiceResponse(); errMsg.IsOk = false; errMsg.FileType = "x"; // Set Nis Type errMsg.FileName = fileName; errMsg.NISOrderId = "0"; errMsg.Status = "Not Processed"; errMsg.Message = e.Message; /// Send Message to WebService wsm.WriteErrorFile(errMsg, sync); } file.Close(); /// Only if process is completed ok and the number of detail records expected /// match the number of records read the object is serialized and send to the /// corresponding Web Service if (process) { if (items.Count() == itemsCounter) { weFiles.OrderDetail = items; resp.IsOk = true; } string json = Newtonsoft.Json.JsonConvert.SerializeObject(weFiles); /// ****************************************************************************** /// Call Web Service /// <param name="json2">Include Header serialized + items seialized info.</param> /// <param name="fname">File to process name </param> /// <param name="type">File Type, determine what service to use (url)</param> /// <returns>"rStatus" true if WebService was processed, else false</returns> /// Web service url is defined in the App.Config file /// ------------------------------------------------------------------------------ /// resp = wsm.ConsumeWebService(json, fileName, "ArrowFTP", sync); // <============== } return(resp.IsOk); }
/// ************************************************************************************** /// Version 2.0 /// Perform Directory File search process when task time is due /// Look for existing files in the new files folder /// Same method is used in the WindowsService version.... /// -------------------------------------------------------------------------------------- //public void FileSearch(object e, EtlTimer sync) //{ // if (serviceId == 0) // { // //serviceId = Convert.ToInt16(ConfigurationManager.AppSettings["ServiceID"]); ; // //sync = wtf.getImportControl(serviceId); // serviceId = sync.MwEtlTimerId; // } // List<string> li = new List<string>(); // // // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, " > (FileSearch) Start Directory scanning. for " + sync.ServiceName + "."); // // // //li.Add(ConfigurationManager.AppSettings["NewFilesDirectory"].ToString()); // C:\\AppData // li.Add(sync.InputFileFolder); // if (li.Count == 0) // { // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, " > (FileSearch) No Folder to process. for " + sync.ServiceName); // } // foreach (string path in li) // { // if (File.Exists(path)) // { // This path is a file // ProcessFile(path, sync); // } // else if (Directory.Exists(path)) // { // This path is a directory // ProcessDirectory(path, sync); // } // else // { // Invalid File or Directory exit // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, "(FileSearch) <" + path + " > is not a valid file or directory."); // } // } // wtf.writeSyncLog(1, serviceId, 1, sync.ServiceName, " > (FileSearch) " + sync.ServiceName + " Files read: " + FilesRead); // /// ******************************************************************************* // /// Back to Service SchedularCallback Function // /// When FileSearch is completed process flow return to Service1.SchedularCallback. // /// ------------------------------------------------------------------------------- //} // ************************************************************************ // Process all files in the directory passed in, recurse on any directories // that are found, and process the files they contain. // ------------------------------------------------------------------------ //public void ProcessDirectory(string targetDirectory, EtlTimer sync) //{ // /// // string[] fileEntries = Directory.GetFiles(targetDirectory); // foreach (string fileName in fileEntries) // { // ProcessFile(fileName, sync); // } // // Recurse into subdirectories of this directory. // string[] subdirectoryEntries = Directory.GetDirectories(targetDirectory); // foreach (string subdirectory in subdirectoryEntries) // ProcessDirectory(subdirectory, sync); //} /// ***************************************************************************************** /// General files process - Only NIS XML valid Files are processed here: /// (1) - Select files to process depending on file extension and/or file name. /// (2) - Route process to the corresponding file types import process using delegates. /// (3) - Unrecognized file types and Service reading errors are detected here. /// (4) - Errors are logged in service log and reported through web services. /// ----------------------------------------------------------------------------------------- public void ProcessFile(string path, EtlTimer sync) { string extension = (Path.GetExtension(path)).ToString(); string fileName = Path.GetFileNameWithoutExtension(path); /// Initialize Error messages object basic information ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; errMsg.FileName = fileName + extension; errMsg.NISOrderId = "0"; errMsg.Status = "Not Processed"; errMsg.Message = string.Empty; try { /// ********************************************************************************* /// Select files acceptable to be process, all other file types (extension) will not /// be processed (they stay in the newFiles folder) and an error message is generated /// to the WebServices. /// Only NIS (1) files are allowed in this directory. /// They have .xml and or sent extension. /// --------------------------------------------------------------------------------- string prefix = fileName; /// /// Validate if this file was already processed - May 16 - 2017 /// int serviceId = Convert.ToInt16(ConfigurationManager.AppSettings["ServiceID"]); int dupFile = wtf.getImportLog(serviceId, "NIS", fileName + extension); //if (((extension == ".xml") || (extension == ".sent") || (extension == ".Sent"))) // && (prefix != "Acc" && prefix != "Dsn" && prefix != "Ord")) if (dupFile == 0 && ((extension == ".xml") || (extension == ".sent"))) { XmlDocument doc = new XmlDocument(); // Read / Load selected file content as xml doc.Load(path); /// Instanciate Xml methods delegate Del handler = null; // Declare a class instance xml: ImportProcedure_NIS.XmlFiles.ImportProcess xml = new ImportProcedure_NIS.XmlFiles.ImportProcess(); /// Declare an interface instance xmlFile: ImportProcedure_NIS.XmlFiles.IXmlFiles xmlfile = (ImportProcedure_NIS.XmlFiles.IXmlFiles)xml; /// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ /// Identify NIS xml files and route them to the corresponding import procedure /// ---------------------------------------------------------------------------- // NIS Files process handler = xmlfile.ProcessNisFiles; /// =========== > ProcessXml(path, doc, fileName, handler, sync); /// < =========== } else { /// Unrecognized file type errMsg.NISOrderId = fileName; errMsg.Message = "(NIS ProcessFile) File <" + fileName + extension + ">, unrecognized file type."; wtf.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, errMsg.Message); /// Move file to problem directory //DAL.ImportControl.ImportControlRepository icr = new DAL.ImportControl.ImportControlRepository(); //icr.SaveProcessedFile(path, false, sync); /// Duplicate files contrl - May16-2017 if (dupFile == 0) { icr.SaveProcessedFile(path, false, sync, "NIS"); } else { File.Delete(path); // delete duplicate file May16-2017 } } } catch (Exception fle) { int res = wtf.updImportControl(sync.MwEtlTimerId, 0); // set EtlTimer for this service to not Running (isRunning = false) errMsg.Message = "(NIS ProcessFile) Xml reading error - File in " + errMsg.FileName + ". " + fle; wtf.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, errMsg.Message); } }
/// ******************************************************************************************* /// <summary> /// 09/22/2015 16:39 version /// Common Entry to Process all NIS Xml Files. /// (1) File send to the corresponding import procedure depending on the file type. /// (2) Finally process flow is transfer to final file processing stage. /// </summary> /// ------------------------------------------------------------------------------------------- private void ProcessXml(string path, XmlDocument doc, string tst, Del handler, EtlTimer sync) { bool ok = false; /// ---------------------------------------------------------------------------------------- /// Synchronous Process option /// ---------------------------------------------------------------------------------------- ok = handler(doc, tst, sync); // Process file and WebService /// ========== > icr.SaveProcessedFile(path, ok, sync, "NIS"); /// < ========== }
/// ------------------------------------------------------------------------------------ /// END OF Version 3.0 methods /// ************************************************************************************ /// ************************************************************************************ /// Version 3.1 methods start here, they replace the SyncControl Method /// All import services share the same input (Db Tables) access methods /// ------------------------------------------------------------------------------------ public void SyncControl_Disk(EtlTimer sync) { // wtf.writeSyncLog(1, sync.MwEtlTimerId, 1, sync.ServiceName, " > (TableSearch) Start Directory scanning. for " + sync.ServiceName + "."); // int testn = 0; int order = 1; string webOrder = ""; // if (syncRow.MwEtlTimerId == 17) { /// Search for unimported NIS order (one at the time) while (order > 0) // && testn < 5) { // Get first unimported order from orders table order = inr.getNisOrdersToImport(); if (order > 0) { // a row was found ProcessRow(order, sync); // testn++; } } } else if (syncRow.MwEtlTimerId == 1) { /// Get unimported Catalog web orders list (order Id.) /// Processs Convert Orders var List = idr.getDesignRequest_NotImportedList(); sync.OrderType = 0; // Set order type to convert foreach (var item in List) { // Get first unimported order from orders table ProcessRow(order, sync, item); testn++; } } else if (syncRow.MwEtlTimerId == 2) { /// Get unimported Catalog web orders list (order Id.) /// Processs Convert Orders var List = icr.getCatalogConvertOrder_NotImportedList(); sync.OrderType = 1; // Set order type to convert foreach (var item in List) { // Get first unimported order from orders table ProcessRow(order, sync, item); testn++; } // Process Web Orders sync.OrderType = 2; // Set order type to Web Orders List = icr.getCatalogOrder_NotImportedList(); foreach (var item in List) { // Get first unimported order from orders table ProcessRow(order, sync, item); testn++; } } else if (syncRow.MwEtlTimerId == 18) { List <NISLateOrders> orders = new List <NISLateOrders>(); orders = inr.getNisLateOrders(); int res = wtf.updImportControl(serviceId, 1); // set EtlTimer for this service to InUse /// Search for imported NIS order that are late orders (one at the time) foreach (var item in orders) { // Get first imported order from orders table LateOrdersProcedure_NIS.FileManagement LateOrdersRequest = new LateOrdersProcedure_NIS.FileManagement(); LateOrdersRequest.ProcessOrder(item, sync); testn++; } res = wtf.updImportControl(serviceId, 0); // set EtlTimer for this service to Inactive } }
/// ************************************************************************************************* /// <summary> /// Version 3.0 Feb20-17 /// Website-Account Xml File is mapped to Object, then passed to WebServices as a JSON string. /// </summary> /// <param name="doc">Imported file content read as an XmlDocument</param> /// <param name="fName">File name (excluding path section)</param> /// <returns>Process status true if procees was completed ok, else false</returns> /// ------------------------------------------------------------------------------------------------- bool IXmlFiles.ProcessStkOrderFiles(XmlDocument doc, string fName, EtlTimer syncRow) { //bool rStatus = false; ServiceResponse rStatus = new ServiceResponse(); StkOrder summary = new StkOrder(); StkHeader ord = new StkHeader(); /// --------------------------------------------------------------------- // Order section /// --------------------------------------------------------------------- ord.OrderType = "stickers"; XmlNode order = doc.DocumentElement.SelectSingleNode("/order"); ord.OrderId = dvs.AttributeValidation_String(order, "orderid", 15); ord.OrderNumber = dvs.AttributeValidation_String(order, "ordernum", 15); /// --------------------------------------------------------------------- // Account section /// --------------------------------------------------------------------- XmlNode account = doc.DocumentElement.SelectSingleNode("/order/account"); ord.AccountId = dvs.AttributeValidation_String(account, "accountid", 15); ord.AccountNum = dvs.AttributeValidation_String(account, "accountnum", 15); /// --------------------------------------------------------------------- // Locale Section /// --------------------------------------------------------------------- XmlNode locale = doc.DocumentElement.SelectSingleNode("/order/locale"); ord.Language = dvs.AttributeValidation_String(locale, "lang", 5); ord.SiteUsed = dvs.AttributeValidation_String(locale, "siteused", 10); ord.Currency = dvs.AttributeValidation_String(locale, "currency", 10); /// --------------------------------------------------------------------- // profile section /// --------------------------------------------------------------------- XmlNode profile = doc.DocumentElement.SelectSingleNode("/order/profile"); ord.VatNum = dvs.AttributeValidation_String(profile, "vatnum", 15); ord.Credit = dvs.AttributeValidation_String(profile, "credit", 20); /// --------------------------------------------------------------------- // Contact (Order) section /// --------------------------------------------------------------------- XmlNode contact = doc.DocumentElement.SelectSingleNode("/order/contact"); ord.Email = dvs.SingleNodeValidation_Text(contact, "email", 60); ord.Title = dvs.SingleNodeValidation_Text(contact, "title", 20); ord.Forename = dvs.SingleNodeValidation_Text(contact, "forename", 70); ord.Surname = dvs.SingleNodeValidation_Text(contact, "surname", 70); ord.CompanyName = dvs.SingleNodeValidation_Text(contact, "company", 300); ord.Industry = dvs.SingleNodeValidation_Text(contact, "industry", 200); ord.Source = dvs.SingleNodeValidation_Text(contact, "source", 50); ord.Telephone = dvs.SingleNodeValidation_Text(contact, "telephone", 30); /// --------------------------------------------------------------------- // Address Section - (Cardholder) /// --------------------------------------------------------------------- XmlNode cardHolder = doc.DocumentElement.SelectSingleNode("/order/address[@type='cardholder']"); // ------------------------------------------------------------------ ord.AddressCardHolderTown = dvs.SingleNodeValidation_Text(cardHolder, "town", 150); ord.AddressCardHolderCounty = dvs.SingleNodeValidation_Text(cardHolder, "county", 150); ord.AddressCardHolderPostCode = dvs.SingleNodeValidation_Text(cardHolder, "postcode", 30); ord.AddressCardHolderCountry = dvs.SingleNodeValidation_Text(cardHolder, "country", 200); /// Cardholder Line section within XmlNodeList xLt = doc.DocumentElement.SelectNodes("/order/address[@type='cardholder']/line"); foreach (XmlNode xn in xLt) { int index = dvs.AttributeValidation_Int(xn, "index"); switch (index) { case 1: ord.AddressCardHolderLine1 = xn.InnerText; // 300 if (ord.AddressCardHolderLine1.Length > 300) { string txt = ord.AddressCardHolderLine1.Substring(0, 300); ord.AddressCardHolderLine1 = txt; } break; case 2: ord.AddressCardHolderLine2 = xn.InnerText; // 300 if (ord.AddressCardHolderLine2.Length > 300) { string txt = ord.AddressCardHolderLine2.Substring(0, 300); ord.AddressCardHolderLine2 = txt; } break; default: break; } } /// ---------------------------------------------------------------------- // Address Section Process - (Delivery) // ---------------------------------------------------------------------- XmlNode delivery = doc.DocumentElement.SelectSingleNode("/order/address[@type='delivery']"); /// ------------------------------------------------------------------- //ord.AddressDeliveryCompany = SingleNodeValidation_Text(delivery, "company"); ord.AddressDeliveryTown = dvs.SingleNodeValidation_Text(delivery, "town", 150); ord.AddressDeliveryCounty = dvs.SingleNodeValidation_Text(delivery, "county", 150); ord.AddressDeliveryPostCode = dvs.SingleNodeValidation_Text(delivery, "postcode", 30); ord.AddressDeliveryCountry = dvs.SingleNodeValidation_Text(delivery, "country", 200); // Contact Section within Address section (Delivery type) XmlNode delContact = doc.DocumentElement.SelectSingleNode("/order/address[@type='delivery']/contact"); ord.AddressDeliveryForename = delContact.SelectSingleNode("forename").InnerXml; // Validate AddressDeliveryForename to max 70 if (ord.AddressDeliveryForename.Length > 70) { string fname = ord.AddressDeliveryForename.Substring(0, 70); ord.AddressDeliveryForename = fname; } ord.AddressDeliverySurname = delContact.SelectSingleNode("surname").InnerXml; // Validate AddressDeliverySurename to max 70 if (ord.AddressDeliverySurname.Length > 70) { string sname = ord.AddressDeliverySurname.Substring(0, 70); ord.AddressDeliverySurname = sname; } ord.AddressDeliveryTelephone = delContact.SelectSingleNode("telephone").InnerXml; // Validate telephone to max 30 if (ord.AddressDeliveryTelephone.Length > 30) { string phone = ord.AddressDeliveryTelephone.Substring(0, 30); ord.AddressDeliveryTelephone = phone; } // Line section within Address section (Delivery type) XmlNodeList xnLine = doc.DocumentElement.SelectNodes("/order/address[@type='delivery']/line"); foreach (XmlNode xi in xnLine) { int index = dvs.AttributeValidation_Int(xi, "index"); switch (index) { case 1: ord.AddressDeliveryLine1 = xi.InnerText; // 300 if (ord.AddressDeliveryLine1.Length > 300) { string txt = ord.AddressDeliveryLine1.Substring(0, 300); ord.AddressDeliveryLine1 = txt; } break; case 2: ord.AddressDeliveryLine2 = xi.InnerText; // 300 if (ord.AddressDeliveryLine2.Length > 300) { string txt = ord.AddressDeliveryLine2.Substring(0, 300); ord.AddressDeliveryLine2 = txt; } break; default: break; } } /// ---------------------------------------------------------------------- // Cart Section // ---------------------------------------------------------------------- XmlNode cart = doc.DocumentElement.SelectSingleNode("/order/cart"); ord.CartPrice = dvs.AttributeValidation_Dec(cart, "price"); /// ------------------------------------------------------------------ // Item Section - (n) Items Within Cart // ------------------------------------------------------------------ XmlNodeList item = doc.DocumentElement.SelectNodes("/order/cart/item"); /// Order items work area array List <StkOrderItem> nItems = new List <StkOrderItem>(); /// foreach (XmlNode itm in item) { StkOrderItem xItem = new StkOrderItem(); xItem.ItemProof = dvs.AttributeValidation_String(itm, "proof", 100); xItem.ItemSku = dvs.AttributeValidation_String(itm, "sku", 30); xItem.ItemWhiteBehind = dvs.AttributeValidation_String(itm, "whitebehind", 30); // for clear stickers, whether the vinyl is pre-printed with a white underlay xItem.ItemVsize = dvs.AttributeValidation_Dec(itm, "vsize"); // vertical size in mm xItem.ItemStyleNum = dvs.AttributeValidation_String(itm, "stylenum", 30); xItem.ItemSimilar = dvs.AttributeValidation_String(itm, "similar", 30); // xItem.ItemShape = dvs.AttributeValidation_String(itm, "shape", 30); // the specified shape xItem.ItemReversePrint = dvs.AttributeValidation_String(itm, "reverseprint", 30); // for window stickers, whether the print is on the inside or outside of the sticker xItem.ItemQuantity = dvs.AttributeValidation_Int(itm, "quantity"); // xItem.ItemPrintedWhite = dvs.AttributeValidation_String(itm, "printedwhite", 30); // for window stickers, whether the vinyl has a printed white background xItem.ItemPpu = dvs.AttributeValidation_String(itm, "ppu", 20); xItem.ItemNumHoles = dvs.AttributeValidation_Int(itm, "numholes"); // number of holes inside a custom-specified shape xItem.ItemMaterialOption = dvs.AttributeValidation_String(itm, "materialoption", 30); // not sure (unused J&A internal field?) xItem.ItemMaterial = dvs.AttributeValidation_String(itm, "material", 30); // vinyl or paper, depending on range xItem.ItemLines = dvs.AttributeValidation_Int(itm, "lines"); // xItem.ItemId = dvs.AttributeValidation_Int(itm, "itemid"); xItem.ItemIdentical = dvs.AttributeValidation_String(itm, "identical", 30); xItem.ItemHsize = dvs.AttributeValidation_Dec(itm, "hsize"); // horizontal size in mm xItem.ItemDesignId = dvs.AttributeValidation_String(itm, "designid", 30); xItem.ItemCornerRad = dvs.AttributeValidation_String(itm, "cornerrad", 30); // corner radius in mm xItem.ItemColour = dvs.AttributeValidation_String(itm, "colour", 30); xItem.ItemCode = dvs.AttributeValidation_String(itm, "code", 10); xItem.ItemSheets = dvs.AttributeValidation_Int(itm, "sheets"); // Added on Jun 26 xItem.ItemsPerSheet = dvs.AttributeValidation_Int(itm, "persheet"); // Added on Jun 29 /// -------------------------------------------------------------- // Names Section - (n) names within Item // -------------------------------------------------------------- XmlNodeList name = doc.DocumentElement.SelectNodes("/order/cart/item/name"); //List<ItemNames> lNames = new List<ItemNames>(); //foreach (XmlNode nme in name) //{ // /// ---------------------------------------------------------- // // Line Section - (Maximun 7 lines) within name // /// ---------------------------------------------------------- // //XmlNodeList line = doc.DocumentElement.SelectNodes("/order/cart/item/name/line"); // ItemNames wrkName = new ItemNames(); // foreach (XmlNode xn in nme) // { // int index = AttributeValidation_Int(xn, "index"); // switch (index) // { // case 1: // wrkName.ItemName1 = FirstChildValidation_Inner(xn); // break; // case 2: // wrkName.ItemName2 = FirstChildValidation_Inner(xn); // break; // case 3: // wrkName.ItemName3 = FirstChildValidation_Inner(xn); // break; // case 4: // wrkName.ItemName4 = FirstChildValidation_Inner(xn); // break; // case 5: // wrkName.ItemName5 = FirstChildValidation_Inner(xn); // break; // case 6: // wrkName.ItemName6 = FirstChildValidation_Inner(xn); // break; // case 7: // wrkName.ItemName7 = FirstChildValidation_Inner(xn); // break; // default: // break; // } // } // /// Add max. lines (index texts) by name to Names List // lNames.Add(wrkName); //} ///// Save Names List in Item row //xItem.names = lNames; /// Add Item row to Items List nItems.Add(xItem); } /// ---------------------------------------------------------------------- /// Discount Section /// ---------------------------------------------------------------------- XmlNode discount = doc.DocumentElement.SelectSingleNode("/order/discount"); ord.DiscountType = dvs.AttributeValidation_String(discount, "type", 20); ord.DiscountCode = dvs.AttributeValidation_String(discount, "code", 20); ord.DiscountTotal = dvs.AttributeValidation_Dec(discount, "total"); ord.DiscountValue = dvs.AttributeValidation_Dec(discount, "value"); /// ---------------------------------------------------------------------- // Delivery section // ---------------------------------------------------------------------- XmlNode xDelivery = doc.DocumentElement.SelectSingleNode("/order/delivery"); ord.DeliveryTotal = dvs.AttributeValidation_Dec(xDelivery, "total"); ord.DeliveryType = dvs.AttributeValidation_String(xDelivery, "type", 10); ord.DeliveryTerritory = dvs.AttributeValidation_String(xDelivery, "territory", 5); ord.DeliveryId = dvs.AttributeValidation_Int(xDelivery, "deliveryid"); ord.DeliveryEta = dvs.AttributeValidation_Date(xDelivery, "etd"); ord.DeliveryEtd = dvs.AttributeValidation_Date(xDelivery, "eta"); /// ---------------------------------------------------------------------- // Vat Section // ---------------------------------------------------------------------- XmlNode vat = doc.DocumentElement.SelectSingleNode("/order/vat"); ord.VatTotal = dvs.AttributeValidation_Dec(vat, "total"); ord.VatNumber = dvs.AttributeValidation_Int(vat, "number"); ord.VatCountyCode = dvs.AttributeValidation_String(vat, "countycode", 5); ord.VatDistrictRate = dvs.AttributeValidation_Dec(vat, "districtrate"); ord.VatCityRate = dvs.AttributeValidation_Dec(vat, "cityrate"); ord.VatCountyRate = dvs.AttributeValidation_Dec(vat, "countyrate"); ord.VatStateRate = dvs.AttributeValidation_Dec(vat, "staterate"); ord.VatState = dvs.AttributeValidation_String(vat, "state", 2); ord.VatCounty = dvs.AttributeValidation_String(vat, "county", 150); ord.VatCity = dvs.AttributeValidation_String(vat, "city", 150); ord.VatStaticRate = dvs.AttributeValidation_Dec(vat, "staticrate"); ord.VatLiveRate = dvs.AttributeValidation_Dec(vat, "liverate"); ord.VatRate = dvs.AttributeValidation_Dec(vat, "rate"); /// ---------------------------------------------------------------------- // Options Section // ---------------------------------------------------------------------- XmlNode options = doc.DocumentElement.SelectSingleNode("/order/options"); ord.OptionsBlindPacking = dvs.AttributeValidation_String(options, "blindpacking", 15); ord.OptionsCustRef = dvs.AttributeValidation_String(options, "custref", 50); /// ---------------------------------------------------------------------- // Payment Section // ---------------------------------------------------------------------- XmlNode payment = doc.DocumentElement.SelectSingleNode("/order/payment"); ord.PaymentUsing = dvs.AttributeValidation_String(payment, "using", 50); // net Section XmlNode net = doc.DocumentElement.SelectSingleNode("/order/payment/net"); ord.PaymentCurrency = dvs.AttributeValidation_String(net, "currency", 5); string amt = dvs.FirstChildValidation_Inner(net); ord.PaymentAmount = Decimal.Parse(amt); // gross Section XmlNode gross = doc.DocumentElement.SelectSingleNode("/order/payment/gross"); ord.GrossCurrency = gross.Attributes["currency"].Value; string grossAmt = dvs.FirstChildValidation_Inner(gross); ord.GrossAmount = Decimal.Parse(grossAmt); /// ---------------------------------------------------------------------- /// Serialize object (WebOrder) to Json string /// Save Items List in Order Items List (include items / names within / name lines within) summary.stkOrderSummary = ord; summary.stkOrderItems = nItems; // ord.Filename = fName + ".xml"; string test = Newtonsoft.Json.JsonConvert.SerializeObject(summary); // =========== > //DAL.SupportServices.SupportServices wsm = new DAL.SupportServices.SupportServices(); /// ****************************************************************************** /// Call Web Service - "WebOrder" /// <param name="json2">Include Header serialized + items seialized info.</param> /// <param name="fname">File to process name </param> /// <param name="type">File Type, determine what service to use (url)</param> /// <returns>"rStatus" true if WebService was processed, else false</returns> /// Web service url is defined in the App.Config file /// ------------------------------------------------------------------------------ rStatus = wsm.ConsumeWebService(test, fName, syncRow.WebServiceOrders, syncRow); // < =========== return(rStatus.IsOk); }
/// ************************************************************************************************* /// <summary> /// 09/22/2015 16:39 version /// Website-Design Xml File is mapped to Object, then passed to WebServices as a JSON string. /// </summary> /// <param name="doc">Imported file content read as an XmlDocument</param> /// <param name="fName">File name (excluding path section)</param> /// <returns>Process status true if procees was completed ok, else false</returns> /// ------------------------------------------------------------------------------------------------- bool IXmlFiles.ProcessWebsiteDesignFiles(XmlDocument doc, string fName, EtlTimer syncRow) { //WebServiceManager wsm = new WebServiceManager(); DAL.SupportServices.SupportServices wsm = new DAL.SupportServices.SupportServices(); WebDesign des = new WebDesign(); ServiceResponse rStatus = new ServiceResponse(); /// ---------------------------------------------------------------------- // Design section /// ---------------------------------------------------------------------- des.OrderType = "nbi"; XmlNode design = doc.DocumentElement.SelectSingleNode("/design"); des.StyleNum = dat.AttributeValidation_String(design, "stylenum", 0); des.DesignID = dat.AttributeValidation_String(design, "designid", 0); des.TimeStamp = dat.AttributeValidation_Date(design, "timestamp"); /// ---------------------------------------------------------------------- // Specs Section /// ---------------------------------------------------------------------- XmlNode specs = doc.DocumentElement.SelectSingleNode("/design/specs"); des.Proof = dat.AttributeValidation_String(specs, "proof", 0); des.lines = dat.AttributeValidation_String(specs, "lines", 0); des.Fitting = dat.AttributeValidation_String(specs, "fitting", 0); des.Bar = dat.AttributeValidation_String(specs, "bar", 0); des.Vinyl = dat.AttributeValidation_String(specs, "vinyl", 0); des.Code = dat.AttributeValidation_String(specs, "code", 0); /// ---------------------------------------------------------------------- // Background Section /// ---------------------------------------------------------------------- XmlNode background = doc.DocumentElement.SelectSingleNode("/design/background"); des.Src = dat.AttributeValidation_String(background, "src", 0); /// ------dat.---------------------------------------------------------------- // Contacdat.t (account) section process /// ---------------------------------------------------------------------- XmlNodeList frag = doc.DocumentElement.SelectNodes("/design/fragments/logo"); WebDesignFragments fragments = new WebDesignFragments(); foreach (XmlNode logo in frag) { fragments.Src = dat.AttributeValidation_String(logo, "src", 0); fragments.Top = dat.AttributeValidation_String(logo, "top", 0); fragments.Left = dat.AttributeValidation_String(logo, "left", 0); fragments.Height = dat.AttributeValidation_String(logo, "height", 0); fragments.Width = dat.AttributeValidation_String(logo, "width", 0); fragments.Index = dat.AttributeValidation_Int(logo, "index"); } des.logo = fragments; /// ---------------------------------------------------------------------- // Address Section Process - (Delivery) /// ---------------------------------------------------------------------- XmlNodeList Text = doc.DocumentElement.SelectNodes("/design/fragments"); List <WebDesignText> texts = new List <WebDesignText>(); foreach (XmlNode txt in Text) { XmlNodeList tNodes = doc.SelectNodes("/design/fragments/text"); foreach (XmlNode tNode in tNodes) { WebDesignText cnt1 = new WebDesignText(); // cnt1.Index = dat.AttributeValidation_Int(tNode, "index"); cnt1.Color = dat.AttributeValidation_String(tNode, "color", 0); cnt1.Size = dat.AttributeValidation_String(tNode, "size", 0); cnt1.Style = dat.AttributeValidation_String(tNode, "style", 0); cnt1.Font = dat.AttributeValidation_String(tNode, "font", 0); cnt1.Y = dat.AttributeValidation_String(tNode, "y", 0); cnt1.X = dat.AttributeValidation_String(tNode, "x", 0); cnt1.Content = dat.AttributeValidation_String(tNode, "content", 0); // texts.Add(cnt1); } } des.texts = texts; des.Filename = fName + ".xml"; string test = Newtonsoft.Json.JsonConvert.SerializeObject(des); /// ****************************************************************************** /// Call Web Service - "WebDesign" /// <param name="json2">Include Header serialized + items seialized info.</param> /// <param name="fname">File to process name </param> /// <param name="type">File Type, determine what service to use (url)</param> /// <returns>"rStatus" true if WebService was processed, else false</returns> /// Web service url is defined in the App.Config file /// ------------------------------------------------------------------------------ rStatus = wsm.ConsumeWebService(test, fName, syncRow.WebServiceDesigns, syncRow); // <============== return(rStatus.IsOk); }
/// ************************************************************************************************* /// <summary> /// 10/29/2015 08:59 version /// Website-Account Xml File is mapped to Object, then passed to WebServices as a JSON string. /// </summary> /// <param name="doc">Imported file content read as an XmlDocument</param> /// <param name="fName">File name (excluding path section)</param> /// <returns>Process status true if procees was completed ok, else false</returns> /// ------------------------------------------------------------------------------------------------- bool IXmlFiles.ProcessWebsiteOrderFiles(XmlDocument doc, string fName, EtlTimer syncRow) { ServiceResponse rStatus = new ServiceResponse(); WebOrder summary = new WebOrder(); NBIHeader ord = new NBIHeader(); /// --------------------------------------------------------------------- // Order section /// --------------------------------------------------------------------- ord.OrderType = "nbi"; XmlNode order = doc.DocumentElement.SelectSingleNode("/order"); ord.OrderId = dat.AttributeValidation_String(order, "orderid", 15); // int 15 ord.OrderNumber = dat.AttributeValidation_String(order, "ordernum", 15); // int 15 /// --------------------------------------------------------------------- // Account section /// --------------------------------------------------------------------- XmlNode account = doc.DocumentElement.SelectSingleNode("/order/account"); ord.AccountId = dat.AttributeValidation_String(account, "accountid", 15); // int ord.AccountNum = dat.AttributeValidation_String(account, "accountnum", 15); // int /// --------------------------------------------------------------------- // Locale Section /// --------------------------------------------------------------------- XmlNode locale = doc.DocumentElement.SelectSingleNode("/order/locale"); ord.Language = dat.AttributeValidation_String(locale, "lang", 5); // 5 ord.SiteUsed = dat.AttributeValidation_String(locale, "siteused", 10); // 10 ord.Currency = dat.AttributeValidation_String(locale, "currency", 10); // 10 /// --------------------------------------------------------------------- // profile section /// --------------------------------------------------------------------- XmlNode profile = doc.DocumentElement.SelectSingleNode("/order/profile"); ord.VatNum = dat.AttributeValidation_String(profile, "vatnum", 15); // int ord.Credit = dat.AttributeValidation_String(profile, "credit", 20); // dec /// --------------------------------------------------------------------- // Contact (Order) section /// --------------------------------------------------------------------- XmlNode contact = doc.DocumentElement.SelectSingleNode("/order/contact"); ord.Email = dat.SingleNodeValidation_Text(contact, "email", 60); // 60 ord.Title = dat.SingleNodeValidation_Text(contact, "title", 20); // 20 ord.Forename = dat.SingleNodeValidation_Text(contact, "forename", 70); // 70 ord.Surname = dat.SingleNodeValidation_Text(contact, "surname", 70); // 70 ord.CompanyName = dat.SingleNodeValidation_Text(contact, "company", 300); // 300 ord.Industry = dat.SingleNodeValidation_Text(contact, "industry", 200); // 200 ord.Source = dat.SingleNodeValidation_Text(contact, "source", 50); // 50 ord.Telephone = dat.SingleNodeValidation_Text(contact, "telephone", 30); // 30 /// --------------------------------------------------------------------- // Address Section - (Cardholder) /// --------------------------------------------------------------------- XmlNode cardHolder = doc.DocumentElement.SelectSingleNode("/order/address[@type='cardholder']"); // ------------------------------------------------------------------ ord.AddressCardHolderTown = dat.SingleNodeValidation_Text(cardHolder, "town", 150); // 150 ord.AddressCardHolderCounty = dat.SingleNodeValidation_Text(cardHolder, "county", 150); // 150 ord.AddressCardHolderPostCode = dat.SingleNodeValidation_Text(cardHolder, "postcode", 30); // 30 ord.AddressCardHolderCountry = dat.SingleNodeValidation_Text(cardHolder, "country", 200); // 200 /// Cardholder Line section within XmlNodeList xLt = doc.DocumentElement.SelectNodes("/order/address[@type='cardholder']/line"); foreach (XmlNode xn in xLt) { int index = dat.AttributeValidation_Int(xn, "index"); switch (index) { case 1: ord.AddressCardHolderLine1 = xn.InnerText; // 300 if (ord.AddressCardHolderLine1.Length > 300) { string txt = ord.AddressCardHolderLine1.Substring(0, 300); ord.AddressCardHolderLine1 = txt; } break; case 2: ord.AddressCardHolderLine2 = xn.InnerText; // 300 if (ord.AddressCardHolderLine2.Length > 300) { string txt = ord.AddressCardHolderLine2.Substring(0, 300); ord.AddressCardHolderLine2 = txt; } break; default: break; } } /// ---------------------------------------------------------------------- // Address Section Process - (Delivery) // ---------------------------------------------------------------------- XmlNode delivery = doc.DocumentElement.SelectSingleNode("/order/address[@type='delivery']"); /// ------------------------------------------------------------------- ord.AddressDeliveryCompany = dat.SingleNodeValidation_Text(delivery, "company", 300); // 300 ord.AddressDeliveryTown = dat.SingleNodeValidation_Text(delivery, "town", 150); // 150 ord.AddressDeliveryCounty = dat.SingleNodeValidation_Text(delivery, "county", 150); // 150 ord.AddressDeliveryPostCode = dat.SingleNodeValidation_Text(delivery, "postcode", 30); // 30 ord.AddressDeliveryCountry = dat.SingleNodeValidation_Text(delivery, "country", 200); // 200 // Contact Section within Address section (Delivery type) XmlNode delContact = doc.DocumentElement.SelectSingleNode("/order/address[@type='delivery']/contact"); ord.AddressDeliveryForename = delContact.SelectSingleNode("forename").InnerXml; // 70 // Validate AddressDeliveryForename to max 70 if (ord.AddressDeliveryForename.Length > 70) { string fname = ord.AddressDeliveryForename.Substring(0, 70); ord.AddressDeliveryForename = fname; } ord.AddressDeliverySurname = delContact.SelectSingleNode("surname").InnerXml; // 70 // Validate AddressDeliverySurename to max 70 if (ord.AddressDeliverySurname.Length > 70) { string sname = ord.AddressDeliverySurname.Substring(0, 70); ord.AddressDeliverySurname = sname; } ord.AddressDeliveryTelephone = delContact.SelectSingleNode("telephone").InnerXml; // 30 // Validate Phone number max length is 30 if (ord.AddressDeliveryTelephone.Length > 30) { string phone = ord.AddressDeliveryTelephone.Substring(0, 30); ord.AddressDeliveryTelephone = phone; } // Line section within Address section (Delivery type) XmlNodeList xnLine = doc.DocumentElement.SelectNodes("/order/address[@type='delivery']/line"); foreach (XmlNode xi in xnLine) { int index = dat.AttributeValidation_Int(xi, "index"); switch (index) { case 1: ord.AddressDeliveryLine1 = xi.InnerText; // 300 if (ord.AddressDeliveryLine1.Length > 300) { string txt = ord.AddressDeliveryLine1.Substring(0, 300); ord.AddressDeliveryLine1 = txt; } break; case 2: ord.AddressDeliveryLine2 = xi.InnerText; // 300 if (ord.AddressDeliveryLine2.Length > 300) { string txt = ord.AddressDeliveryLine2.Substring(0, 300); ord.AddressDeliveryLine2 = txt; } break; default: break; } } /// ---------------------------------------------------------------------- // Cart Section // ---------------------------------------------------------------------- XmlNode cart = doc.DocumentElement.SelectSingleNode("/order/cart"); ord.CartPrice = dat.AttributeValidation_Dec(cart, "price"); /// ------------------------------------------------------------------ // Item Section - (n) Items Within Cart // ------------------------------------------------------------------ XmlNodeList item = doc.DocumentElement.SelectNodes("/order/cart/item"); /// Order items work area array List <WebOrderItem> nItems = new List <WebOrderItem>(); /// foreach (XmlNode itm in item) { WebOrderItem xItem = new WebOrderItem(); xItem.ItemProof = dat.AttributeValidation_String(itm, "proof", 100); // 100 xItem.ItemSku = dat.AttributeValidation_String(itm, "sku", 30); // 30 xItem.ItemIdentical = dat.AttributeValidation_String(itm, "identical", 30); // 30 xItem.ItemSimilar = dat.AttributeValidation_String(itm, "similar", 30); // 30 xItem.ItemStyleNum = dat.AttributeValidation_String(itm, "stylenum", 30); // 30 xItem.ItemId = dat.AttributeValidation_Int(itm, "itemid"); xItem.ItemDesignId = dat.AttributeValidation_String(itm, "designid", 30); // 30 xItem.ItemPpu = dat.AttributeValidation_String(itm, "ppu", 20); // 20 xItem.ItemQuantity = dat.AttributeValidation_Int(itm, "quantity"); xItem.ItemLines = dat.AttributeValidation_Int(itm, "lines"); xItem.ItemFitting = dat.AttributeValidation_String(itm, "fitting", 50); // 50 xItem.ItemBar = dat.AttributeValidation_String(itm, "bar", 50); // 50 xItem.ItemVinyl = dat.AttributeValidation_String(itm, "vinyl", 50); // 50 xItem.ItemCode = dat.AttributeValidation_String(itm, "code", 10); // 10 /// -------------------------------------------------------------- // Names Section - (n) names within Item // -------------------------------------------------------------- List <ItemNames> lNames = new List <ItemNames>(); int qty = xItem.ItemQuantity; // Set the names search limit foreach (XmlNode nme in itm) { /// ---------------------------------------------------------- // Line Section - (Maximun 7 lines) within name /// ---------------------------------------------------------- //XmlNodeList line = doc.DocumentElement.SelectNodes("/order/cart/item/name/line"); ItemNames wrkName = new ItemNames(); foreach (XmlNode xn in nme) { int index = dat.AttributeValidation_Int(xn, "index"); switch (index) { case 1: wrkName.ItemName1 = dat.FirstChildValidation_TextValue(xn); if (wrkName.ItemName1.Length > 100) { string txt = wrkName.ItemName1.Substring(0, 300); wrkName.ItemName1 = txt; } break; case 2: wrkName.ItemName2 = dat.FirstChildValidation_TextValue(xn); if (wrkName.ItemName2.Length > 100) { string txt = wrkName.ItemName2.Substring(0, 300); wrkName.ItemName2 = txt; } break; case 3: wrkName.ItemName3 = dat.FirstChildValidation_TextValue(xn); if (wrkName.ItemName3.Length > 100) { string txt = wrkName.ItemName3.Substring(0, 300); wrkName.ItemName3 = txt; } break; case 4: wrkName.ItemName4 = dat.FirstChildValidation_TextValue(xn); if (wrkName.ItemName4.Length > 100) { string txt = wrkName.ItemName4.Substring(0, 300); wrkName.ItemName4 = txt; } break; case 5: wrkName.ItemName5 = dat.FirstChildValidation_TextValue(xn); if (wrkName.ItemName5.Length > 100) { string txt = wrkName.ItemName5.Substring(0, 300); wrkName.ItemName5 = txt; } break; case 6: wrkName.ItemName6 = dat.FirstChildValidation_TextValue(xn); if (wrkName.ItemName6.Length > 100) { string txt = wrkName.ItemName6.Substring(0, 300); wrkName.ItemName6 = txt; } break; case 7: wrkName.ItemName7 = dat.FirstChildValidation_TextValue(xn); if (wrkName.ItemName7.Length > 100) { string txt = wrkName.ItemName7.Substring(0, 300); wrkName.ItemName7 = txt; } break; default: break; } } /// Add max. lines (index texts) by name to Names List lNames.Add(wrkName); qty = qty - 1; if (qty == 0) { break; } } /// Save Names List in Item row xItem.names = lNames; /// Add Item row to Items List nItems.Add(xItem); } /// ---------------------------------------------------------------------- /// Discount Section /// ---------------------------------------------------------------------- XmlNode discount = doc.DocumentElement.SelectSingleNode("/order/discount"); ord.DiscountType = dat.AttributeValidation_String(discount, "type", 20); // 20 ord.DiscountCode = dat.AttributeValidation_String(discount, "code", 20); // 20 ord.DiscountTotal = dat.AttributeValidation_Dec(discount, "total"); ord.DiscountValue = dat.AttributeValidation_Dec(discount, "value"); /// ---------------------------------------------------------------------- // Delivery section // ---------------------------------------------------------------------- XmlNode xDelivery = doc.DocumentElement.SelectSingleNode("/order/delivery"); ord.DeliveryTotal = dat.AttributeValidation_Dec(xDelivery, "total"); ord.DeliveryType = dat.AttributeValidation_String(xDelivery, "type", 10); // 10 ord.DeliveryTerritory = dat.AttributeValidation_String(xDelivery, "territory", 5); // 5 ord.DeliveryId = dat.AttributeValidation_Int(xDelivery, "deliveryid"); // int ord.DeliveryEta = dat.AttributeValidation_Date(xDelivery, "etd"); ord.DeliveryEtd = dat.AttributeValidation_Date(xDelivery, "eta"); /// ---------------------------------------------------------------------- // Vat Section // ---------------------------------------------------------------------- XmlNode vat = doc.DocumentElement.SelectSingleNode("/order/vat"); ord.VatTotal = dat.AttributeValidation_Dec(vat, "total"); // dec ord.VatNumber = dat.AttributeValidation_Int(vat, "number"); // int ord.VatCountyCode = dat.AttributeValidation_String(vat, "countycode", 5); // 5 ord.VatDistrictRate = dat.AttributeValidation_String(vat, "districtrate", 20); // 20 ord.VatCityRate = dat.AttributeValidation_String(vat, "cityrate", 20); // 20 ord.VatCountyRate = dat.AttributeValidation_String(vat, "countyrate", 20); // 20 ord.VatStateRate = dat.AttributeValidation_String(vat, "staterate", 20); // 20 ord.VatState = dat.AttributeValidation_String(vat, "state", 2); // 2 ord.VatCounty = dat.AttributeValidation_String(vat, "county", 150); // 150 ord.VatCity = dat.AttributeValidation_String(vat, "city", 150); // 150 ord.VatStaticRate = dat.AttributeValidation_String(vat, "staticrate", 20); // 20 ord.VatLiveRate = dat.AttributeValidation_String(vat, "liverate", 20); // 20 ord.VatRate = dat.AttributeValidation_String(vat, "rate", 20); // 20 /// ---------------------------------------------------------------------- // Options Section // ---------------------------------------------------------------------- XmlNode options = doc.DocumentElement.SelectSingleNode("/order/options"); ord.OptionsBlindPacking = dat.AttributeValidation_String(options, "blindpacking", 15); // int ord.OptionsCustRef = dat.AttributeValidation_String(options, "custref", 50); // 50 /// ---------------------------------------------------------------------- // Payment Section // ---------------------------------------------------------------------- XmlNode payment = doc.DocumentElement.SelectSingleNode("/order/payment"); ord.PaymentUsing = dat.AttributeValidation_String(payment, "using", 50); // 50 ord.PaymentCardType = dat.SingleNodeValidation_Text(payment, "cardtype", 20); // Apr13-17 20 ord.PaymentLastFour = dat.SingleNodeValidation_Text(payment, "lastfour", 4); // Apr13-17 4 // net Section XmlNode net = doc.DocumentElement.SelectSingleNode("/order/payment/net"); ord.PaymentCurrency = dat.AttributeValidation_String(net, "currency", 5); // 5 string amt = dat.FirstChildValidation_Inner(net); ord.PaymentAmount = Decimal.Parse(amt); // gross Section XmlNode gross = doc.DocumentElement.SelectSingleNode("/order/payment/gross"); ord.GrossCurrency = gross.Attributes["currency"].Value; // 5 string grossAmt = dat.FirstChildValidation_Inner(gross); ord.GrossAmount = Decimal.Parse(grossAmt); /// ---------------------------------------------------------------------- /// Serialize object (WebOrder) to Json string /// Save Items List in Order Items List (include items / names within / name lines within) summary.nbiOrderSummary = ord; summary.nbiOrderItems = nItems; // ord.Filename = fName + ".xml"; // string test = Newtonsoft.Json.JsonConvert.SerializeObject(summary); // =========== > DAL.SupportServices.SupportServices wsm = new DAL.SupportServices.SupportServices(); /// ****************************************************************************** /// Call Web Service - "WebOrder" /// <param name="json2">Include Header serialized + items seialized info.</param> /// <param name="fname">File to process name </param> /// <param name="type">File Type, determine what service to use (url)</param> /// <returns>"rStatus" true if WebService was processed, else false</returns> /// Web service url is defined in the App.Config file /// ------------------------------------------------------------------------------ rStatus = wsm.ConsumeWebService(test, fName, syncRow.WebServiceOrders, syncRow); //rStatus = true; // use only for testing purposes // < =========== return(rStatus.IsOk); }
/// ************************************************************************************************* /// <summary> /// 09/22/2015 16:39 version /// Website-Account Xml document is mapped to Object, then passed to WebServices as a JSON string. /// </summary> /// <param name="doc">Imported file content read as an XmlDocument</param> /// <param name="fName">File name (excluding path section)</param> /// <returns>Process status true if procees was completed ok, else false</returns> /// ------------------------------------------------------------------------------------------------- bool IXmlFiles.ProcessWebsiteAccountFiles(XmlDocument doc, string fName, EtlTimer syncRow) { ServiceResponse rStatus = new ServiceResponse(); //WebServiceManager wsm = new WebServiceManager(); /// ---------------------------------------------------------------------- // Account section /// ---------------------------------------------------------------------- /// XmlNode account = doc.DocumentElement.SelectSingleNode("/account"); WebAccount ord = new WebAccount(); ord.OrderType = "nbi"; ord.AccountId = dat.AttributeValidation_String(account, "accountid", 20); // 20 /// ---------------------------------------------------------------------- // Locale Section /// ---------------------------------------------------------------------- XmlNode locale = doc.DocumentElement.SelectSingleNode("/account/locale"); ord.Language = dat.AttributeValidation_String(locale, "lang", 5); // 5 ord.SiteUsed = dat.AttributeValidation_String(locale, "siteused", 10); // 10 ord.Currency = dat.AttributeValidation_String(locale, "currency", 10); // 10 /// ---------------------------------------------------------------------- // Contact (account) section /// ---------------------------------------------------------------------- XmlNode contact = doc.DocumentElement.SelectSingleNode("/account/contact"); ord.Email = dat.SingleNodeValidation_Text(contact, "email", 60); // 60 ord.Title = dat.SingleNodeValidation_Text(contact, "title", 20); // 20 ord.Forename = dat.SingleNodeValidation_Text(contact, "forename", 70); // 70 ord.Surname = dat.SingleNodeValidation_Text(contact, "surname", 70); // 70 ord.CompanyName = dat.SingleNodeValidation_Text(contact, "company", 300); // 300 ord.Industry = dat.SingleNodeValidation_Text(contact, "industry", 200); // 200 ord.Telephone = dat.SingleNodeValidation_Text(contact, "telephone", 30); // 30 /// ---------------------------------------------------------------------- // Address Section Process - (Cardholder) /// ---------------------------------------------------------------------- XmlNode cardHolder = doc.DocumentElement.SelectSingleNode("/account/address[@type='cardholder']"); ord.AddressCardHolderTown = dat.SingleNodeValidation_Text(cardHolder, "town", 150); // 150 ord.AddressCardHolderCounty = dat.SingleNodeValidation_Text(cardHolder, "county", 150); // 150 ord.AddressCardHolderPostCode = dat.SingleNodeValidation_Text(cardHolder, "postcode", 30); // 30 ord.AddressCardHolderCountry = dat.SingleNodeValidation_Text(cardHolder, "country", 200); // 200 // Line section within Cardholder address section XmlNodeList xLt = cardHolder.SelectNodes("/account/address[@type='cardholder']/line"); foreach (XmlNode xc in xLt) { int index = dat.AttributeValidation_Int(xc, "index"); switch (index) { case 1: ord.AddressCardHolderLine1 = xc.InnerText; // 300 if (ord.AddressCardHolderLine1.Length > 300) { string txt = ord.AddressCardHolderLine1.Substring(0, 300); ord.AddressCardHolderLine1 = txt; } break; case 2: ord.AddressCardHolderLine2 = xc.InnerText; // 300 if (ord.AddressCardHolderLine2.Length > 300) { string txt = ord.AddressCardHolderLine2.Substring(0, 300); ord.AddressCardHolderLine2 = txt; } break; default: break; } } /// ---------------------------------------------------------------------- // Address Section - (Delivery) /// ---------------------------------------------------------------------- XmlNodeList delivery = doc.DocumentElement.SelectNodes("/account/address[@type='delivery']"); foreach (XmlNode del in delivery) { /// Contact information within delivery address XmlNode delLine = del.SelectSingleNode("/account/address[@type='delivery']/contact"); ord.AddressDeliveryForename = dat.SingleNodeValidation_Text(delLine, "forename", 70); // 70 ord.AddressDeliverySurname = dat.SingleNodeValidation_Text(delLine, "surname", 70); // 70 ord.AddressDeliveryTelephone = dat.SingleNodeValidation_Text(delLine, "telephone", 30); // 70 /// ord.AddressDeliveryCompany = dat.SingleNodeValidation_Text(del, "company", 300); // 300 /// Line section within Delivery address section XmlNodeList xnLine = del.SelectNodes("/account/address[@type='delivery']/line"); foreach (XmlNode xd in xnLine) { int index = dat.AttributeValidation_Int(xd, "index"); switch (index) { case 1: ord.AddressDeliveryLine1 = xd.InnerText; // 300 if (ord.AddressDeliveryLine1.Length > 300) { string txt = ord.AddressDeliveryLine1.Substring(0, 300); ord.AddressDeliveryLine1 = txt; } break; case 2: ord.AddressDeliveryLine2 = xd.InnerText; // 300 if (ord.AddressDeliveryLine2.Length > 300) { string txt = ord.AddressDeliveryLine2.Substring(0, 300); ord.AddressDeliveryLine2 = txt; } break; default: break; } } ord.AddressDeliveryTown = dat.SingleNodeValidation_Text(del, "town", 150); // 150 ord.AddressDeliveryCounty = dat.SingleNodeValidation_Text(del, "county", 150); // 150 ord.AddressDeliveryPostCode = dat.SingleNodeValidation_Text(del, "postcode", 30); // 30 ord.AddressDeliveryCountry = dat.SingleNodeValidation_Text(del, "country", 200); // 200 } ord.FileName = fName + ".xml"; string json2 = Newtonsoft.Json.JsonConvert.SerializeObject(ord); /// ****************************************************************************** /// Call Web Service - "WebAccount" /// <param name="json2">Object serialized Json string.</param> /// <param name="fname">Xml file name </param> /// <param name="type">File Type (WebAccounts) </param> /// <returns>"rStatus" true if WebService was processed, else false</returns> /// Web service url is defined in the App.Config file /// ------------------------------------------------------------------------------ rStatus = wsm.ConsumeWebService(json2, fName, syncRow.WebServiceAccounts, syncRow); // <============== return(rStatus.IsOk); }
/// <summary> /// G&K Text files provide orders header and items information, each data line distribution [ PO_GK00.....txt ] /// (data type and positioning) will depend in the type of record which is identified by tags /// in the first position of each readed line. /// Data is separated with , * or "," characters. /// This process split data line into an string array and use the elements within the array /// to retreive the corresponding fields. (they will depend in the line type in process) /// </summary> /// Old system ==> subImportTXTFile / subImportGKOrders public bool ProcessGKFiles(string path, string fileName, EtlTimer sync) { DAL.SupportServices.SupportServices wef = new DAL.SupportServices.SupportServices(); // bool resp = false; ServiceResponse resp = new ServiceResponse(); string[] separators = { " , ", "*", "", "" }; /// string line; bool newFile = false; //bool newLine = true; GKHeader order = new GKHeader(); List <OrderItems> list = new List <OrderItems>(); /// ------------------------------------------------------------------------------ /// Read the file and display it line by line. /// ------------------------------------------------------------------------------ try { System.IO.StreamReader file = new System.IO.StreamReader(path); while ((line = file.ReadLine()) != null) { line = line.Replace('"', ' ').Replace('-', ' '); /// string[] words = line.Split(separators, StringSplitOptions.None); if (words[0] == "BG") { newFile = true; } string tag = words[0].TrimStart(); /// ------------------------------------------------------------------------------- /// Process header information /// ------------------------------------------------------------------------------- if ((tag == "AAA0") || (tag == "POH0") || (tag == "POH1") && (newFile)) { switch (tag) { case "AAA0": string date = words[2].Substring(0, 4) + "-" + words[2].Substring(4, 2) + "-" + words[2].Substring(6, 2) + " " + words[3].Substring(0, 2) + ":" + words[3].Substring(2, 2) + ":" + words[3].Substring(4, 2); // ok order.OrderDate = DateTime.ParseExact(date, "yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture); break; case "POH0": order.PO = words[1]; // ok order.UserID = words[2]; // ok order.DateReq = words[3].Substring(0, 4) + "-" + words[3].Substring(4, 2) + "-" + words[3].Substring(6, 2); // ok break; case "POH1": order.ID = order.PO; // ok order.ShippingToID = ""; order.Description = words[1]; // ok order.UserEmail = words[2]; // ok order.UserID = ""; if (order.UserID == "0096") { order.UserID = "0596"; } if ((order.UserID == "000000302871") || (order.UserID == "000000302863") || (order.UserID == "000000306101") || (order.UserID == "000000316854") || (order.UserID == "000000316891")) { order.ShippingViaID = "PL"; } else { order.ShippingViaID = "10"; } // break; default: break; } } /// ------------------------------------------------------------------------------- /// Process order items tags /// ------------------------------------------------------------------------------- else if ((tag == "POD0") && (newFile)) { //newLine = true; /// LineNo = Int32.Parse(words[1]); SeqNo = words[3]; Qty = Int32.Parse(words[6]); EmblemPrice = Int32.Parse(words[7]); } else if ((tag == "POD1") && (newFile)) { //complete = true; //newLine = true; OrderItems ordItms = BuildPod0(words, order.UserID); list.Add(ordItms); } /// If this is not a valid file - terminate the process if (!newFile) { throw new Exception(); } } order.items = list; string json = Newtonsoft.Json.JsonConvert.SerializeObject(order); //Console.WriteLine("Text process ok"); //Console.ReadLine(); file.Close(); /// ****************************************************************************** /// Call Web Service /// <param name="json2">Include Header serialized + items seialized info.</param> /// <param name="fname">File to process name </param> /// <param name="type">File Type, determine what service to use (url)</param> /// <param name="pStatus">Data status</param> Ignore /// <returns>"rStatus" true if WebService was processed, else false</returns> /// Web service url is defined in the App.Config file /// ------------------------------------------------------------------------------ /// resp = wsm.ConsumeWebService(json, fileName, "GKOrders", sync); // <============== } catch (Exception e) { /// Process errors //Console.WriteLine("Text process error"); //Console.ReadLine(); /// error while reading the file //process = false; resp.IsOk = false; ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; // Set Nis Type errMsg.FileName = fileName + ".txt"; errMsg.NISOrderId = "0"; errMsg.Status = "Not Processed"; errMsg.Message = e.Message + " in line "; // +lineCounter; /// Send Message to WebService wef.WriteErrorFile(errMsg, sync); } return(resp.IsOk); }
DAL.SupportServices.SupportServices wsm = new DAL.SupportServices.SupportServices(); // Set WebService methods pointer /// <summary> /// Process WE text files, built an object, generate a Json string and submit it to the /// webServices. [ WE XML Order.txt ] /// If any processing errors are detected, the corresponding message is send to WebServices /// </summary> /// <param name="path">The complete path to the file in process</param> /// <param name="fileName">File name without the extension</param> /// <returns>Process result in a boolean var. if OK (true) else (false) </returns> public bool ProcessWEFiles(string path, string fileName, EtlTimer sync) { bool head = false; /// Header info detection flag bool det = false; /// Detail info detection flag //bool resp = false; /// Process final status return flag ServiceResponse resp = new ServiceResponse(); bool process = true; /// control that process was completed ok /// int itemsCounter = 0; /// Detail items counter int lineCounter = 0; /// Count the number of rows(records) in file /// string line; string[] separators = { "=", "_" }; /// WEFiles weFiles = new WEFiles(); List <WEItems> items = new List <WEItems>(); //WriteErrorFile wef = new WriteErrorFile(); DAL.SupportServices.SupportServices wef = new DAL.SupportServices.SupportServices(); /// --------------------------------------------------------------------------- /// Read the file line by line. /// --------------------------------------------------------------------------- System.IO.StreamReader file = new System.IO.StreamReader(path); try { while ((line = file.ReadLine()) != null) { /// Count lines in file lineCounter++; /// Split input record into string array elements string[] words = line.Split(separators, StringSplitOptions.None); /// ------------------------------------------------------------------- /// Only one element found in record <element 0> /// Identify is Header or detail tags come after this element /// ------------------------------------------------------------------- if (words.Count() == 1) { if (words[0] == "[Order Header]") { head = true; /// Set header section detected flag on continue; } else if (words[0] == "[Order Detail]") { det = true; /// set Deatil section detected flag on head = false; /// Header detected off continue; } else if (words[0] == "") { continue; /// Ignore blank records } throw new Exception("Unrecognized content"); } /// ------------------------------------------------------------------- /// Two elements found in record <tag name> = <tag value> /// Header flag on. validate against Header tags /// Is not a detail record /// ------------------------------------------------------------------- if (head && !det && words.Count() == 2) { /// Build Header object from data file switch (words[0]) { case "MacolaUserID": weFiles.MacolaUserID = words[1]; break; case "UserEmail": weFiles.UserEmail = words[1].TrimStart(); break; case "OrderDate": weFiles.OrderDate = words[1].TrimStart(); break; case "PO": weFiles.PO = words[1].TrimStart(); break; case "ImportType": weFiles.ImportType = words[1].TrimStart(); break; case "TotalItemsNo": if (!string.IsNullOrEmpty(words[1])) { weFiles.TotalItemsNo = Int32.Parse(words[1]); } break; default: // throw error throw new Exception("Unrecognized header tag name"); } } /// ------------------------------------------------------------------- /// Three elements found in record: /// <tag name> = <detail record count> = <tag value> /// Detail flag on. validate against detail tags /// ------------------------------------------------------------------- else if (det && words.Count() == 3) { int itm = Int32.Parse(words[1]); if (itm > itemsCounter) { /// Add new empty() line object into Items list /// All new data entry values will be stored in the empty line. /// ============= > items.Add(AddWEItemToList()); /// < ============= /// Count items in List itemsCounter++; } switch (words[0]) { case "Qty": items[itemsCounter - 1].Qty = words[2]; break; case "Line1": items[itemsCounter - 1].Line1 = words[2]; break; case "Line2": items[itemsCounter - 1].Line2 = words[2]; break; case "Line3": items[itemsCounter - 1].Line3 = words[2]; break; case "ItemClientCode": items[itemsCounter - 1].ItemClientCode = words[2]; break; case "ItemClientCodeDescription": items[itemsCounter - 1].ItemClientCodeDescription = words[2]; break; case "ItemWECode": items[itemsCounter - 1].ItemWECode = words[2]; break; case "PriorityID": items[itemsCounter - 1].PriorityID = words[2]; break; case "Type": items[itemsCounter - 1].Type = words[2]; break; case "Instructions1": items[itemsCounter - 1].Instructions1 = words[2]; break; case "Instructions2": items[itemsCounter - 1].Instructions2 = words[2]; break; case "Instructions3": items[itemsCounter - 1].Instructions3 = words[2]; break; case "Instructions4": items[itemsCounter - 1].Instructions4 = words[2]; break; default: // throw error throw new Exception("Unrecognized detail tag name"); } } else { /// throw error - unrecognized data line (lineCounter) throw new Exception("Invalid data format"); } } } catch (Exception e) { /// error while reading the file process = false; resp.IsOk = false; ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; // Set Nis Type errMsg.FileName = fileName + ".txt"; errMsg.NISOrderId = "0"; errMsg.Status = "Not Processed"; errMsg.Message = e.Message + " in line " + lineCounter; /// Send Message to WebService wef.WriteErrorFile(errMsg, sync); } file.Close(); /// Only if process is completed ok and the number of detail records expected /// match the number of records read the object is serialized and send to the /// corresponding Web Service if (process) { if (items.Count() == itemsCounter) { weFiles.OrderDetail = items; resp.IsOk = true; } string json = Newtonsoft.Json.JsonConvert.SerializeObject(weFiles); /// ****************************************************************************** /// Call Web Service /// <param name="json2">Include Header serialized + items seialized info.</param> /// <param name="fname">File to process name </param> /// <param name="type">File Type, determine what service to use (url)</param> /// <returns>"rStatus" true if WebService was processed, else false</returns> /// Web service url is defined in the App.Config file /// ------------------------------------------------------------------------------ /// resp = wsm.ConsumeWebService(json, fileName, "WEOrders", sync); // <============== } return(resp.IsOk); }
/// ************************************************************************************************* /// <summary> /// 07/27/2017 11:27 version /// NIS Orders process, Order data come as an object splited into order header/detail sections. /// Each section is send to WebServices as a JSON string if header/detail information is complete, /// when detail info. /// All errors are send to a Webservice (Error) and included in the Service log. /// </summary> /// <param name="doc">Imported order content as a NisTables class</param> /// <param name="oNumber">Order number</param> /// <param name="fName">EtlTimer sync control data)</param> /// <returns>Process status true if procees was completed ok, else false</returns> /// ------------------------------------------------------------------------------------------------- bool INISTables.ProcessNisOrder(NisTables doc, int oNumber, EtlTimer syncRow) { /// Response from MW api ServiceResponse rStatus = new ServiceResponse(); DAL.SupportServices.SupportServices wsm = new DAL.SupportServices.SupportServices(); // Set WebService methods pointer DAL.ImportControl.ImportControlRepository icr = new DAL.ImportControl.ImportControlRepository(); /// Create error message object and initialice it ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; // Set Nis Type errMsg.FileName = "NIS Table"; errMsg.NISOrderId = oNumber.ToString(); errMsg.Status = "Not Processed"; errMsg.Message = "No items found for this order header"; /// ********************************************************************************************* // Order header section /// --------------------------------------------------------------------------------------------- string jsonHead = "{ \"nisOrderSummary\":" + Newtonsoft.Json.JsonConvert.SerializeObject(doc.header); /// ********************************************************************************************* /// Order Detail Section /// -------------------------------------------------------------------------------------------- /// =============================================================================== /// Send Imported files data content to webServices - information must be complete /// Order Header + all related Order Items. /// ------------------------------------------------------------------------------- if (doc.items.Count > 0) { /// Serialize Items list and complete json string for Header and Items string json2 = jsonHead + ", \"nisOrderItems\" : " + Newtonsoft.Json.JsonConvert.SerializeObject(doc.items) + "}"; /// ****************************************************************************** /// Call Web Service /// <param name="json2"> Header/detail object Json serialized string.</param> /// <param name="fname"> Xml file name </param> /// <param name="syncRow.WebServiceOrders">File Type, route to web service(url)</param> /// <param name="syncRow"> EtlTimer control data. /// <returns>"rStatus" true if WebService was processed, else false</returns> /// *** Web service url is defined in the App.Config file key 'NisOrder'. /// ------------------------------------------------------------------------------ /// ==============> save order data through the defined web service rStatus = wsm.ConsumeWebService(json2, oNumber.ToString(), syncRow.WebServiceOrders, syncRow); //"OrderData", syncRow); //// TEMPORARY UNCOMMENT TO SEND JSON INFO /// //rStatus.IsOk = true; /// set order process to ok TEMPORARY, UNCOMMENT IF WEB SERVICE IS USED TO SEND JSON INFO /// string apiMsg = ""; int resp = 0; /// Order update response int uOption = 0; int impProb = 0; int navOrder = 0; DAL.ImportControl.ImportControlRepository ikr = new DAL.ImportControl.ImportControlRepository(); DAL.ImportControl.ImportNISRepository inr = new DAL.ImportControl.ImportNISRepository(); // if (rStatus.Status == "OK") { // set order condition to imported apiMsg = " Imported"; uOption = 1; rStatus.IsOk = true; navOrder = Convert.ToInt32(rStatus.NISOrderId); /// /// Save processed files log - May16-2017 /// int res = ikr.writeImportLog(syncRow.MwEtlTimerId, "NIS", doc.header.HeaderId.ToString()); } else { // Set order contion to imported with errors. impProb = 1; apiMsg = " Not Imported - API errors"; rStatus.IsOk = false; } resp = inr.updNisOrder(oNumber, uOption, impProb, navOrder); // ************ MUST UPDATE NIS ORDER ******************* // string ret = ikr.writeSyncLog(1, syncRow.MwEtlTimerId, 1, syncRow.ServiceName, "> " + syncRow.Description + " NIS Order: <" + doc.header.HeaderId + "> " + apiMsg + "."); // <============== // <============== } else { /// Incomplete order (No order items included and no xls file Name reported in orderHeader) jsonHead = jsonHead + " }"; /// Send Message to WebService wsm.WriteErrorFile(errMsg, syncRow); //// TEMPORARY UNCOMMENT TO SEND JSON INFO } return(rStatus.IsOk); }
/// ************************************************************************************************* /// <summary> /// 07/06/2017 10:23 version /// Catalog Web Orders process, un-imported web orders are retreived and mapped to an object (header/detail /// sections). /// Each section is send to WebServices as a JSON string if header/detail information is complete, /// when detail info. /// All errors are send to a Webservice (Error) and included in the Service log. /// </summary> /// <param name="doc">Imported Web orders</param> /// <param name="oNumber">Web Order number</param> /// <param name="syncRow">EtlTimer sync control data)</param> /// <returns>Process status true if procees was completed ok, else false</returns> /// ------------------------------------------------------------------------------------------------- bool IDesignRequestTables.ProcessDesignRequestOrder(DesignRequest doc, string oNumber, EtlTimer syncRow) { //bool rStatus = false; // WebService return status (default=false) ServiceResponse rStatus = new ServiceResponse(); Dictionary <string, string> configValues = new Dictionary <string, string>(); FTPServerIP = ConfigurationManager.AppSettings["FTPServerIP"]; // configValues[ConfigurationValues.FTP_SERVER_IP]; FTPUserID = ConfigurationManager.AppSettings["FTPUserID"]; // configValues[ConfigurationValues.FTP_USER_ID]; FTPPassword = ConfigurationManager.AppSettings["FTPPassword"]; // configValues[ConfigurationValues.FTP_PASSWORD]; // ClientArtImagesFolderSource = syncRow.ExcelFileFolder; ClientArtImagesFolderDestination = syncRow.ProcessedFileFolder; /// Create error message object and initialice it ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; // Set Nis Type errMsg.FileName = "Catalog Design Request Table"; errMsg.NISOrderId = oNumber.ToString(); errMsg.Status = "Not Processed"; errMsg.Message = "Design request not found"; /// ********************************************************************************************* // Design request order /// --------------------------------------------------------------------------------------------- /// =============================================================================== /// Send Imported files data content to webServices - information must be complete /// Order Header + all related Order Items. /// ------------------------------------------------------------------------------- if (doc != null) { /// ****************************************************************************** /// Call Web Service /// <param name="json2"> Header/detail object Json serialized string.</param> /// <param name="fname"> Xml file name </param> /// <param name="syncRow.WebServiceOrders">File Type, route to web service(url)</param> /// <param name="syncRow"> EtlTimer control data. /// <returns>"rStatus.IsOk" true if WebService was processed, else false</returns> /// *** Web service url is defined in the App.Config file key 'NisOrder'. /// ------------------------------------------------------------------------------ /// /// Process design Request image /// string errorMessage = " "; rStatus.IsOk = ProcessDesignRequestImage(doc, out errorMessage); // , errorMessage); /// string apiMsg = ""; int resp = 0; // Order update response // string json2 = "{ \"WebOrderSummary\":" + Newtonsoft.Json.JsonConvert.SerializeObject(doc) + "}"; if (rStatus.IsOk) { /// ==============> save order data through the defined web service /// rStatus = wsm.ConsumeWebService(json2, oNumber, syncRow.WebServiceOrders, syncRow); //"OrderData", syncRow); //// TEMPORARY UNCOMMENT TO SEND JSON INFO /// ------------------------------------------------------------------------------ /// UNCOMMENT IF WEB SERVICE IS USED TO SEND JSON INFO //rStatus.IsOk = true; /// set order process to ok TEMPORARY, rStatus.NISOrderId = "Nav1234567"; /// ------------------------------------------------------------------------------ if (rStatus.IsOk) { // set order condition to imported apiMsg = " Imported"; // resp = idr.updDesignRequest(oNumber, "Imported", 1); if (resp < 1) { apiMsg += " but Design Request status not updated due to DB access errors."; } } else { // Set order contion to imported with errors. apiMsg = " Not Imported - API errors" + " Image errors: " + errorMessage; } } string ret = ikr.writeSyncLog(1, syncRow.MwEtlTimerId, 1, syncRow.ServiceName, "> " + syncRow.Description + " Catalog Web Order: <" + doc.DesignId + "> " + apiMsg + "."); // <============== } else { /// Incomplete order (No order items included and no xls file Name reported in orderHeader) //json2 = json2 + " }"; /// Send Message to WebService wsm.WriteErrorFile(errMsg, syncRow); //// TEMPORARY UNCOMMENT TO SEND JSON INFO } return(rStatus.IsOk); }
/// ************************************************************************************************* /// <summary> /// 11/03/2015 10:23 version /// NIS Files process, Xml document mapped to an object and splited into order header/detail /// sections. /// Each section is send to WebServices as a JSON string if header/detail information is complete, /// when detail info. is not included in the xml document, it must have an excel file associated /// with the detail information (Header filename field). /// All errors are send to a Webservice (Error) and included in the Service log. /// </summary> /// <param name="doc">Imported file content read as an XmlDocument</param> /// <param name="fName">File name (excluding path section)</param> /// <param name="fName">EtlTimer sync control data)</param> /// <returns>Process status true if procees was completed ok, else false</returns> /// ------------------------------------------------------------------------------------------------- bool IXmlFiles.ProcessNisFiles(XmlDocument doc, string fName, EtlTimer syncRow) { //bool rStatus = false; // WebService return status (default=false) ServiceResponse rStatus = new ServiceResponse(); DAL.SupportServices.SupportServices wsm = new DAL.SupportServices.SupportServices(); // Set WebService methods pointer DAL.DataValidationServices.DataValidation dvs = new DAL.DataValidationServices.DataValidation(); /// Create error message object and initialice it ServiceResponse errMsg = new ServiceResponse(); errMsg.FileType = "1"; // Set Nis Type errMsg.FileName = fName + ".xml"; errMsg.NISOrderId = "0"; errMsg.Status = "Not Processed"; errMsg.Message = "No items found for this order header"; /// ********************************************************************************************* // Order header section /// --------------------------------------------------------------------------------------------- XmlNode header = doc.DocumentElement.SelectSingleNode("/Order/OrderHeader"); Header head = new Header(); /// head.HeaderId = dvs.SingleNodeValidation_Text(header, "ID", 6); head.HeaderUserId = dvs.SingleNodeValidation_Text(header, "userID", 6); head.HeaderUserEmail = dvs.SingleNodeValidation_Text(header, "UserEmail", 60); head.HeaderOrderDate = dvs.SingleNodeValidation_Text(header, "orderDate", 30); head.HeaderPO = dvs.SingleNodeValidation_Text(header, "PO", 25); head.HeaderDateRequested = dvs.SingleNodeValidation_Text(header, "dateReq", 30); head.HeaderDescription = dvs.SingleNodeValidation_Text(header, "description", 0); head.HeaderShipVia1 = dvs.SingleNodeValidation_Text(header, "shippingViaID", 2); head.HeaderShipVia2 = dvs.SingleNodeValidation_Text(header, "shippingViaID2", 2); head.HeaderShipToId1 = dvs.SingleNodeValidation_Text(header, "shippingToID", 0); head.HeaderShipToId2 = dvs.SingleNodeValidation_Text(header, "shippingToID2", 0); head.HeaderComments = dvs.SingleNodeValidation_Text(header, "comments", 0); head.FileName = dvs.SingleNodeValidation_Text(header, "ItemsFileName", 0); head.HeaderSentDate = dvs.SingleNodeValidation_Text(header, "sentDate", 30); /// string jsonHead = "{ \"nisOrderSummary\":" + Newtonsoft.Json.JsonConvert.SerializeObject(head); /// ********************************************************************************************* /// Order Detail Section /// -------------------------------------------------------------------------------------------- XmlNodeList orders = doc.DocumentElement.SelectNodes("/Order/OrderItems"); /// List <Order> ordList = new List <Order>(); int itm = 1; foreach (XmlNode order in orders) { Order ord = new Order(); ord.NisOrderId = itm.ToString(); ord.Itemid = dvs.SingleNodeValidation_Text(order, "ID", 6);; ord.OrderId = dvs.SingleNodeValidation_Text(order, "orderID", 6); ord.SkuId = dvs.SingleNodeValidation_Text(order, "SKU_ID", 3); ord.LineId = dvs.SingleNodeValidation_Int(order, "lineID"); ord.Quantity1 = dvs.SingleNodeValidation_Int(order, "qty1"); ord.Quantity2 = dvs.SingleNodeValidation_Int(order, "qty2"); ord.Line1 = dvs.SingleNodeValidation_Text(order, "line1", 40); ord.Line2 = dvs.SingleNodeValidation_Text(order, "line2", 40); ord.Line3 = dvs.SingleNodeValidation_Text(order, "line3", 40); ord.Comment = dvs.SingleNodeValidation_Text(order, "comment", 100); ord.Description = dvs.SingleNodeValidation_Text(order, "description", 0); ord.SkuClient = dvs.SingleNodeValidation_Text(order, "SKU_client", 0); ord.SkuWe = dvs.SingleNodeValidation_Text(order, "SKU_WE", 30); ord.AccountCode = dvs.SingleNodeValidation_Text(order, "AccountCode", 0); /// itm++; ordList.Add(ord); } /// =========================================================================================== /// When an Order don't include items, order items must be provided through an xls / xlsx file /// indicated in the Header "FileName" field. /// If fileName is not indicated/provided, the corresponding order must remain pending in the /// problem directory until it can be processed, an entry in the ServiceLog must be generated /// to report this situation and a WebService error message is send. /// Old system ==> subImportXLSFile /// ------------------------------------------------------------------------------------------- if (ordList.Count == 0) { if (String.IsNullOrEmpty(head.FileName)) { /// Incomplete order (No order items included and no xls file Name reported in orderHeader) errMsg.Message = "No items in xml file and no xls file reported in Header (fileName)"; } else { /// =================================================================================================== /// read xls file using Header FileName, build order items List and add it to header section. /// ---------------------------------------------------------------------------------------------------- // string path = ConfigurationManager.AppSettings["ExcelFilesDirectory"].ToString() + @"\" + head.FileName; string path = syncRow.ExcelFileFolder + @"\" + head.FileName; DataTable dt = ImportProcedure_NIS.ExcelFiles.ImportProcess.ReadExcelFile(path, "Items", "*", head.FileName, false); /// if ((dt == null) || (dt.Rows.Count == 0)) { /// Incomplete order (associated xls file name was not found) errMsg.Message = "Associated xls/xlsx file <" + head.FileName + "> not found"; /// ------------------------------------------------------------------------- } else { /// Built items list from xls/xlsx file content for (int i = 0; i < dt.Rows.Count; i++) { string it = Convert.ToString(dt.Rows[i].ItemArray[5]); if (!String.IsNullOrEmpty(it)) { /// All empty rows Qty(G) are ignored, when current row is empty the process /// continue. Associated file may have additional filled rows that must be /// included. Order ord = new Order(); /// process all existing items ord.NisOrderId = head.HeaderId; // Header file name ord.Itemid = string.Empty; ord.OrderId = head.HeaderId; ord.SkuId = (i + 1).ToString(); /// Quantity Qty1/Qty2 nodes int q1; bool n = Int32.TryParse(dt.Rows[i].ItemArray[5].ToString(), out q1); ord.Quantity1 = q1; // ok ord.Quantity2 = 0; // ok /// Line Line1-line3 nodes ord.Line1 = dt.Rows[i].ItemArray[2].ToString(); // ok ord.Line2 = dt.Rows[i].ItemArray[3].ToString(); // ok ord.Line3 = dt.Rows[i].ItemArray[4].ToString(); // ok /// This counter must be after storing Line1 .. Line3 /// Conts the number of lines included in this row. ord.LineId = 0; if (!string.IsNullOrEmpty(ord.Line1)) { ord.LineId++; } if (!string.IsNullOrEmpty(ord.Line2)) { ord.LineId++; } if (!string.IsNullOrEmpty(ord.Line3)) { ord.LineId++; } /// ord.Comment = dt.Rows[i].ItemArray[7].ToString(); // ok ord.Description = ""; ord.SkuClient = dt.Rows[i].ItemArray[1].ToString(); ord.SkuWe = dt.Rows[i].ItemArray[0].ToString(); /// Add row in detail list ordList.Add(ord); } } } } } /// =============================================================================== /// Send Imported files data content to webServices - information must be complete /// Order Header + all related Order Items. /// ------------------------------------------------------------------------------- if (ordList.Count > 0) { /// Serialize Items list and complete json string for Header and Items string json2 = jsonHead + ", \"nisOrderItems\" : " + Newtonsoft.Json.JsonConvert.SerializeObject(ordList) + "}"; /// ****************************************************************************** /// Call Web Service /// <param name="json2"> Header/detail object Json serialized string.</param> /// <param name="fname"> Xml file name </param> /// <param name="syncRow.WebServiceOrders">File Type, route to web service(url)</param> /// <param name="syncRow"> EtlTimer control data. /// <returns>"rStatus" true if WebService was processed, else false</returns> /// *** Web service url is defined in the App.Config file key 'NisOrder'. /// ------------------------------------------------------------------------------ /// ==============> save order data through the defined web service rStatus = wsm.ConsumeWebService(json2, fName, syncRow.WebServiceOrders, syncRow); //"OrderData", syncRow); // <============== } else { /// Incomplete order (No order items included and no xls file Name reported in orderHeader) jsonHead = jsonHead + " }"; /// Send Message to WebService rStatus.IsOk = false; wsm.WriteErrorFile(errMsg, syncRow); } return(rStatus.IsOk); }