Beispiel #1
0
        public EWS.Domain.Data.DataModel.Contract GetContract(int ContractID)
        {
            ContractQuery query = new Domain.Data.Queries.ContractQuery()
            {
                ID = ContractID
            };

            EWS.Domain.Data.DataModel.Contract founditem = _queryProcessor.Execute(query);

            return(founditem);
        }
Beispiel #2
0
        private EWS.Domain.Model.QuoteCalculationItem[] GetQuoteCalculationItemsStructure(Domain.Data.DataModel.QuoteCalculation calc, short NoOfYears, DateTime?StartDate = null)
        {
            QuoteCalculationItem[] models = new QuoteCalculationItem[NoOfYears];

            // new/old ROE and VAT values needed .........................................
            decimal oldROE;
            decimal newROE;
            float   VAT;


            QuoteQuery quotequery = new QuoteQuery()
            {
                ID = calc.QuoteID
            };

            EWS.Domain.Data.DataModel.Quote quoteEntity = _queryProcessor.Execute(quotequery);
            newROE = quoteEntity.ROE;

            if (!string.IsNullOrEmpty(quoteEntity.QuoteRef))
            {
                SourceQuoteQuery query = new SourceQuoteQuery()
                {
                    QuoteRef = quoteEntity.QuoteRef
                };
                SourceQuote entity = _queryProcessor.Execute(query);
                oldROE = entity.ROE;
                VAT    = entity.VAT;
            }
            else
            {
                ContractQuery query = new ContractQuery()
                {
                    ID = quoteEntity.BaseContractID.Value
                };
                EWS.Domain.Data.DataModel.Contract entity = _queryProcessor.Execute(query);
                oldROE = entity.ROE;
                VAT    = entity.VAT;
            }

            // Currently Saved values ....................................................
            QuoteCalculationItemsQuery qury = new QuoteCalculationItemsQuery()
            {
                QuoteCalculationID = calc.ID
            };
            IEnumerable <Domain.Data.DataModel.QuoteCalculationItem> calcs = _queryProcessor.Execute(qury);

            // Setup the structure .......................................................
            for (byte i = 0; i < NoOfYears; i++)
            {
                byte yearno = (byte)(i + 1);
                models[i] = new QuoteCalculationItem()
                {
                    YearNo    = yearno,
                    NewROE    = newROE, TOPSROE = oldROE, VAT = VAT,
                    UseNewROE = true,
                    Increment = (i == 0 ? 0 : EWS.Domain.Defaults.AnnualIncrement)
                };

                if (StartDate.HasValue)
                {
                    models[i].StartDate = StartDate.Value.AddYears(i);
                    models[i].EndDate   = StartDate.Value.AddYears(yearno).AddDays(-1);
                }

                Domain.Data.DataModel.QuoteCalculationItem item = calcs.FirstOrDefault(c => c.YearNo == yearno);
                if (item != null)
                {
                    models[i].ID        = item.ID;
                    models[i].Increment = item.IncrPerc;
                    models[i].UseNewROE = (item.ROE == newROE);
                }
            }



            return(models);
        }
Beispiel #3
0
        private EnterCurrentQuote GetCurrentQuote_Model(string ContractID)
        {
            if (string.IsNullOrEmpty(ContractID))
            {
                return(null);
            }
            else
            {
                int contractID = Convert.ToInt32(ContractID);
                EWS.Domain.Data.DataModel.Quote quote = GetExistingQuote(contractID);
                if (quote != null)
                {
                    return(GetCurrentQuote_Model(quote));
                }
                else
                {
                    EWS.Domain.Data.DataModel.Contract sourcecontract = GetContract(contractID);
                    if (sourcecontract == null)
                    {
                        return(null);
                    }
                    else
                    {
                        EnterCurrentQuote model = new EnterCurrentQuote();


                        DeviceQuery query = new Domain.Data.Queries.DeviceQuery()
                        {
                            DeviceID = sourcecontract.DeviceID
                        };
                        model.Device = _queryProcessor.Execute(query);

                        model.TenderNumber        = sourcecontract.TenderNo;
                        model.VAT                 = sourcecontract.VAT;
                        model.SellingPriceExclVAT = 0;
                        model.SellingPriceInclVAT = 0;


                        List <EWS.Domain.Data.DataModel.ContractItem> contractitems = GetContractItems(contractID);
                        model.ContractCalculations = new List <QuoteCalculation>();
                        foreach (EWS.Domain.Data.DataModel.ContractItem contractitem in contractitems)
                        {
                            model.ContractCalculations.Add(new QuoteCalculation()
                            {
                                Selected         = true,
                                BasePrice        = contractitem.BasePrice,
                                ContractTypeID   = contractitem.ContractTypeID,
                                ContractType     = contractitem.ContractType.ContractTypeName,
                                ROEPortion       = contractitem.ROEPortion,
                                ROEPortionAmount = contractitem.ROEPortionAmount,
                                ZARPortion       = contractitem.ZARPortion,
                                ZARPortionAmount = contractitem.ZARPortionAmount
                            });
                        }

                        CustomerQuery customerquery = new CustomerQuery()
                        {
                            ID = sourcecontract.CustomerID
                        };
                        Domain.Data.DataModel.Customer customer = _queryProcessor.Execute(customerquery);

                        model.Customer = new Customer()
                        {
                            Id             = sourcecontract.CustomerID,
                            CustomerName   = customer.CustomerNameFriendly,
                            Locality       = customer.CustomerLocality.CustomerLocalityName,
                            RegistrationNo = customer.RegistrationNo
                        };

                        model.ExchangeRate = new ExchangeRate()
                        {
                            Rate = sourcecontract.ROE,
                            Date = sourcecontract.ROEDate
                        };

                        return(model);
                    }
                }
            }
        } //GetCurrentQuote_Model