private EnterCurrentQuote GetCurrentQuote_Model(EWS.Domain.Data.DataModel.Quote entity)
{
EnterCurrentQuote model = new EnterCurrentQuote();
model.QuoteID = entity.ID;
model.TenderNumber = entity.TenderNo;
model.VAT = entity.VAT;
model.SellingPriceExclVAT = entity.SellingPrice;
model.SellingPriceInclVAT = Math.Round(entity.SellingPrice * Convert.ToDecimal(entity.VAT / 100 + 1), 2);
model.NoOfMonths = entity.ContractTerm;
model.Customer = GetCustomer_Model(entity.CustomerID);
DeviceQuery dqry = new Domain.Data.Queries.DeviceQuery()
{
DeviceID = entity.DeviceID
};
model.Device = _queryProcessor.Execute(dqry);
model.ExchangeRate = new ExchangeRate()
{
Rate = entity.ROE,
Date = entity.ROEDate
};
model.ContractCalculations = GetNewContractCalculationModels(model.SellingPriceExclVAT);
UpdateModelFromSavedValues(model.ContractCalculations, model.QuoteID);
return(model);
}
private EnterEquipmentQuote GetEquipmentQuote_Model(string QuoteRef)
{
if (string.IsNullOrEmpty(QuoteRef))
{
return(null);
}
else
{
EWS.Domain.Data.DataModel.Quote quote = GetExistingQuote(QuoteRef);
if (quote != null)
{
return(GetEquipmentQuote_Model(quote));
}
else
{
Domain.Model.SourceQuote sourcequote = GetSourceQuote(QuoteRef);
if (sourcequote == null)
{
return(null);
}
else
{
EnterEquipmentQuote model = new EnterEquipmentQuote();
model.QuoteRef = QuoteRef;
DeviceQuery query = new Domain.Data.Queries.DeviceQuery()
{
DeviceID = sourcequote.DeviceID
};
model.Device = _queryProcessor.Execute(query);
model.TenderNumber = sourcequote.TenderNumber;
model.VAT = sourcequote.VAT;
model.SellingPriceExclVAT = sourcequote.SellingPriceInclVAT / Convert.ToDecimal(1 + sourcequote.VAT / 100);
model.SellingPriceInclVAT = sourcequote.SellingPriceInclVAT;
model.ContractCalculations = GetNewEquipmentContractCalculationModels(model.SellingPriceExclVAT);
if (quote == null) // fill in from source quote:
{
// Exchange Rate
CurrencyQuery cquery = new CurrencyQuery()
{
ID = "USD"
};
Domain.Data.DataModel.Currency usd = _queryProcessor.Execute(cquery);
model.ExchangeRate = new ExchangeRate()
{
Rate = Convert.ToDecimal(usd.DefaultRateOfExchange),
Date = DateTime.Today
};
}
return(model);
}
}
}
} //GetEquipmentQuote_Model
public EWS.Domain.Data.DataModel.ContractInclusion[] GetContractInclusions(int QuoteID)
{
QuoteQuery quotequery = new QuoteQuery()
{
ID = QuoteID
};
EWS.Domain.Data.DataModel.Quote quote = _queryProcessor.Execute(quotequery);
DeviceQuery devicequery = new DeviceQuery()
{
DeviceID = quote.DeviceID
};
EWS.Domain.Model.Device device = _queryProcessor.Execute(devicequery);
ContractInclusionsQuery inclquery = new ContractInclusionsQuery()
{
ModalityID = device.ModalityID
};
IEnumerable <EWS.Domain.Data.DataModel.ContractInclusion> result1 = _queryProcessor.Execute(inclquery);
inclquery = new ContractInclusionsQuery()
{
ModalityID = null
};
IEnumerable <EWS.Domain.Data.DataModel.ContractInclusion> result2 = _queryProcessor.Execute(inclquery);
EWS.Domain.Data.DataModel.ContractInclusion[] inclusions = result1.Concat(result2).ToArray();
return(inclusions);
}
private EWS.Domain.Data.DataModel.Quote GetExistingQuote(int ContractID)
{
QuoteQuery query = new Domain.Data.Queries.QuoteQuery()
{
BaseContractID = ContractID
};
EWS.Domain.Data.DataModel.Quote founditem = _queryProcessor.Execute <EWS.Domain.Data.DataModel.Quote>(query);
return(founditem);
}
private EWS.Domain.Data.DataModel.Quote GetExistingQuote(string QuoteRef)
{
QuoteQuery query = new Domain.Data.Queries.QuoteQuery()
{
QuoteRef = QuoteRef
};
EWS.Domain.Data.DataModel.Quote founditem = _queryProcessor.Execute <EWS.Domain.Data.DataModel.Quote>(query);
return(founditem);
}
private EWS.Domain.Model.Quote GetQuote_Model(EWS.Domain.Data.DataModel.Quote entity)
{
EWS.Domain.Model.Quote model = new EWS.Domain.Model.Quote();
model.QuoteID = entity.ID;
model.QuoteRef = entity.QuoteRef;
model.ContractID = entity.BaseContractID;
model.TenderNumber = entity.TenderNo;
model.VAT = entity.VAT;
model.SellingPriceExclVAT = entity.SellingPrice;
model.SellingPriceInclVAT = Math.Round(entity.SellingPrice * Convert.ToDecimal(entity.VAT / 100 + 1), 2);
model.NoOfMonths = entity.ContractTerm;
model.Customer = GetCustomer_Model(entity.CustomerID);
DeviceQuery dqry = new Domain.Data.Queries.DeviceQuery()
{
DeviceID = entity.DeviceID
};
model.Device = _queryProcessor.Execute(dqry);
model.ExchangeRate = new ExchangeRate()
{
Rate = entity.ROE,
Date = entity.ROEDate
};
QuoteCalculationsQuery qcqry = new QuoteCalculationsQuery()
{
QuoteID = entity.ID
};
IEnumerable <Domain.Data.DataModel.QuoteCalculation> listofQuoteCalcs = _queryProcessor.Execute(qcqry);
model.ContractCalculations = new List <QuoteCalculation>();
foreach (Domain.Data.DataModel.QuoteCalculation calc in listofQuoteCalcs)
{
QuoteCalculation calcmodel = new QuoteCalculation();
MapEntityToModel(calc, calcmodel);
model.ContractCalculations.Add(calcmodel);
QuoteCalculationItem[] years = GetQuoteCalculationItemsStructure(calc, (short)(model.NoOfMonths / 12), model.StartDate);
calcmodel.QuoteCalculationItems = Recalculate(calcmodel, years, model.StartDate);
}
return(model);
}
} //GetCurrentQuote_Model
private EWS.Domain.Model.Quote GetQuote_Model(int QuoteID)
{
if (QuoteID <= 0)
{
return(null);
}
else
{
QuoteQuery query = new Domain.Data.Queries.QuoteQuery()
{
ID = QuoteID
};
EWS.Domain.Data.DataModel.Quote entity = _queryProcessor.Execute <EWS.Domain.Data.DataModel.Quote>(query);
return(GetQuote_Model(entity));
}
}
public Device[] GetCoveredItems(int QuoteID)
{
QuoteQuery quotequery = new QuoteQuery()
{
ID = QuoteID
};
EWS.Domain.Data.DataModel.Quote quote = _queryProcessor.Execute(quotequery);
DeviceQuery devicequery = new DeviceQuery()
{
DeviceID = quote.DeviceID
};
EWS.Domain.Model.Device device = _queryProcessor.Execute(devicequery);
return(new Device[1] {
device
}); //Todo finish this so it returns the individual components
}
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);
}
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
