public PolicyVersion
(
Guid id,
int versionNumber,
ValidityPeriod versionValidityPeriod,
PolicyStatus policyStatus,
ValidityPeriod coverPeriod,
Person policyHolder,
Person driver,
Car car,
Money totalPremium,
IEnumerable <CoverPrice> coverPrices
)
{
Id = id;
VersionNumber = versionNumber;
BaseVersionNumber = null;
VersionStatus = PolicyVersionStatus.Draft;
VersionValidityPeriod = versionValidityPeriod;
PolicyStatus = policyStatus;
CoverPeriod = coverPeriod;
PolicyHolder = policyHolder;
Driver = driver;
Car = car;
TotalPremium = totalPremium; //TODO: check against covers?
foreach (var coverPrice in coverPrices)
{
AddCover(coverPrice, versionValidityPeriod.ValidFrom, versionValidityPeriod.ValidTo);
}
}
public PolicyStatus GetPolicyStatus(ProjectVersionView projectVersionView)
{
VersionBomPolicyStatusView policyView = GetVersionBomPolicyStatusView(projectVersionView);
PolicyStatus policyStatus = new PolicyStatus(policyView);
return(policyStatus);
}
public async Task <IActionResult> Edit(Guid id, [Bind("ID,IsUpdatable,Name")] PolicyStatus policyStatus)
{
if (id != policyStatus.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(policyStatus);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PolicyStatusExists(policyStatus.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
return(View(policyStatus));
}
public void ExecuteTask()
{
if (IsExcluded())
{
Log.LogMessage("Project {0} excluded from task", HubProjectName);
}
else
{
// Creates output directory if it doesn't already exist
Directory.CreateDirectory(OutputDirectory);
// Define output files
string bdioFilePath = $"{OutputDirectory}/{HubProjectName}.jsonld";
string flatListFilePath = $"{OutputDirectory}/{HubProjectName}_flat.txt";
// Execute task functionality
if (CreateFlatDependencyList)
{
string[] externalIds = CreateFlatList().ToArray();
File.WriteAllLines(flatListFilePath, externalIds, Encoding.UTF8);
}
if (CreateHubBdio)
{
BdioContent bdioContent = BuildBOM();
File.WriteAllText(bdioFilePath, bdioContent.ToString());
}
if (DeployHubBdio)
{
string bdio = File.ReadAllText(bdioFilePath);
BdioContent bdioContent = BdioContent.Parse(bdio);
DeployBdioDataService.Deploy(bdioContent);
}
// Only wait for scan if we have to
if (DeployHubBdio && (CheckPolicies || CreateHubBdio || WaitForDeployment))
{
WaitForHub();
}
if (CreateHubReport)
{
ProjectView projectView = ProjectDataService.GetProjectView(HubProjectName);
ProjectVersionView projectVersionView = ProjectDataService.GetMostRecentVersion(projectView);
ReportData reportData = RiskReportDataService.GetReportData(projectView, projectVersionView);
RiskReportDataService.WriteToRiskReport(reportData, OutputDirectory);
}
if (CheckPolicies)
{
PolicyStatus policyStatus = new PolicyStatus(GetPolicies());
LogPolicyViolations(policyStatus);
}
}
}
private void AddPolicyStatuses(DataContext context)
{
foreach (var item in PolicyStatusList)
{
var policyStatus = new PolicyStatus {
Name = item
};
context.PolicyStatuses.Add(policyStatus);
}
}
/// <summary>
///
/// </summary>
/// <param name="status"></param>
/// <returns></returns>
public static string GetRuleStatus(PolicyStatus status)
{
switch (status)
{
case PolicyStatus.Active: return "active";
case PolicyStatus.Disabled: return "disabled";
case PolicyStatus.UnderTest: return "undertest";
default: return string.Empty;
}
}
public async Task <IActionResult> Create([Bind("ID,IsUpdatable,Name")] PolicyStatus policyStatus)
{
if (ModelState.IsValid)
{
policyStatus.ID = Guid.NewGuid();
_context.Add(policyStatus);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(policyStatus));
}
public PolicyVersion(
int versionNumber,
PolicyStatus policyStatus,
PolicyVersionStatus versionStatus,
ValidityPeriod coverPeriod,
ValidityPeriod versionPeriod,
IEnumerable <PolicyCover> policyCovers)
{
VersionNumber = versionNumber;
PolicyStatus = policyStatus;
VersionStatus = versionStatus;
CoverPeriod = coverPeriod;
VersionPeriod = versionPeriod;
covers.AddRange(policyCovers);
}
public CataloguePolicy(CataloguePolicy rhs, bool readOnly, bool createNewId)
: base(rhs, readOnly, createNewId)
{
if (null == rhs)
{
Utilities.ErrorMessage errorMessage = new Utilities.ErrorMessage(
"INPUT_POLICY_NULL",
"Workshare.Policy.Properties.Resources",
Assembly.GetExecutingAssembly());
Logger.LogError(errorMessage.LogString);
throw new Workshare.Policy.Exceptions.ArgumentNullException("rhs", errorMessage.DisplayString);
}
m_status = rhs.Status;
}
/// <summary>
/// Creates a new policy object with default AuditLevel and ConditionGroup values. The IPolicy
/// is created with a new GUID.
/// </summary>
/// <param name="policyName">The name of the policy</param>
/// <param name="policySet">The policy set to which this policy belongs</param>
/// <param name="policyStatus">The status of the policy</param>
/// <param name="auditLevel">The audit level of the policy</param>
/// <returns>The IPolicy object</returns>
public static IPolicy CreatePolicy(string policyName, IPolicySet policySet, PolicyStatus policyStatus, string auditLevel)
{
IPolicy policy = new P5Policy(policySet, System.Guid.NewGuid(), new TranslateableLanguageItem(policyName), policyStatus);
policy["AuditLevel"] = new NonTranslateableLanguageItem(auditLevel);
policy["blockOnException"] = new NonTranslateableLanguageItem(bool.TrueString);
policy[PolicyConstants.SkipVerifiedMessages] = new NonTranslateableLanguageItem(bool.FalseString);
//create root condition group on the policy
ChannelType[] channelTypes = PolicyTypeInfoManager.Instance.GetInfo(policySet.PolicyType).ChannelTypes;
IPolicyChannel[] channels = ChannelFactory.CreateChannels(channelTypes);
policy.Conditions.Add(new ConditionGroup(Guid.NewGuid(), new TranslateableLanguageItem("Default Condition Group"), ConditionLogic.AND, false));
foreach (IPolicyChannel channel in channels)
{
policy.Channels.Add(channel);
}
return policy;
}
public void LogPolicyViolations(PolicyStatus policyStatus)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("The Hub found: ");
stringBuilder.Append(policyStatus.InViolationCount);
stringBuilder.Append(" components in violation, ");
stringBuilder.Append(policyStatus.InViolationCount);
stringBuilder.Append(" components in violation, but overridden, and ");
stringBuilder.Append(policyStatus.NotInViolationCount);
stringBuilder.Append(" components not in violation.");
if (PolicyStatusEnum.IN_VIOLATION.Equals(policyStatus.OverallStatus))
{
string error = $"The Hub found: {policyStatus.InViolationCount} components in violation\n";
throw new BlackDuckIntegrationException(error);
}
}
public void UpdatePolicyStatus(string policyId, PolicyStatus status)
{
var query = @"UPDATE `aigang.insurance`.policy
SET ModifiedUtc = @Now, Status = @Status
WHERE Id = @PolicyId;";
var now = DateTime.UtcNow;
using (IDbConnection dbConnection = Connection)
{
dbConnection.Open();
dbConnection.Execute(query, new
{
Now = now,
Status = status,
PolicyId = policyId
});
}
}
public IHttpActionResult ViewAll(PolicyStatus status, int offset = 0, int count = 10, string q = null)
{
using (IUnitOfWork unitOfWork = UnitOfWork.Create())
{
var userId = User.Identity.GetUserId();
IQueryable <Policy> query = unitOfWork.PolicyRepository.GetAll();
if (status != PolicyStatus.None)
{
query = query.Where(a => a.Status == status);
}
if (!string.IsNullOrEmpty(q))
{
query = query.Where(e =>
e.PolicyNumber == q ||
e.CreatedBy.FirstName.StartsWith(q) ||
e.CreatedBy.LastName.StartsWith(q) ||
e.CreatedBy.Email == q);
}
var countOfUsers = query.Count();
var policyList = query
.OrderByDescending(a => a.CreatedDate)
.Skip(offset)
.Take(count)
.ToList()
.Select(a => new
{
id = a.Id,
status = a.Status,
policyNumber = a.PolicyNumber,
insurer = a.Insurer == null ? null : new
{
name = a.Insurer.Name
},
//fileNames = a.PolicyFiles.Where(f => f.Status != FileStatus.deleted).Select(f => f.File.FileName),
createdDate = a.CreatedDate,
createdBy = new
{
id = a.CreatedBy.Id,
firstName = a.CreatedBy.FirstName,
lastName = a.CreatedBy.LastName,
email = a.CreatedBy.Email
}
}).ToList();
//foreach (var policy in policyList)
//{
// policy.fileNames.ToList();
//}
var result = new
{
count = countOfUsers,
data = policyList
};
return(Json(result));
}
}
public IHttpActionResult List(PolicyStatus status = PolicyStatus.None, PolicySortType sortType = PolicySortType.All, int offset = 0, int count = 10, string groupName = null, string q = null)
{
using (IUnitOfWork unitOfWork = UnitOfWork.Create())
{
var userId = User.Identity.GetUserId();
var startLinkToLogo = Url.Link("Default", new { controller = "files", action = "getLogo" });
IQueryable <Policy> query = unitOfWork.PolicyRepository.GetAll()
.Where(a => a.CreatedById == userId && a.Status != PolicyStatus.Hidden);
if (!string.IsNullOrEmpty(groupName))
{
query = query.Where(e =>
e.PolicyType != null && e.PolicyType.PolicyGroup.Name == groupName);
}
if (status != PolicyStatus.None)
{
query = query.Where(a => a.Status == status);
}
if (!string.IsNullOrEmpty(q))
{
query = query.Where(e =>
e.PolicyNumber == q);
}
if (sortType == PolicySortType.Active)
{
query = query.Where(a => a.Status == PolicyStatus.Unconfirmed || a.EndDate > DateTime.Now);
}
else if (sortType == PolicySortType.Expired)
{
query = query.Where(a => a.EndDate < DateTime.Now);
}
var countOfUsers = query.Count();
var countOfProcessing = query.Where(a => a.Status == PolicyStatus.Unconfirmed).Count();
var policyList = query
.OrderByDescending(a => a.CreatedDate)
.Skip(offset)
.Take(count)
.ToList()
.Select(a => new
{
id = a.Id,
status = a.Status,
title = a.Title,
subTitle = a.SubTitle,
prePolicyType = a.PrePolicyType,
policyPaymentAmount = a.PolicyPaymentAmount,
policyPaymentFrequency = a.PolicyPaymentFrequency,
policyTotalPremiumAmount = a.PolicyPremium,
policyNumber = a.PolicyNumber,
endDate = a.EndDate,
fileNames = a.PolicyFiles.Where(f => f.Status != FileStatus.deleted).Select(f => f.File.FileName),
lifeInsurancePremiumType = a.PolicyPolicyProperties.Where(f => f.PolicyProperty.Status != FieldStatus.Deleted && f.PolicyProperty.FieldName == "Life Insurance Premium Type")
.Select(f => new
{
value = f.Value
}).FirstOrDefault(),
policyGroup = a.PolicyType == null ? null : new
{
groupName = a.PolicyType.PolicyGroup.Name,
policyType = a.PolicyType.PolicyTypeName,
policyTemplate = a.PolicyType.PolicyTemplate.Name,
},
insurer = a.Insurer == null ? null : new
{
name = a.Insurer.Name,
color = a.Insurer.Color,
logoUrl = string.Concat(startLinkToLogo, "?id=", a.Insurer.LogoFileId),
description = a.Insurer.Description
},
createdDate = a.CreatedDate,
createdBy = new
{
id = a.CreatedBy.Id,
firstName = a.CreatedBy.FirstName,
lastName = a.CreatedBy.LastName,
email = a.CreatedBy.Email
},
}).ToList();
foreach (var policy in policyList)
{
policy.fileNames.ToList();
}
var result = new
{
count = countOfUsers,
countOfProcessing = countOfProcessing,
data = policyList
};
return(Json(result));
}
}
public CataloguePolicy(ICataloguePolicy rhs, bool readOnly)
: base(rhs, readOnly, false)
{
m_status = rhs.Status;
}
/// <summary>
/// Constructs a new Rule object as a NEW object
/// </summary>
/// <param name="name"></param>
/// <param name="status"></param>
public CataloguePolicy(Guid guid, IPolicyLanguageItem name, PolicyStatus status, bool readOnly)
: base(guid, name, readOnly)
{
m_status = status;
}
/// <summary>
/// Constructs a new Rule object as a NEW object
/// </summary>
/// <param name="name"></param>
/// <param name="status"></param>
public CataloguePolicy(Guid guid, IPolicyLanguageItem name, PolicyStatus status)
: base(guid, name)
{
m_status = status;
}
