Example #1
0
        public async Task CalculateChargeAsync(int chargeId)
        {
            var calculationInfos = await GetExpensesAsync(chargeId);

            List <ChargeItemDTO> chargeItems = new List <ChargeItemDTO>();

            foreach (var calculationInfo in calculationInfos)
            {
                var shareInfos = await GetShareInfosAsync(calculationInfo);

                IFormula formula = CalculationFormulaFactory.Create(calculationInfo.FormulaName);
                chargeItems.AddRange(formula.Calculate(calculationInfo.Amount, shareInfos, calculationInfo.ExpenseId, calculationInfo.IsForOwner));
            }
            var gateway = _gatewayFactory.CreateChargeItemTableGateway();
            await gateway.InsertChargeItemsAsync(chargeItems, chargeId);
        }
        private ExplicitFormula updateFormulaToAmountBase(IFormula originalFormula, IDimension amountDimension)
        {
            ExplicitFormula formulaInAmount;

            if (originalFormula.IsExplicit())
            {
                formulaInAmount = _cloneManagerForModel.Clone(originalFormula.DowncastTo <ExplicitFormula>());
            }
            else
            {
                formulaInAmount = _objectBaseFactory.Create <ExplicitFormula>()
                                  .WithFormulaString(originalFormula.Calculate(null).ToString(CultureInfo.InvariantCulture));
            }

            formulaInAmount.Dimension = amountDimension;

            var volumeAlias = _formulaTask.AddParentVolumeReferenceToFormula(formulaInAmount);

            formulaInAmount.FormulaString = $"({formulaInAmount.FormulaString})*{volumeAlias}";
            return(formulaInAmount);
        }
Example #3
0
        private FormulaExport createFormulaExport(IUsingFormula usingFormula, IFormula formula)
        {
            switch (formula)
            {
            case ExplicitFormula explicitFormula:
                var explicitFormulaExport = new ExplicitFormulaExport {
                    Equation = explicitFormula.FormulaString
                };
                addObjectReferencesTo(explicitFormula, explicitFormulaExport.ReferenceList);
                return(explicitFormulaExport);

            case TableFormulaWithXArgument tableFormulaWithXArgument:
                var tableFormulaWithXArgumentExport = new TableFormulaWithXArgumentExport()
                {
                    TableObjectId     = idFor(tableFormulaWithXArgument.GetTableObject(usingFormula)),
                    XArgumentObjectId = idFor(tableFormulaWithXArgument.GetXArgumentObject(usingFormula))
                };
                return(tableFormulaWithXArgumentExport);

            case TableFormulaWithOffset tableFormulaWithOffset:
                var tableFormulaWithOffsetExport = new TableFormulaWithOffsetExport
                {
                    TableObjectId  = idFor(tableFormulaWithOffset.GetTableObject(usingFormula)),
                    OffsetObjectId = idFor(tableFormulaWithOffset.GetOffsetObject(usingFormula))
                };
                return(tableFormulaWithOffsetExport);

            case TableFormula tableFormula:
                return(_tableFormulaExportMapper.MapFrom(tableFormula));

            default:
                return(new ExplicitFormulaExport {
                    Equation = formula.Calculate(usingFormula).ToString(NumberFormatInfo.InvariantInfo)
                });
            }
        }