Example #1
0
        private void MergeLineFromCache(ExpenseClaimLine line)
        {
            bool isFound = false;

            for (int i = 0; i < _model.Lines.Count; i++)
            {
                if (_model.Lines[i].LineNbr == line.LineNbr)
                {
                    if (line.Deleted == true)
                    {
                        _model.Lines.RemoveAt(i);
                        _model.DeletedLines.Add(line);
                    }
                    else
                    {
                        _model.Lines[i] = line;
                    }
                    isFound = true;
                    break;
                }
            }

            if (!isFound && !line.Deleted)
            {
                //This is a newly added line
                _model.Lines.Add(line);
            }
        }
Example #2
0
        private async void LoadDesignData()
        {
            var service = Acumatica.Core.Ioc.Container.Default.GetInstance <IExpenseClaimService>();
            var claim   = await service.GetExpenseClaim("12345");

            _model = claim.Lines[0];
            OnPropertyChanged("Model");
        }
Example #3
0
        private void ExecuteShowExpenseClaimLine(ExpenseClaimLine line)
        {
            var cache = Acumatica.Core.Ioc.Container.Default.GetInstance <IExpenseClaimLineCache>();

            cache.CurrentLine = line;
            cache.CurrentLine.HasUnsavedChanges = false;

            Acumatica.Core.Ioc.Container.Default.GetInstance <Acumatica.Core.Service.INavigationService>().NavigateTo("ExpenseClaimLinePage", null);
        }
Example #4
0
        private void ExecuteAddExpenseCommand()
        {
            var newLine = new ExpenseClaimLine();

            newLine.AllowEdit    = true;
            newLine.ParentRefNbr = Model.RefNbr;
            newLine.LineNbr      = Model.Lines.Max(l => l.LineNbr).GetValueOrDefault(0) + 1;
            newLine.Date         = System.DateTime.Today;

            var cache = Acumatica.Core.Ioc.Container.Default.GetInstance <IExpenseClaimLineCache>();

            cache.CurrentLine = newLine;

            Acumatica.Core.Ioc.Container.Default.GetInstance <Acumatica.Core.Service.INavigationService>().NavigateTo("ExpenseClaimLinePage", null);
        }
Example #5
0
        public override void LoadState(object navigationParameter, Dictionary <String, Object> viewData)
        {
            if (viewData != null && viewData.ContainsKey("CurrentLine"))
            {
                _model = (ExpenseClaimLine)viewData["CurrentLine"];
                _model.TrackChanges();
            }
            else
            {
                var cache = Acumatica.Core.Ioc.Container.Default.GetInstance <IExpenseClaimLineCache>();
                System.Diagnostics.Debug.Assert(cache.CurrentLine != null, "An expense claim line should be stored in the cache before we are loaded");
                if (cache.CurrentLine != null)
                {
                    _model = Acumatica.Core.Helpers.ObjectCloner.Clone <ExpenseClaimLine>(cache.CurrentLine);
                    _model.TrackChanges();
                }
            }

            if (_model != null)
            {
                PageTitle = string.Format("Expense Claim {0} Line", _model.ParentRefNbr);
            }
        }
Example #6
0
        public Task <ExpenseClaim> GetExpenseClaim(string refNbr)
        {
            return(Task.Factory.StartNew <ExpenseClaim>(() =>
            {
                var claim = new ExpenseClaim("Sample Expense Claim", "MICG", refNbr, 334.56M, DateTime.Today, "Hold");
                claim.Hold = true;
                claim.Location = "MAIN";
                claim.NoteText = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Mauris lectus est, pellentesque quis luctus sit amet, hendrerit sed nunc";
                claim.AllowEdit = true;

                var line = new ExpenseClaimLine();
                line.ParentRefNbr = refNbr;
                line.AllowEdit = true;
                line.Date = DateTime.Today.AddDays(-5);
                line.RefNbr = "1234";
                line.ExpenseId = "DEP";
                line.Quantity = 3;
                line.UnitCost = 100;
                line.Total = 300;
                line.EmployeePart = 10;
                line.Description = "Line 1 Description";
                claim.Lines.Add(line);

                var line2 = new ExpenseClaimLine();
                line2.ParentRefNbr = refNbr;
                line2.AllowEdit = true;
                line2.Date = DateTime.Today.AddDays(-3);
                line2.RefNbr = "4567";
                line2.ExpenseId = "FUEL";
                line2.Total = 34.56M;
                line2.Description = "Line 2 Description";
                claim.Lines.Add(line2);

                return claim;
            }));
        }
        public async Task <ExpenseClaim> GetExpenseClaim(string refNbr)
        {
            ScreenSoapClient client = await GetAuthenticatedClient(Common.SettingsStore.SiteUrl, Common.SettingsStore.Username, Common.SettingsStore.Password);

            var schema = await GetSavedSchema();

            await client.SetSchemaAsync(schema);

            var result = await client.ExportAsync(new Command[] {
                new Value {
                    Value = refNbr, LinkedCommand = schema.DocumentSummary.ReferenceNbr
                },
                schema.DocumentSummary.Description,
                schema.DocumentSummary.ClaimedBy,
                schema.DocumentSummary.ClaimTotal,
                schema.DocumentSummary.Date,
                schema.DocumentSummary.Status,
                schema.DocumentSummary.ApprovalDate,
                schema.DocumentSummary.Hold,
                schema.DocumentSummary.Location,
                schema.DocumentSummary.NoteText,
                new Field()
                {
                    FieldName = "ClaimDetailID", ObjectName = "ExpenseClaimDetails"
                },
                schema.ExpenseClaimDetails.Date,
                schema.ExpenseClaimDetails.RefNbr,
                schema.ExpenseClaimDetails.ExpenseItem,
                schema.ExpenseClaimDetails.Quantity,
                schema.ExpenseClaimDetails.UnitCost,
                schema.ExpenseClaimDetails.TotalAmount,
                schema.ExpenseClaimDetails.EmployeePart,
                schema.ExpenseClaimDetails.Billable,
                schema.ExpenseClaimDetails.Customer,
                schema.ExpenseClaimDetails.Location,
                schema.ExpenseClaimDetails.ProjectContract,
                schema.ExpenseClaimDetails.ProjectTask,
                schema.ExpenseClaimDetails.Description,
                schema.ExpenseClaimDetails.NoteText,
            },
                                                  null,
                                                  0, false, true);

            if (result.ExportResult.Length == 0)
            {
                return(null);
            }

            var claim = new ExpenseClaim(result.ExportResult[0][0].Trim(),
                                         result.ExportResult[0][1].Trim(),
                                         refNbr,
                                         decimal.Parse(result.ExportResult[0][2].Trim(), System.Globalization.CultureInfo.InvariantCulture),
                                         DateTime.Parse(result.ExportResult[0][3].Trim(), System.Globalization.CultureInfo.InvariantCulture),
                                         result.ExportResult[0][4].Trim());

            if (!String.IsNullOrEmpty(result.ExportResult[0][5]))
            {
                claim.ApprovalDate = DateTime.Parse(result.ExportResult[0][5], System.Globalization.CultureInfo.InvariantCulture);
            }

            claim.Hold     = bool.Parse(result.ExportResult[0][6]);
            claim.Location = result.ExportResult[0][7];
            claim.NoteText = result.ExportResult[0][8];

            for (int i = 0; i < result.ExportResult.Length; i++)
            {
                var lineNbr = result.ExportResult[i][9];
                if (String.IsNullOrEmpty(lineNbr))
                {
                    continue;
                }

                var line = new ExpenseClaimLine();
                line.ParentRefNbr = refNbr;
                line.LineNbr      = int.Parse(lineNbr, System.Globalization.CultureInfo.InvariantCulture);
                line.Date         = DateTime.Parse(result.ExportResult[i][10], System.Globalization.CultureInfo.InvariantCulture);
                line.RefNbr       = result.ExportResult[i][11];
                line.ExpenseId    = result.ExportResult[i][12].Trim();
                line.Quantity     = decimal.Parse(result.ExportResult[i][13], System.Globalization.CultureInfo.InvariantCulture);
                line.UnitCost     = decimal.Parse(result.ExportResult[i][14], System.Globalization.CultureInfo.InvariantCulture);
                line.Total        = decimal.Parse(result.ExportResult[i][15], System.Globalization.CultureInfo.InvariantCulture);
                line.EmployeePart = decimal.Parse(result.ExportResult[i][16], System.Globalization.CultureInfo.InvariantCulture);
                line.Billable     = bool.Parse(result.ExportResult[i][17]);
                line.Customer     = result.ExportResult[i][18].Trim();
                line.Location     = result.ExportResult[i][19].Trim();
                line.Project      = result.ExportResult[i][20].Trim();
                line.ProjectTask  = result.ExportResult[i][21].Trim();
                line.Description  = result.ExportResult[i][22];
                line.NoteText     = result.ExportResult[i][23];
                claim.Lines.Add(line);
            }

            var claimStatus = await client.SubmitAsync(new Command[]
            {
                new Value {
                    Value = refNbr, LinkedCommand = schema.DocumentSummary.ReferenceNbr
                },
                schema.DocumentSummary.Description
            });

            if (claimStatus.Length > 0)
            {
                // The schema needs to be generated with schema mode == detailed for this to work
                claim.AllowEdit = !claimStatus[0].DocumentSummary.Description.Descriptor.IsDisabled;
            }

            foreach (var line in claim.Lines)
            {
                line.AllowEdit         = claim.AllowEdit;
                line.HasUnsavedChanges = false;
            }

            claim.HasUnsavedChanges = false;
            return(claim);
        }