// GET: Claims/Create
public async Task <IActionResult> Create(Guid productId, Guid clientId, Guid policyId, int riskId, Guid riskitemId)
{
Models.Claim claim = new Models.Claim
{
RiskID = riskId,
RiskItemID = riskitemId,
RegisterDate = DateTime.Now,
IncidentDate = DateTime.Now,
ReportDate = DateTime.Now
};
ClaimViewModel viewModel = new ClaimViewModel
{
ProductID = productId,
ClientID = clientId,
PolicyID = policyId,
Claim = claim,
ClaimClassList = new SelectList(await _context.ClaimClasses.AsNoTracking().ToListAsync(), "ID", "Name",
await _context.ClaimClasses.FirstOrDefaultAsync()),
ClaimStatusList = new SelectList(await _context.ClaimStatuses.AsNoTracking().ToListAsync(), "ID", "Name",
await _context.ClaimStatuses.FirstOrDefaultAsync()),
IncidentList = new SelectList(await _context.Incidents
.Where(i => i.RiskIncidents.Any(r => r.RiskID == riskId))
.AsNoTracking().ToListAsync(),
"ID", "Name", await _context.Incidents.FirstOrDefaultAsync()),
RegionList = new SelectList(await _context.Regions.AsNoTracking().ToListAsync(), "ID", "Name",
await _context.Regions.FirstOrDefaultAsync()),
ProvinceList = new SelectList(await _context.Provinces.OrderBy(n => n.Name).AsNoTracking().ToListAsync(), "ID", "Name",
await _context.Provinces.FirstOrDefaultAsync()),
CountryList = new SelectList(await _context.Countries.OrderBy(n => n.Name).AsNoTracking().ToListAsync(), "ID", "Name",
await _context.Countries.FirstOrDefaultAsync())
};
return(View(viewModel));
}
public async Task <bool> InsertAsync(AddClaimParameter claim)
{
if (claim == null)
{
throw new ArgumentNullException(nameof(claim));
}
using (var transaction = _context.Database.BeginTransaction())
{
try
{
var newClaim = new Models.Claim
{
Code = claim.Code,
IsIdentifier = false, //claim.IsIdentifier,
CreateDateTime = DateTime.UtcNow,
UpdateDateTime = DateTime.UtcNow
};
_context.Claims.Add(newClaim);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
catch (Exception ex)
{
_managerEventSource.Failure(ex);
transaction.Rollback();
return(false);
}
}
return(true);
}
public Task AddClaimAsync(ApplicationUser user, System.Security.Claims.Claim claim)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (claim == null)
{
throw new ArgumentNullException("claim");
}
var u = _unitOfWork.UserRepository.FindById(user.Id);
if (u == null)
{
throw new ArgumentException("ApplicationUser does not correspond to a User entity.", "user");
}
var c = new Models.Claim
{
ClaimType = claim.Type,
ClaimValue = claim.Value,
User = u
};
u.Claims.Add(c);
_unitOfWork.UserRepository.Update(u);
return(_unitOfWork.CommitAsync());
}
public async Task <IActionResult> Edit(ClaimViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
Models.Claim claim = new Models.Claim();
claim = viewModel.Claim;
_context.Update(claim);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClaimExists(viewModel.Claim.ClaimNumber))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index", new { policyId = viewModel.Claim.PolicyID }));
}
viewModel.ClaimClassList = new SelectList(_context.ClaimClasses, "ID", "Name", viewModel.Claim.ClaimClassID);
viewModel.ClaimStatusList = new SelectList(_context.ClaimStatuses, "ID", "Name", viewModel.Claim.ClaimStatusID);
viewModel.IncidentList = new SelectList(_context.Incidents, "ID", "Name", viewModel.Claim.IncidentID);
viewModel.RegionList = new SelectList(_context.Regions, "ID", "Name", viewModel.Claim.RegionID);
return(View(viewModel));
}
public async Task <bool> InsertAsync(Domains.Scope scope)
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
var record = new Models.Scope
{
Name = scope.Name,
Description = scope.Description,
IsDisplayedInConsent = scope.IsDisplayedInConsent,
IsExposed = scope.IsExposed,
IsOpenIdScope = scope.IsOpenIdScope,
Type = (Models.ScopeType)scope.Type,
ScopeClaims = new List <Models.ScopeClaim>(),
CreateDateTime = DateTime.UtcNow,
UpdateDateTime = DateTime.UtcNow
};
if (scope.Claims != null &&
scope.Claims.Any())
{
foreach (var type in scope.Claims)
{
var rec = _context.Claims.FirstOrDefault(c => c.Code == type);
if (rec == null)
{
rec = new Models.Claim {
Code = type
};
_context.Claims.Add(rec);
}
record.ScopeClaims.Add(new Models.ScopeClaim {
Claim = rec
});
}
}
_context.Scopes.Add(record);
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
catch (Exception ex)
{
_managerEventSource.Failure(ex);
transaction.Rollback();
return(false);
}
}
return(true);
}
public async Task <IActionResult> New(Models.Claim claim)
{
if (!ModelState.IsValid)
{
return(View(claim));
}
claim.ClaimValue = claim.ClaimValue.ToString();
_context.Claims.Add(claim);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create(ClaimViewModel viewModel)
{
if (ModelState.IsValid)
{
// Check if Claim Series has been set
int claimPrefix = GetClaimPrefix(viewModel.PolicyID, viewModel.Claim.RiskID);
if (claimPrefix > 0)
{
//Random rnd = new Random();
Models.Claim claim = viewModel.Claim;
var riskId = viewModel.Claim.RiskID;
claim.ClaimNumber = GetClaimNumber(claimPrefix);
claim.PolicyID = viewModel.PolicyID;
claim.ReserveInsuredRevised = claim.ReserveInsured;
claim.ReserveThirdPartyRevised = claim.ReserveThirdParty;
_context.Add(claim);
await _context.SaveChangesAsync();
var claimNumber = claim.ClaimNumber;
var myParams = new object[] { claimPrefix, claimNumber };
await _context.Database.ExecuteSqlCommandAsync(
"INSERT INTO ClaimNumberGenerator(ClaimPrefix, ClaimNumber) " +
"Values ({0}, {1})",
parameters : myParams);
Guid currentUserId = Guid.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
var riskclaimdocuments = _context.RiskClaimDocuments.Where(r => r.RiskID == riskId);
if (riskclaimdocuments.Count() > 0)
{
foreach (var r in riskclaimdocuments)
{
var claimParams = new object[] { Guid.NewGuid(), claim.ClaimNumber, r.ClaimDocumentID, null, DateTime.Now,
currentUserId, null, null };
await _context.Database.ExecuteSqlCommandAsync(
"INSERT INTO ClaimDocumentSubmit(ID, ClaimNumber, ClaimDocumentID, SubmitDate, " +
"DateAdded, AddedBy, DateModified, ModifiedBy) " +
"Values ({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})",
parameters : claimParams);
}
}
return(RedirectToAction("Index", new {
productId = viewModel.ProductID, clientId = viewModel.ClientID, policyid = viewModel.PolicyID
}));
}
else
{
ViewData["ErrorMessage"] = "Claim Number series not set";
viewModel.ClaimClassList = new SelectList(await _context.ClaimClasses.AsNoTracking().ToListAsync(), "ID", "Name", viewModel.Claim.ClaimClassID);
viewModel.ClaimStatusList = new SelectList(await _context.ClaimStatuses.AsNoTracking().ToListAsync(), "ID", "Name", viewModel.Claim.ClaimStatusID);
viewModel.IncidentList = new SelectList(await _context.Incidents
.Where(i => i.RiskIncidents.Any(r => r.RiskID == viewModel.Claim.RiskID))
.AsNoTracking().ToListAsync(),
"ID", "Name", viewModel.Claim.IncidentID);
viewModel.RegionList = new SelectList(await _context.Regions.AsNoTracking().ToListAsync(), "ID", "Name", viewModel.Claim.RegionID);
return(View(viewModel));
}
}
viewModel.ClaimClassList = new SelectList(await _context.ClaimClasses.AsNoTracking().ToListAsync(), "ID", "Name", viewModel.Claim.ClaimClassID);
viewModel.ClaimStatusList = new SelectList(await _context.ClaimStatuses.AsNoTracking().ToListAsync(), "ID", "Name", viewModel.Claim.ClaimStatusID);
viewModel.IncidentList = new SelectList(await _context.Incidents
.Where(i => i.RiskIncidents.Any(r => r.RiskID == viewModel.Claim.RiskID))
.AsNoTracking().ToListAsync(),
"ID", "Name", viewModel.Claim.IncidentID);
viewModel.RegionList = new SelectList(await _context.Regions.AsNoTracking().ToListAsync(), "ID", "Name", viewModel.Claim.RegionID);
return(View(viewModel));
}
private IEnumerable <Models.Claim> GetClaims()
{
if (importedData != null && importedData.Any())
{
var claimTable = importedData.FirstOrDefault(o => o.TableName.Equals(Constants.Claim));
var claims = new List <Models.Claim>();
if (claimTable != null)
{
foreach (DataRow row in claimTable.Rows)
{
try
{
var claim = new Models.Claim
{
KeyInternSchadenummer = row["KeyInternSchadenummer"].ToString(),
BackgroundNarrative = row["BackgroundNarrative"].ToString(),
CatastropheCode = row["CatastropheCode"].ToString(),
CatastropheDescription = row["CatastropheDescription"].ToString(),
ClaimCode = row["ClaimCode"].ToString(),
ClaimCountry = row["ClaimCountry"].ToString(),
ClaimDeniedIndicator = row["ClaimDeniedIndicator"].ToString(),
ClaimDescription = row["ClaimDescription"].ToString(),
ClaimDiary = row["ClaimDiary"].ToString(),
ClaimEventCode = row["ClaimEventCode"].ToString(),
ClaimEventDescription = row["ClaimEventDescription"].ToString(),
ClaimHandler = row["ClaimHandler"].ToString(),
ClaimHandlerCode = row["ClaimHandlerCode"].ToString(),
ClaimInsured = row["ClaimInsured"].ToString(),
ClaimLastModified = row["ClaimLastModified"].ToString(),
ClaimLeadIndicator =
(ClaimLeadIndicator)
Enum.Parse(typeof(ClaimLeadIndicator), row["ClaimLeadIndicator"].ToString()),
ClaimLocationState = row["ClaimLocationState"].ToString(),
ClaimOpenDate = row.ConvertToLong("ClaimOpenDate", Logger),
ClaimReference = row["ClaimReference"].ToString(),
ClaimReportDate = row.ConvertToLong("ClaimReportDate", Logger),
ClaimStatus = row["ClaimStatus"].ToString(),
ClaimYearOfAccount = row.ConvertToLong("ClaimYearOfAccount", Logger),
CloseDate = row.ConvertToLong("CloseDate", Logger),
CoverageNarrative = row["CoverageNarrative"].ToString(),
CoverholderWithClaimsAuthority = row["CoverholderWithClaimsAuthority"].ToString(),
DateOfDeclinature = row.ConvertToLong("DateOfDeclinature", Logger),
DateOfLoss = row.ConvertToLong("DateOfLoss", Logger),
GeographicalOriginOfTheClaim = row["GeographicalOriginOfTheClaim"].ToString(),
LineageReference = row["LineageReference"].ToString(),
LitigationCode = row["LitigationCode"].ToString(),
LitigationDescription = row["LitigationDescription"].ToString(),
MaximumPotentialLoss = row["MaximumPotentialLoss"].ToString(),
MaximumPotentialLossCurrency = row["MaximumPotentialLossCurrency"].ToString(),
MaximumPotentialLossPercentage = row["MaximumPotentialLossPercentage"].ToString(),
OriginalCurrencyCode = row["OriginalCurrencyCode"].ToString(),
PreviousClaimReference = row["PreviousClaimReference"].ToString(),
PreviousSourceSystem = row["PreviousSourceSystem"].ToString(),
PreviousSourceSystemDescription = row["PreviousSourceSystemDescription"].ToString(),
ReasonDeclined = row["ReasonDeclined"].ToString(),
ReserveNarrative = row["ReserveNarrative"].ToString(),
ServiceProviderReference = row["ServiceProviderReference"].ToString(),
SettlementCurrencyCode = row["SettlementCurrencyCode"].ToString(),
SubrogationSalvageIndicator = row["SubrogationSalvageIndicator"].ToString(),
TPAHandleIndicator = row["TPAHandleIndicator"].ToString(),
TacticsNarrative = row["TacticsNarrative"].ToString(),
TriageCode = row["TriageCode"].ToString(),
XCSClaimCode = row["XCSClaimCode"].ToString(),
XCSClaimRef = row["XCSClaimRef"].ToString(),
Policy = GetPolicyByClaimNumber(row["KeyInternSchadenummer"].ToString()),
Claimant = GetClaimantsByClaimNumber(row["KeyInternSchadenummer"].ToString()).ToArray()
};
claims.Add(claim);
}
catch (Exception ex)
{
Logger.Log(LogLevel.Error, ex,
$"While importing EDF claim Claimnumber - {row["KeyInternSchadenummer"]} : ");
}
}
}
if (claims.Any())
{
return(claims);
}
}
return(Enumerable.Empty <Models.Claim>());
}
public async Task <bool> UpdateAsync(Domains.Scope scope)
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
var connectedScope = await _context.Scopes
.Include(s => s.ScopeClaims)
.FirstOrDefaultAsync(c => c.Name == scope.Name)
.ConfigureAwait(false);
connectedScope.Description = scope.Description;
connectedScope.IsOpenIdScope = scope.IsOpenIdScope;
connectedScope.IsDisplayedInConsent = scope.IsDisplayedInConsent;
connectedScope.IsExposed = scope.IsExposed;
connectedScope.Type = (Models.ScopeType)scope.Type;
var scopesNotToBeRemoved = new List <string>();
if (scope.Claims != null &&
scope.Claims.Any())
{
foreach (var type in scope.Claims)
{
var rec = _context.Claims.FirstOrDefault(c => c.Code == type);
var scopeClaims = connectedScope.ScopeClaims.FirstOrDefault(c => c.ClaimCode == type);
if (rec == null)
{
rec = new Models.Claim {
Code = type
};
_context.Claims.Add(rec);
}
if (scopeClaims == null)
{
connectedScope.ScopeClaims.Add(new Models.ScopeClaim
{
ClaimCode = rec.Code,
ScopeName = connectedScope.Name
});
}
scopesNotToBeRemoved.Add(type);
}
}
foreach (var scopeClaim in connectedScope.ScopeClaims.Where(s => !scopesNotToBeRemoved.Any(c => c == s.ClaimCode)).ToList())
{
_context.ScopeClaims.Remove(scopeClaim);
}
await _context.SaveChangesAsync().ConfigureAwait(false);
transaction.Commit();
}
catch (Exception ex)
{
_managerEventSource.Failure(ex);
transaction.Rollback();
return(false);
}
return(true);
}
}
