public TypeOfCustomer(string firstName, string lastName, InsuranceType typeOfInsurance, string email)
{
FirstName = firstName;
LastName = lastName;
TypeOfInsurance = typeOfInsurance;
Email = email;
}
public void ImportFromExcel(string excelFileName, string dataSheet, InsuranceType insType, bool isCashFlow)
{
var govs = _db.Entities
.Where(e => e.Identity.Contains(string.Format("{0}(guid'", _db.Governors.RequestUri.PathAndQuery)))
.Select(ed => ProxyActivator.CreateProxy <Governor, BLL.Governor>(ed.Entity as Governor)).ToList();
XlsObject <BLL.AssetValue> parser;
if (isCashFlow)
{
parser = new AssetsCashXlsObject(govs, insType, excelFileName, dataSheet);
}
else
{
parser = new AssetsValXlsObject(govs, insType, excelFileName, dataSheet);
}
var list = parser.SelectAll().Select(val => Newtonsoft.Json.JsonConvert.SerializeObject(val)).ToList();
UriBuilder urib = new UriBuilder(_db.BaseUri);
urib.Path = string.Format("{0}/CreateBatch", _db.Assets.RequestUri.PathAndQuery);
var r = _db.Execute <bool>(urib.Uri, "POST", true
, new System.Data.Services.Client.BodyOperationParameter("Values", list)
).FirstOrDefault();
if (!r)
{
throw new InvalidOperationException("ImportFromExcel");
}
}
public void PublicAssetProfitReport(DateTime db, DateTime de, InsuranceType insType, Governor gov)
{
var rawReport = _rep.PublicAssetProfitReport(db, de, insType, gov != null ? gov.Id : (Guid?)null);
string tempDir = Path.Combine(Path.GetTempPath(), "Access", "XsltReports");
string filePath = Path.Combine(tempDir, string.Format("AssetProfitReport{0:yyMMddHHmm}.xml", DateTime.Now));
Directory.CreateDirectory(tempDir);
using (StreamWriter txtstream = File.CreateText(filePath))
{
try
{
txtstream.Write(rawReport);
}
catch (Exception ex)
{
if (File.Exists(filePath))
File.Delete(filePath);
throw new InvalidOperationException(string.Format("Ошибка при генерации файла отчета. " + Environment.NewLine + "Ошибка: {0}", ex.Message), ex);
}
}
//var p = new System.Diagnostics.Process();
//p.StartInfo = new System.Diagnostics.ProcessStartInfo(filePath);
//p.Start();
System.Diagnostics.Process.Start(filePath);
}
public AirlinerInsurance(InsuranceType insType, InsuranceScope insScope, PaymentTerms paymentTerms, int insAmount)
{
this.Deductible = 0;
this.TermLength = 0;
this.CancellationFee = 0;
this.InsuredAmount = insAmount;
}
/// <summary>
/// The get insurance.
/// </summary>
/// <param name="statement">
/// The statement.
/// </param>
/// <returns>
/// The <see cref="InsuranceType"/>.
/// </returns>
protected virtual InsuranceType GetInsurance(Statement statement)
{
var conceptManager = ObjectFactory.GetInstance <IConceptCacheManager>();
var insurance = new InsuranceType();
insurance.TER_ST = Batch.Sender.Okato;
insurance.ENP = statement.NumberPolicy;
insurance.OGRNSMO = Batch.Receiver.Ogrn;
// Зарегистрирован в РС ЕРП
insurance.ERP = 1;
// recType.Insurance.ORDERZ = TODO : Расширить функционал
// Информация о документе, подтверждающем факт страхования по ОМС
if (statement.MedicalInsurances != null)
{
insurance.POLIS = new List <PolisType>(2);
foreach (var medicalInsurance in statement.MedicalInsurances)
{
var polis = new PolisType();
polis.VPOLIS = conceptManager.Unproxy(medicalInsurance.PolisType).Code;
polis.SPOLIS = medicalInsurance.PolisSeria;
polis.NPOLIS = medicalInsurance.PolisNumber;
polis.DBEG = medicalInsurance.DateFrom.ToShortDateString();
polis.DEND = medicalInsurance.DateTo.ToShortDateString();
polis.DSTOP = medicalInsurance.DateStop.HasValue ? medicalInsurance.DateTo.ToShortDateString() : string.Empty;
insurance.POLIS.Add(polis);
}
}
return(insurance);
}
public static void ValidateInsertCode(string code)
{
InsuranceType insuranceType = new InsuranceType();
insuranceType.Code = code;
insuranceType.TestBeforeInsert();
}
public double GetBasePremium(InsuranceType insuranceType)
{
string basePremium = (from bp in _premiumRules.Descendants("BasePremium")
select bp.Element(insuranceType.ToString())).Single().Value;
return Convert.ToDouble(basePremium);
}
public static string InsuranceSubTypeCodeGenerator(int InsuranceTypeID)
{
List <InsuranceSubType> insuranceSubTypeList = InsuranceSubType.GetByInsuranceType(InsuranceTypeID).OrderBy(c => c.Code).ToList();
string lastCode = string.Empty;
if (insuranceSubTypeList.Last().Code.Substring(2) == InsuranceSubType.LAST_CODE)
{
lastCode = insuranceSubTypeList[insuranceSubTypeList.Count - 2].Code.Substring(2);
}
else
{
lastCode = insuranceSubTypeList.Last().Code.Substring(2);
}
int lastCodeNumber = int.Parse(lastCode);
InsuranceType it = InsuranceType.Get(InsuranceTypeID);
int length = lastCode.Length;
int newCodeNumber = lastCodeNumber + 1;
string newCode = newCodeNumber.ToString();
while (newCode.Length < length)
{
newCode = "0" + newCode;
}
newCode = it.Code + newCode;
return(newCode);
}
public void PublicAssetProfitReport(DateTime db, DateTime de, InsuranceType insType, Governor gov)
{
var rawReport = _rep.PublicAssetProfitReport(db, de, insType, gov != null ? gov.Id : (Guid?)null);
string tempDir = Path.Combine(Path.GetTempPath(), "Access", "XsltReports");
string filePath = Path.Combine(tempDir, string.Format("AssetProfitReport{0:yyMMddHHmm}.xml", DateTime.Now));
Directory.CreateDirectory(tempDir);
using (StreamWriter txtstream = File.CreateText(filePath))
{
try
{
txtstream.Write(rawReport);
}
catch (Exception ex)
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
throw new InvalidOperationException(string.Format("Ошибка при генерации файла отчета. " + Environment.NewLine + "Ошибка: {0}", ex.Message), ex);
}
}
//var p = new System.Diagnostics.Process();
//p.StartInfo = new System.Diagnostics.ProcessStartInfo(filePath);
//p.Start();
System.Diagnostics.Process.Start(filePath);
}
public Policy(int _id, InsuranceType inType, Agent a, double pre)
{
this._id = _id;
this._insuranceType = inType;
this._agent = a;
this._premiumPayable = pre;
}
public AirlinerInsurance(InsuranceType insType, InsuranceScope insScope, PaymentTerms paymentTerms, int insAmount)
{
this.Deductible = 0;
this.TermLength = 0;
this.CancellationFee = 0;
this.InsuredAmount = insAmount;
}
/// <summary>
/// Заполняет информацию о факте страхования
/// </summary>
/// <param name="insurance">
/// The insurance.
/// </param>
/// <param name="statement">
/// The statement.
/// </param>
protected virtual void FillInsurance(InsuranceType insurance, Statement statement)
{
var conceptManager = ObjectFactory.GetInstance <IConceptCacheManager>();
// Номер полиса
statement.NumberPolicy = insurance.ENP;
// Информация о документе, подтверждающем факт страхования по ОМС
statement.MedicalInsurances = new List <MedicalInsurance>();
foreach (var polis in insurance.POLIS)
{
var medInsurance = new MedicalInsurance();
medInsurance.Statement = statement;
medInsurance.PolisType =
conceptManager.GetBy(x => x.Code == polis.VPOLIS && x.Oid.Id == Oid.Формаизготовленияполиса).FirstOrDefault();
medInsurance.PolisSeria = polis.SPOLIS;
medInsurance.PolisNumber = polis.NPOLIS;
DateTime dateFrom;
if (!string.IsNullOrEmpty(polis.DBEG) && DateTime.TryParse(polis.DBEG, out dateFrom))
{
medInsurance.DateFrom = dateFrom;
}
DateTime dateTo;
if (!string.IsNullOrEmpty(polis.DEND) && DateTime.TryParse(polis.DEND, out dateTo))
{
medInsurance.DateTo = dateTo;
}
DateTime dateStop;
if (!string.IsNullOrEmpty(polis.DSTOP) && DateTime.TryParse(polis.DSTOP, out dateStop))
{
medInsurance.DateStop = dateStop;
}
statement.MedicalInsurances.Add(medInsurance);
if (!string.IsNullOrEmpty(medInsurance.PolisNumber))
{
////// Временное свидетельство
////if (medInsurance.PolisNumber.Length == 9)
////{
//// statement.NumberTemporaryCertificate = medInsurance.PolisNumber;
//// statement.DateIssueTemporaryCertificate = medInsurance.DateFrom;
////}
////// Номер бланка полиса
////if (medInsurance.PolisNumber.Length == 11)
////{
//// statement.NumberPolisCertificate = medInsurance.PolisNumber;
//// statement.DateIssuePolisCertificate = medInsurance.DateFrom;
////}
}
}
}
public InsuranceType Post(InsuranceType insuranceType)
{
if (insuranceType == null || !ModelState.IsValid)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid Request");
}
return(insuranceTypeService.AddUpdateInsuranceType(insuranceType.CreateFromm()).CreateFromm());
}
public LoyaltyServerData(int id, InsuranceType ins, string name, string fullname)
{
Id = id;
Insurance = ins;
LoyalName = name;
LoyalFullName = fullname;
MinLevel = 1;
}
private void Types_ListView_ItemClick(object sender, ItemClickEventArgs e)
{
clickedItem = (InsuranceType)e.ClickedItem;
Insurances = InsurManager.GetInsurances(clickedItem.category);
DisplayType = clickedItem.category;
// this.contentControl.Content = new UserControl();
}
public static void ValidateUpdateCode(int codeID, string code)
{
InsuranceType insuranceType = new InsuranceType();
insuranceType.Code = code;
insuranceType.ID = codeID;
insuranceType.TestBeforeUpdate();
}
/// <summary>
/// Update Insurance Type Properties while updating the instance
/// </summary>
private void UpdateInsuranceTypeProperties(InsuranceType insuranceType, InsuranceType dbVersion)
{
dbVersion.RecLastUpdatedBy = insuranceTypeRepository.LoggedInUserIdentity;
dbVersion.RecLastUpdatedDt = DateTime.Now;
dbVersion.RowVersion = dbVersion.RowVersion + 1;
dbVersion.InsuranceTypeCode = insuranceType.InsuranceTypeCode;
dbVersion.InsuranceTypeName = insuranceType.InsuranceTypeName;
dbVersion.InsuranceTypeDescription = insuranceType.InsuranceTypeDescription;
}
public string Report(ODataActionParameters parameters)
{
DateTime db = (DateTime)parameters["DateBegin"];
DateTime de = (DateTime)parameters["DateEnd"];
InsuranceType insType = (InsuranceType)(byte)parameters["InsuranceType"];
Guid? govId = (Guid?)parameters["GovernorId"];
return(_rep.PublicAssetProfitReport(db, de, insType, govId));
}
public Boolean Delete(InsuranceType insuranceType)
{
if (insuranceType == null || !ModelState.IsValid)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Invalid Request");
}
insuranceTypeService.DeleteInsuranceType(insuranceType.InsuranceTypeId);
return(true);
}
public AirlineInsurance(InsuranceType insType, InsuranceScope insScope, PaymentTerms paymentTerms, int insAmount)
{
Deductible = 0;
TermLength = 0;
CancellationFee = 0;
InsuredAmount = insAmount;
InsType = insType;
InsScope = insScope;
InsTerms = paymentTerms;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
GXGridView1.TotalRecords = InsuranceType.SelectCountCached();
mvMain.SetActiveView(viewGrid);
reportControl.BranchName = BrokerHouseInformation.GetBrokerHouseNameByCode(BrokerHouseInformation.FIRST_ROW);
reportControl.CompanyName = "Брокерско друштво";
}
}
public Account GetIssuerFromType(InsuranceType t)
{
var pair = _associations.FirstOrDefault(x => x.Value == t);
if (pair.Key == null)
{
return(null);
}
return(UserContext.Accounts.GetOrFail(pair.Key));
}
/// <summary>
/// Create From Web Model
/// </summary>
public static Cares.Models.DomainModels.InsuranceType CreateFromm(this InsuranceType source)
{
return(new Cares.Models.DomainModels.InsuranceType
{
InsuranceTypeId = source.InsuranceTypeId,
InsuranceTypeCode = source.InsuranceTypeCode,
InsuranceTypeName = source.InsuranceTypeName,
InsuranceTypeDescription = source.InsuranceTypeDescription
});
}
public void UpdateInsuranceType(UpdateInsuranceTypeCommand updatedInsuranceTypeCommand, int id)
{
var repo = new InsuranceTypeRepository();
var updatedInsuranceType = new InsuranceType
{
Name = updatedInsuranceTypeCommand.Name
};
repo.UpdateInsuranceType(updatedInsuranceType, id);
}
public void DeleteInsuranceType(UpdateInsuranceTypeCommand deletedInsuranceTypeCommand, int id)
{
var repo = new InsuranceTypeRepository();
var deletedInsuranceType = new InsuranceType
{
Name = deletedInsuranceTypeCommand.Name
};
repo.DeleteInsuranceType(deletedInsuranceType, id);
}
public async Task <List <PolicyItemSource> > LoadAllInsurancesByType(InsuranceType insuranceType)
{
IEnumerable <InsurancePolicyDto> insurances = (await _oDataClient.For <InsurancePolicyDto>(controllerName)
.Function("LoadInsurancesByType")
.Set(new { insuranceType })
.OrderBy(it => it.CreatedOn)
.FindEntriesAsync());
insurances = insurances.Where(i => i.ExpirationDate >= DateTimeOffset.Now.AddMonths(-2));
return(await ConvertPolicyToItemSource(insurances));
}
public string PublicAssetProfitReport(DateTime db, DateTime de, InsuranceType insType, Guid?govId)
{
UriBuilder urib = new UriBuilder(_db.BaseUri);
urib.Path = string.Format("{0}/Report", _db.Assets.RequestUri.PathAndQuery);
return(_db.Execute <string>(urib.Uri, "POST", true
, new System.Data.Services.Client.BodyOperationParameter("DateBegin", db)
, new System.Data.Services.Client.BodyOperationParameter("DateEnd", de)
, new System.Data.Services.Client.BodyOperationParameter("InsuranceType", (byte)insType)
, new System.Data.Services.Client.BodyOperationParameter("GovernorId", govId)
).FirstOrDefault());
}
public bool DeleteInsuranceType(InsuranceType insuranceTypeToDelete, int id)
{
using (var db = new SqlConnection(_connectionString))
{
var sql = @"UPDATE [dbo].[InsuranceType]
SET [Name] = NULL
WHERE Id = @id";
insuranceTypeToDelete.Id = id;
return(db.Execute(sql, insuranceTypeToDelete) == 1);
}
}
/// <summary>
/// Delete Insurance Type
/// </summary>
public void DeleteInsuranceType(long insuranceTypeId)
{
InsuranceType dbversion = insuranceTypeRepository.Find(insuranceTypeId);
CheckInsuranceTypeAssociations(insuranceTypeId);
if (dbversion == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Insurance Type with Id {0} not found!", insuranceTypeId));
}
insuranceTypeRepository.Delete(dbversion);
insuranceTypeRepository.SaveChanges();
}
public void Test_CalculatePremium_Boundries(InsuranceType insuranceType, DateTime currentDate, DateTime dob, decimal expected)
{
// Arrange
Driver driver = new Driver();
driver.DOB = dob;
driver.InsuranceType = insuranceType;
// Act
var actual = driver.CalculatePremium(currentDate);
// Assess
Assert.AreEqual(expected, actual);
}
private void SetInsuranceHolder_Checked(Account userAccount, int level, InsuranceType t, bool isStolen = false)
{
Try.Condition((userAccount.Role & AccountRole.Person) > 0,
$"Только персоны могут быть держателями страховки");
var oldIssuer = GetIssuerFromType(userAccount.Insurance);
var newIssuer = GetIssuerFromType(t);
if (!isStolen)
{
var price = (int)UserContext.Constants.GetInsuranceCost(t, level);
var priceOld = (int)UserContext.Constants.GetInsuranceCost(t, userAccount.InsuranceLevel);
if (userAccount.Insurance == t)
{
price = Math.Max(0, price - priceOld);
}
Try.Condition(newIssuer.InsurancePoints >= price, $"Не хватает очков страховки");
newIssuer.InsurancePoints -= price;
UserContext.Accounts.Update(newIssuer);
var txtverb = userAccount.Insurance == t ? "изменение" : "выдачу";
UserContext.AddGameEvent(newIssuer.Login, GameEventType.Index,
$"Потрачено {price} очков на {txtverb} страховки {userAccount.DisplayName}", true);
}
//Отменить старую страховку, если была
if (oldIssuer != null && userAccount.Insurance != t)
{
UserContext.AddGameEvent(oldIssuer.Login, GameEventType.Insurance,
$"{userAccount.DisplayName} отказался от вашей страховки", true);
UserContext.AddGameEvent(userAccount.Login, GameEventType.Insurance,
$"Вы отказались от страховки {t}", true);
}
userAccount.Insurance = t;
userAccount.InsuranceLevel = level;
UserContext.Accounts.Update(userAccount);
//if(!isStolen)
// UserContext.AddGameEvent(newIssuer.Login, GameEventType.Insurance,
// $"Выдана страховка {userAccount.DisplayName}" +
// $"уровня {userAccount.InsuranceLevel}");
UserContext.AddGameEvent(userAccount.Login, GameEventType.Insurance,
$"Выдана страховка {userAccount.Insurance} " +
$"уровня {userAccount.InsuranceLevel}", true);
UpdateInsuranceInAlice(userAccount);
}
public static IInsuranceFactory CreateFactory(InsuranceType insuranceType)
{
switch (insuranceType)
{
case InsuranceType.Immobilized:
return(new ImmobilizedFactory());
case InsuranceType.Mobilized:
return(new MobilizedFactory());
default:
throw new ArgumentOutOfRangeException();
}
}
public void Test_CalculateQuote(decimal vehicleValue, InsuranceType insuranceType, DateTime dob, int penaltyPoints, DateTime testDate, decimal expected)
{
// Arrange
Driver driver = new Driver();
driver.InsuranceType = insuranceType;
driver.VehicleValue = vehicleValue;
driver.DOB = dob;
driver.PenaltyPoints = penaltyPoints;
// Act
var actual = driver.CalculateQuote(testDate);
// Assess
Assert.AreEqual(expected, actual);
}
public async Task <IActionResult> OnGetAsync(Guid?id)
{
if (id == null)
{
return(NotFound());
}
InsuranceType = await _context.InsuranceTypes.FirstOrDefaultAsync(m => m.Id == id);
if (InsuranceType == null)
{
return(NotFound());
}
return(Page());
}
internal static string InsuranceDescription(InsuranceType tds)
{
switch (tds)
{
case InsuranceType.None:
return "Sem seguro";
case InsuranceType.Basic:
return "Seguro a todos os tipos de acidentes com cobertura extensível ao carro";
case InsuranceType.Person:
return "Seguro a todos os tipos de acidentes com cobertura extensível ao Passageiro";
case InsuranceType.Theft:
return "Seguro a roubo e furtos com cobertura extensível ao carro";
case InsuranceType.InnerTheft:
return "Seguro a roubo e furtos com cobertura extensível a peças do carro";
case InsuranceType.Headlights:
return "Seguro a danos à pintura, Farois, Vidros, Retrovisores e Pneus";
case InsuranceType.Assistance24x7:
return "Reboque 24hr por dia com deslocamento de até 100km incluso";
case InsuranceType.Complete:
return "Todos Seguros Juntos";
default:
return "Nenhum Contratado";
}
}
public void ImportFromExcel(string excelFileName, string dataSheet, InsuranceType insType, bool isCashFlow)
{
_rep.ImportFromExcel(excelFileName, dataSheet, insType, isCashFlow);
}
public PayPercent(InsuranceType type, double companyPayPercent, double personPayPercent)
{
this.InsuranceType = type;
this.CompanyPayPercent = companyPayPercent;
this.PersonPayPercent = personPayPercent;
}
public string PublicAssetProfitReport(DateTime db, DateTime de, InsuranceType insType, Guid? govId)
{
UriBuilder urib = new UriBuilder(_db.BaseUri);
urib.Path = string.Format("{0}/Report", _db.Assets.RequestUri.PathAndQuery);
return _db.Execute<string>(urib.Uri, "POST", true
, new System.Data.Services.Client.BodyOperationParameter("DateBegin", db)
, new System.Data.Services.Client.BodyOperationParameter("DateEnd", de)
, new System.Data.Services.Client.BodyOperationParameter("InsuranceType", (byte)insType)
, new System.Data.Services.Client.BodyOperationParameter("GovernorId", govId)
).FirstOrDefault();
}
public void ImportFromExcel(string excelFileName, string dataSheet, InsuranceType insType, bool isCashFlow)
{
var govs = _db.Entities
.Where(e => e.Identity.Contains(string.Format("{0}(guid'", _db.Governors.RequestUri.PathAndQuery)))
.Select(ed => ProxyActivator.CreateProxy<Governor, BLL.Governor>(ed.Entity as Governor)).ToList();
XlsObject<BLL.AssetValue> parser;
if (isCashFlow)
parser = new AssetsCashXlsObject(govs, insType, excelFileName, dataSheet);
else
parser = new AssetsValXlsObject(govs, insType, excelFileName, dataSheet);
var list = parser.SelectAll().Select(val => Newtonsoft.Json.JsonConvert.SerializeObject(val)).ToList();
UriBuilder urib = new UriBuilder(_db.BaseUri);
urib.Path = string.Format("{0}/CreateBatch", _db.Assets.RequestUri.PathAndQuery);
var r = _db.Execute<bool>(urib.Uri, "POST", true
, new System.Data.Services.Client.BodyOperationParameter("Values", list)
).FirstOrDefault();
if (!r)
throw new InvalidOperationException("ImportFromExcel");
}
