public void RemoveRisk(string nameOfInsuredObject, Risk risk, DateTime validTill, DateTime effectiveDate)
{
var policyId = IdGenerator.ConstructPolicyId(nameOfInsuredObject, effectiveDate);
var policyModel = _policyRepository.Get(policyId);
if (validTill.Date > policyModel.ValidTill.Date)
{
throw new RiskRemovalDateException();
}
var riskId = IdGenerator.ConstructRiskId(risk.Name, nameOfInsuredObject, effectiveDate);
var riskModel = _riskRepository.Get(riskId);
var updatedRiskModel = new RiskModel
{
Name = riskModel.Name,
ValidFrom = riskModel.ValidFrom,
PolicyEffectiveDate = riskModel.PolicyEffectiveDate,
PolicyId = riskModel.PolicyId,
Id = riskModel.Id,
ValidTill = validTill,
YearlyPrice = riskModel.YearlyPrice
};
_riskRepository.Edit(updatedRiskModel);
}
public async Task <IActionResult> Create([FromBody] RiskModel model)
{
var project = await _projectRepository.GetAsync(model.ProjectId);
if (project == null)
{
return(NotFound("Project not found"));
}
var riskStatus = await _riskStatusRepository.FindAsync(_ => _.Title == model.Status);
if (riskStatus == null)
{
return(NotFound("Risk Status not found"));
}
var risk = await _riskRepository
.AddAsyn(new Risk()
{
Title = model.Title,
Description = model.Description,
DateIdentified = model.DateIdentified,
MostLikelyEstimate = model.MostLikelyEstimate,
OptimisticEstimate = model.OptimisticEstimate,
PessimisticEstimate = model.PessimisticEstimate,
RiskStatus = riskStatus,
Project = project
})
.ConfigureAwait(false);
return(CreatedAtRoute("GetRisk", new { id = risk.Id }, risk));
}
public async Task <IActionResult> UpdateAsync(int id, [FromBody] RiskModel model)
{
if (model == null)
{
return(BadRequest());
}
var risk = await _riskRepository.GetAsync(id);
if (risk == null)
{
return(NotFound());
}
risk.Title = model.Title;
risk.Description = model.Description;
risk.DateIdentified = model.DateIdentified;
risk.MostLikelyEstimate = model.MostLikelyEstimate;
risk.OptimisticEstimate = model.OptimisticEstimate;
risk.PessimisticEstimate = model.PessimisticEstimate;
risk.RiskStatus = await _riskStatusRepository.FindAsync(_ => _.Title == model.Status);
risk.Project = await _projectRepository.FindAsync(_ => _.Id == model.ProjectId);
await _riskRepository.UpdateAsyn(risk, id);
return(new NoContentResult());
}
public async Task <IActionResult> Get(int id)
{
var riskModel = new RiskModel();
try
{
var risk = await _riskRepository.GetAsync(id).ConfigureAwait(false);
if (risk == null)
{
return(NotFound());
}
riskModel.Id = risk.Id;
riskModel.Title = risk.Title;
riskModel.Description = risk.Description;
riskModel.DateIdentified = risk.DateIdentified;
riskModel.MostLikelyEstimate = risk.MostLikelyEstimate;
riskModel.OptimisticEstimate = risk.OptimisticEstimate;
riskModel.PessimisticEstimate = risk.PessimisticEstimate;
riskModel.Status = risk.RiskStatus?.Title;
riskModel.ProjectId = risk.Project?.Id ?? 0;
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(Ok(riskModel));
}
public void RiskModel_GettersReturnCorrectValues()
{
const string name = "risk name";
DateTime validFrom = new DateTime(2020, 5, 5);
DateTime validTill = new DateTime(2020, 6, 6);
DateTime policyEffectiveDate = new DateTime(2020, 4, 4);
const string policyId = "policyId";
const string id = "id";
const decimal yearlyPrice = 10.0m;
var testRiskModel = new RiskModel()
{
Name = name,
ValidFrom = validFrom,
ValidTill = validTill,
PolicyEffectiveDate = policyEffectiveDate,
PolicyId = policyId,
Id = id,
YearlyPrice = yearlyPrice
};
Assert.AreEqual(name, testRiskModel.Name);
Assert.AreEqual(validFrom, testRiskModel.ValidFrom);
Assert.AreEqual(validTill, testRiskModel.ValidTill);
Assert.AreEqual(policyEffectiveDate, testRiskModel.PolicyEffectiveDate);
Assert.AreEqual(policyId, testRiskModel.PolicyId);
Assert.AreEqual(id, testRiskModel.Id);
Assert.AreEqual(yearlyPrice, testRiskModel.YearlyPrice);
}
public void AddRisk(string nameOfInsuredObject, Risk risk, DateTime validFrom, DateTime effectiveDate)
{
if (validFrom < effectiveDate)
{
throw new RiskValidityPeriodException();
}
var policyId = IdGenerator.ConstructPolicyId(nameOfInsuredObject, effectiveDate);
var policyModel = _policyRepository.Get(policyId);
if (validFrom > policyModel.ValidTill)
{
throw new RiskValidityPeriodException();
}
if (policyModel.InsuredRisks.Contains(risk))
{
throw new DuplicateRiskException(risk.Name);
}
var riskId = IdGenerator.ConstructRiskId(risk.Name, policyModel.NameOfInsuredObject, effectiveDate);
var riskModel = new RiskModel
{
Name = risk.Name,
ValidFrom = validFrom,
PolicyEffectiveDate = effectiveDate,
PolicyId = policyId,
Id = riskId,
ValidTill = policyModel.ValidTill,
YearlyPrice = risk.YearlyPrice
};
_riskRepository.Add(riskModel);
}
public void UpdateProjectRisk(RiskModel riskModel)
{
// Mapp to backend model
var risk = new ProjectRisk();
if (riskModel != null)
{
risk = ApplicationMapper.MapProjectRisk(riskModel);
}
// Create P.Risk
projectRepository.UpdateProjectRisk(risk);
}
public int CreateProjectRisk(RiskModel riskModel)
{
// Mapp to backend model
var risk = new ProjectRisk();
if (riskModel != null)
{
risk = ApplicationMapper.MapProjectRisk(riskModel);
}
// Create P.Risk
return(projectRepository.CreateProjectRisk(risk));
}
public void Risk_GettersReturnCorrectValues()
{
const string name = "risk name";
const decimal yearlyPrice = 20.0m;
var risk = new RiskModel()
{
Name = name,
YearlyPrice = yearlyPrice
};
Assert.AreEqual(name, risk.Name);
Assert.AreEqual(yearlyPrice, risk.YearlyPrice);
}
public static ProjectRisk MapProjectRisk(RiskModel riskModel)
{
var risk = new ProjectRisk
{
Id = riskModel.Id,
ProjectId = riskModel.ProjectId,
Name = riskModel.Name,
ProbabilityId = riskModel.ProbabilityId,
ConsequenceId = riskModel.ConsequenceId
};
//risk.Effect = riskModel.Effect;
return(risk);
}
public ActionResult Risks(int id)
{
var riskResults = from r in projectDb.Risks where r.ProjectID == id select r;
var levelResults = from l in projectDb.RiskLevels select l;
var statusResults = from s in projectDb.RiskStatus select s;
RiskModel model = new RiskModel()
{
Risks = riskResults.ToList(),
Levels = levelResults.ToList(),
Statuses = statusResults.ToList()
};
ViewBag.ProjectId = id;
return(View(model));
}
public RiskModel GetRisks()
{
RiskModel risk = null;
using (SqlConnection sqlConnection = new SqlConnection(connectionStringSQL))
{
sqlConnection.Open();
SqlCommand All_Check_Risk = new SqlCommand("All_Check_Risk", sqlConnection);
All_Check_Risk.CommandType = CommandType.StoredProcedure;
SqlDataReader sqlDataReader = All_Check_Risk.ExecuteReader();
while (sqlDataReader.Read())
{
risk = new RiskModel
{
OwnershipOrg = Convert.ToInt32(sqlDataReader["Ownership_Org"]),
TaxDebt = Convert.ToInt32(sqlDataReader["Tax_Debt"]),
DebtsEnforcementDocuments = Convert.ToInt32(sqlDataReader["Debts_Enforcement_Documents"]),
FalseBusiness = Convert.ToInt32(sqlDataReader["False_Business"]),
SpecialRisc = Convert.ToInt32(sqlDataReader["Special_Risc"]),
ExecuteProc = Convert.ToInt32(sqlDataReader["Execute_Proc"]),
BankruptcyProc = Convert.ToInt32(sqlDataReader["Bankruptcy_Proc"]),
LiquidationProc = Convert.ToInt32(sqlDataReader["Liquidation_Proc"]),
Resident = Convert.ToInt32(sqlDataReader["Resident"]),
BrokerClient = Convert.ToInt32(sqlDataReader["Broker_Client"]),
Tradingexperience = Convert.ToInt32(sqlDataReader["Trading_experience"]),
Manufacturer = Convert.ToInt32(sqlDataReader["Manufacturer"]),
ExchengeTradingDisorders = Convert.ToInt32(sqlDataReader["Exchenge_Trading_Disorders"]),
NegativData = Convert.ToInt32(sqlDataReader["Negativ_Data"]),
Reputation = Convert.ToInt32(sqlDataReader["Reputation"]),
PrevLiquidated = Convert.ToInt32(sqlDataReader["Prev_Liquidated"]),
PrevBankruptcy = Convert.ToInt32(sqlDataReader["Prev_Bankruptcy"]),
PrevStateDebt = Convert.ToInt32(sqlDataReader["Prev_State_Debt"]),
PrevTaxDebt = Convert.ToInt32(sqlDataReader["Prev_Tax_Debt"]),
PrevExecuteProc = Convert.ToInt32(sqlDataReader["Prev_Execute_Proc"]),
AgeOrg = Convert.ToInt32(sqlDataReader["Age_Org_Risk"]),
};
}
sqlConnection.Close();
}
return(risk ?? new RiskModel());// если риск NULL возвращаем пустую модель(чтобы не свалилось в случае чего)
}
public IPolicy SellPolicy(IPolicy policy)
{
var policyId = IdGenerator.ConstructPolicyId(policy.NameOfInsuredObject, policy.ValidFrom);
if (_policyRepository.Get(policyId) != null)
{
throw new DuplicatePolicyException(policy.NameOfInsuredObject, policy.ValidFrom);
}
var policyModel = new PolicyModel {
Id = policyId,
NameOfInsuredObject = policy.NameOfInsuredObject,
ValidFrom = policy.ValidFrom,
ValidTill = policy.ValidTill,
InsuredRisks = policy.InsuredRisks,
Premium = policy.Premium
};
foreach (var risk in policy.InsuredRisks)
{
var riskId = IdGenerator.ConstructRiskId(risk.Name, policy.NameOfInsuredObject, policy.ValidFrom);
var riskModel = new RiskModel
{
Name = risk.Name,
ValidFrom = policy.ValidFrom,
ValidTill = policy.ValidTill,
PolicyEffectiveDate = policy.ValidFrom,
PolicyId = policyId,
Id = riskId,
YearlyPrice = risk.YearlyPrice
};
_riskRepository.Add(riskModel);
}
_policyRepository.Add(policyModel);
return(policy);
}
private void btnSave_Click(object sender, EventArgs e)
{
try
{
if (checkValid())
{
RiskModel risk;
if (_isAdd)
{
risk = new RiskModel();
}
else
{
int ID = Convert.ToInt32(grvData.GetRowCellValue(grvData.FocusedRowHandle, "ID").ToString());
risk = RiskBO.Instance.FindByPK(ID) as RiskModel;
}
risk.Code = txtCode.Text;
risk.Description = txtDescription.Text;
if (_isAdd)
{
RiskBO.Instance.Insert(risk);
}
else
{
RiskBO.Instance.Update(risk);
}
SetInterface(false);
ClearInterface();
LoadRisk();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, TextUtils.Caption, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void Add(RiskModel riskModel)
{
FakeStorage.Instance.RiskList.Add(riskModel);
}
protected RiskFacade(RiskModel model) : base(model)
{
}
public void Edit(RiskModel model)
{
Remove(model.Id);
Add(model);
}
public void Add(RiskModel model)
{
_dataProvider.Add(model);
}
