public string ProcessBatch(string message)
        {
            var exportString = message.Split(':');
            var batchList    = exportString[0];

            sessionId = exportString[1];
            var exportUserId = exportString[2];

            batches = batchList.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

            try
            {
                var finCoCode        = exportString[3];
                var settingFinCoCode = SettingsModelList.GetFinCoCode();
                if (settingFinCoCode != finCoCode)
                {
                    Helpers.LogAppError($"Invalid FinCoCode settings:{settingFinCoCode}, singalR: {finCoCode}");
                    batchList = "0";
                    return("Invalid FinCo");
                }

                foreach (var batch in batches)
                {
                    var batchNo = Convert.ToInt32(batch);
                    type = exportAPInvoices.GetBatchType(batchNo);
                    var result = "";

                    if (type == "ApInvoice" || type == "ApCredit" || type == "SubClaim")
                    {
                        result = exportAPInvoices.Export(batchNo, sessionId);
                    }

                    if (type == "ArInvoice" || type == "ArCredit")
                    {
                        result = exportARInvoices.Export(batchNo, sessionId);
                    }

                    if (type == "Adjustment" || type == "WipAccrual" || type == "CccAccrual" || type == "PoAccrual")
                    {
                        result = exportGLJournals.Export(batchNo, sessionId);
                    }

                    if (type == "Disbursement" || type == "PlantIssue" || type == "Docket" || type == "Timesheet")
                    {
                        result = exportGLJournals.Export(batchNo, sessionId);
                    }

                    if (type == "StockReturn" || type == "StockIssue" || type == "StockTrf" || type == "StockAdjust")
                    {
                        result = exportGLJournals.Export(batchNo, sessionId);
                    }

                    if (result == "")
                    {
                        Helpers.LogAppError($"Batch type \"{type}\" is not supported yet");
                        var wbTrfClient = new WorkbenchTrfClient(new HttpClient());
                        _ = wbTrfClient.LogTrfApi_Post2Async(batchNo, exportId: null, exportTable: null, Type2.Error, $"Batch type \"{type}\" is not supported yet").Result;
                        _ = wbTrfClient.LogTrfApi_PostAsync(sessionId, "Export log marked as error", batchNo, Type.Error).Result;
                    }

                    Helpers.LogInfo($"type: {type}, result: {result}");
                }
                return("success");
            }
            catch (Exception ex)
            {
                foreach (var batch in batches)
                {
                    var wbTrfClient = new WorkbenchTrfClient(new HttpClient());
                    var batchNo     = Convert.ToInt32(batch);
                    type = exportAPInvoices.GetBatchType(batchNo);

                    if (type == "ApInvoice" || type == "ApCredit")
                    {
                        var apiResult  = wbTrfClient.APInvoiceTrfApi_GetAsync(batchNo);
                        var apInvoices = apiResult.Result;
                        exportTable = "APInvoices";
                        foreach (var invoice in apInvoices)
                        {
                            _ = wbTrfClient.LogTrfApi_Post2Async(batchNo, invoice.ID.Value, exportTable, Type2.Error, $"Error exporting batch {ex.Message}").Result;
                        }
                        _ = wbTrfClient.LogTrfApi_PostAsync(sessionId, "Export log marked as error", batchNo, Type.Error).Result;
                    }
                    if (type == "ArInvoice" || type == "ArCredit")
                    {
                        var apiResult  = wbTrfClient.ARInvoiceTrfApi_GetAsync(batchNo);
                        var arInvoices = apiResult.Result;
                        exportTable = "ARInvoices";
                        foreach (var invoice in arInvoices)
                        {
                            _ = wbTrfClient.LogTrfApi_Post2Async(batchNo, invoice.ID.Value, exportTable, Type2.Error, $"Error exporting batch {ex.Message}").Result;
                        }
                        _ = wbTrfClient.LogTrfApi_PostAsync(sessionId, "Export log marked as error", batchNo, Type.Error).Result;
                    }
                    if (type == "Adjustment" || type == "WipAccrual" || type == "CccAccrual" || type == "PoAccrual")
                    {
                        exportTable = "GLJournals";
                        _           = wbTrfClient.LogTrfApi_Post2Async(batchNo, batchNo, exportTable, Type2.Error, $"Error exporting batch {ex.Message}").Result;
                    }

                    if (type == "Disbursement" || type == "PlantIssue" || type == "Docket" || type == "Timesheet")
                    {
                        exportTable = "GLJournals";
                        _           = wbTrfClient.LogTrfApi_Post2Async(batchNo, batchNo, exportTable, Type2.Error, $"Error exporting batch {ex.Message}").Result;
                    }

                    if (type == "StockReturn" || type == "StockIssue" || type == "StockTrf" || type == "StockAdjust")
                    {
                        exportTable = "GLJournals";
                        _           = wbTrfClient.LogTrfApi_Post2Async(batchNo, batchNo, exportTable, Type2.Error, $"Error exporting batch {ex.Message}").Result;
                    }
                }

                Helpers.LogAppError($"catch {ex.InnerException.Message}");
                _ = exportAPInvoices.wbTrfclient.BatchTrfApi_PostAsync(batchList, Convert.ToInt32(exportUserId)).Result;
            }
            finally
            {
                Helpers.LogInfo($"finally {batchList}");
                _ = exportAPInvoices.wbTrfclient.BatchTrfApi_PostAsync(batchList, Convert.ToInt32(exportUserId)).Result;
            }

            Helpers.LogInfo($"exit {batchList}");
            _ = exportAPInvoices.wbTrfclient.BatchTrfApi_PostAsync(batchList, Convert.ToInt32(exportUserId)).Result;
            return("exit");
        }
Example #2
0
 public ExportARInvoices(Client wbClient, Company sapCompany, WorkbenchTrfClient wbTrfclient) :
     base(wbClient, sapCompany, wbTrfclient)
 {
 }
 public ImportBase(Client wbClient, Company sapCompany, WorkbenchTrfClient wbTrfclient)
 {
     this.wbClient    = wbClient;
     this.sapCompany  = sapCompany;
     this.wbTrfclient = wbTrfclient;
 }
Example #4
0
        protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
        {
            try
            {
                base.ApplicationStartup(container, pipelines);

                pipelines.EnableBasicAuthentication(new BasicAuthenticationConfiguration(
                                                        container.Resolve <IUserValidator>(),
                                                        "MyRealm"));

                var httpClient = new HttpClient()
                {
                    BaseAddress = new Uri(ConfigurationManager.AppSettings["WorkbenchUrl"])
                };

                httpClient.DefaultRequestHeaders.Authorization = !string.IsNullOrEmpty(ConfigurationManager.AppSettings["WorkbenchApiKey"]) ?
                                                                 new AuthenticationHeaderValue("Bearer ", ConfigurationManager.AppSettings["WorkbenchApiKey"]) :
                                                                 new AuthenticationHeaderValue("Basic", (ConfigurationManager.AppSettings["WorkbenchUserName"] + ":" + ConfigurationManager.AppSettings["WorkbenchPassword"].FromBase64()).ToBase64());

                var sapClient   = ServerConnection.Current;
                var wbtrfClient = new WorkbenchTrfClient(new HttpClient());
                var client      = new Client(httpClient);
                var company     = sapClient.GetCompany();

                container.Register((c, p) =>
                {
                    return(new Client(httpClient));
                });

                container.Register((c, p) =>
                {
                    return(ServerConnection.Current);
                });

                container.Register((c, p) =>
                {
                    return(ServerConnection.Current.GetCompany());
                });


                container.Register((c, p) =>
                {
                    return(new ImportBase(client, company, wbtrfClient));
                });


                container.Register((c, p) =>
                {
                    return(new ExportBase(client, company, wbtrfClient));
                });


                container.Register((c, p) =>
                {
                    return(new ExportJobs(client, company, wbtrfClient));
                });

                container.Register((c, p) =>
                {
                    return(new ExportClient(new ExportJobs(client, company, wbtrfClient),
                                            new ExportGLJournals(client, company, wbtrfClient),
                                            new ExportAPInvoices(client, company, wbtrfClient),
                                            new ExportARInvoices(client, company, wbtrfClient)));
                });

                container.Register((c, p) =>
                {
                    return(new ExportProcessBatch(new ExportJobs(client, company, wbtrfClient),
                                                  new ExportGLJournals(client, company, wbtrfClient),
                                                  new ExportAPInvoices(client, company, wbtrfClient),
                                                  new ExportARInvoices(client, company, wbtrfClient)));
                });

                container.Register((c, p) =>
                {
                    return(new ExportAPInvoices(client, company, wbtrfClient));
                });

                current = (ExportClient)container.Resolve(typeof(ExportClient));
            }
            catch (Exception ex)
            {
                Helpers.LogAppError($"{ex.InnerException} {ex.Message}");
            }
        }
 public ImportExchangeRates(Client wbClient, Company sapCompany, WorkbenchTrfClient wbTrfclient) :
     base(wbClient, sapCompany, wbTrfclient)
 {
 }
Example #6
0
 public ImportPayments(Client wbClient, Company sapCompany, WorkbenchTrfClient wbTrfclient) :
     base(wbClient, sapCompany, wbTrfclient)
 {
 }
 public ImportJobReceipts(Client wbClient, Company sapCompany, WorkbenchTrfClient wbTrfclient) :
     base(wbClient, sapCompany, wbTrfclient)
 {
 }
 public ExportGLJournals(Client wbClient, Company sapCompany, WorkbenchTrfClient wbTrfclient) :
     base(wbClient, sapCompany, wbTrfclient)
 {
 }