public async Task <long> InsertSanctionInfo(SanctionInfo data)
{
var caseParam = new DynamicParameters();
caseParam.Add("@Type", data.Type);
caseParam.Add("@Sanction", data.Sanction);
caseParam.Add("@Value", data.Value);
caseParam.Add("@CaseID", data.CaseID);
caseParam.Add("@Out", dbType: DbType.Int64, direction: ParameterDirection.Output);
await SqlMapper.ExecuteAsync(_unitOfWork.Connection,
"InsertSanctionInfo",
caseParam,
commandType : CommandType.StoredProcedure,
transaction : _unitOfWork.Transaction);
var caseID = caseParam.Get <long>("@Out");
return(caseID);
}
public async Task <long> Invoke(IUnitOfWork unitOfWork)
{
var dbContext = DbContext.From(unitOfWork);
unitOfWork.BeginTransaction();
var @case = await dbContext.Case.GetBasicByID(_caseID);
@case.Status = CaseStatus.PendingFOC;
@case.Sanction = Sanction.ImmediateSuspension;
@case.SuspendedFrom = DateTime.UtcNow;
await dbContext.Case.UpdateCaseInfo(@case);
var sanction = new SanctionInfo
{
CaseID = _caseID,
Sanction = Sanction.ImmediateSuspension,
Type = SanctionInfoType.Recommended
};
sanction.ID = await dbContext.Sanction.InsertSanctionInfo(sanction);
await dbContext.Case.MapCaseSanctionInfo(_caseID, sanction.ID);
var certificates = await dbContext.Certificate.GetCertificate(_caseID);
foreach (var certificate in certificates)
{
var certOldStatus = certificate.Status;
certificate.Status = CertificateStatus.Suspended;
certificate.SuspendedUntil = @case.SuspendedFrom.Value.AddMonths(Int32.Parse(_data.Months));
await dbContext.Certificate.UpdateCertificate(certificate);
_eventBus.Publish(new OnCertificateStatusChangedEvent
{
NewStatus = CertificateStatus.Suspended,
OldStatus = certOldStatus,
Number = certificate.Number
});
}
var action = await dbContext.Translation.GetTranslation(Locale.EN, "CaseImmediateSuspension");
var _activityID = await dbContext.Activity.InsertActivity(new Activity
{
Action = action,
User = _user,
Notes = _data.Notes
}, _caseID);
if (_data.Attachments?.Any() ?? false)
{
foreach (var attachment in _data.Attachments)
{
attachment.ID = await dbContext.Attachment.InsertAttachment(attachment);
}
await dbContext.Activity.MapActivityAttachments(
_activityID,
_data.Attachments.Select(e => e.ID).ToArray());
}
unitOfWork.Commit();
return(_activityID);
}
public Model.Case Map(Model.Case @case,
Offender offender = null,
ContactInfo offenderContact = null,
Officer managedBy = null,
Officer assignedTo = null,
Person reportedBy = null,
ContactInfo reporterContact = null,
Master breachCategories = null,
Master offences = null,
Attachment attachment = null,
Certificate certificate = null,
Premise premise = null,
SanctionInfo sanctionInfo = null)
{
if (!dict.TryGetValue(@case.ID, out Model.Case result))
{
dict[@case.ID] = @case;
_contactInfoCache.Clear();
_breachCategoriesCache.Clear();
_offencesCache.Clear();
_attachmentCache.Clear();
_certificatesCache.Clear();
_premiseCache.Clear();
_sanctionInfoCache.Clear();
_activityCache.Clear();
_offenderContactInfoCache.Clear();
if (!string.IsNullOrEmpty(offender?.Name))
{
@case.Offender = offender;
}
if (!string.IsNullOrEmpty(managedBy?.Name))
{
@case.ManagedBy = managedBy;
}
if (!string.IsNullOrEmpty(assignedTo?.Name))
{
@case.AssignedTo = assignedTo;
}
if (!string.IsNullOrEmpty(reportedBy?.Name))
{
@case.ReportedBy = reportedBy;
}
result = @case;
}
if ((reporterContact?.ID ?? 0) > 0 &&
!_contactInfoCache.ContainsKey(reporterContact.ID))
{
_contactInfoCache[reporterContact.ID] = reporterContact;
if (result.ReportedBy.ContactInfos == null)
{
result.ReportedBy.ContactInfos = new List <ContactInfo>();
}
result.ReportedBy.ContactInfos.Add(reporterContact);
}
if ((offenderContact?.ID ?? 0) > 0 &&
!_offenderContactInfoCache.ContainsKey(offenderContact.ID))
{
_offenderContactInfoCache[offenderContact.ID] = offenderContact;
if (result.Offender.ContactInfos == null)
{
result.Offender.ContactInfos = new List <ContactInfo>();
}
result.Offender.ContactInfos.Add(offenderContact);
}
if ((breachCategories?.ID ?? Guid.Empty) != Guid.Empty &&
!_breachCategoriesCache.ContainsKey(breachCategories.ID))
{
_breachCategoriesCache[breachCategories.ID] = breachCategories;
if (result.BreachCategories == null)
{
result.BreachCategories = new List <Master>();
}
result.BreachCategories.Add(breachCategories);
}
if ((offences?.ID ?? Guid.Empty) != Guid.Empty &&
!_offencesCache.ContainsKey(offences.ID))
{
_offencesCache[offences.ID] = offences;
if (result.Offences == null)
{
result.Offences = new List <Master>();
}
result.Offences.Add(offences);
}
if ((attachment?.ID ?? 0) > 0 &&
!_attachmentCache.ContainsKey(attachment.ID))
{
_attachmentCache[attachment.ID] = attachment;
if (result.Attachments == null)
{
result.Attachments = new List <Attachment>();
}
result.Attachments.Add(attachment);
}
if ((certificate?.ID ?? 0) > 0 &&
!_certificatesCache.ContainsKey(certificate.ID))
{
_certificatesCache[certificate.ID] = certificate;
if (result.Certificates == null)
{
result.Certificates = new List <Certificate>();
}
result.Certificates.Add(certificate);
}
if ((premise?.ID ?? 0) > 0 &&
!_premiseCache.ContainsKey(premise.ID))
{
_premiseCache[premise.ID] = premise;
if (result.Premises == null)
{
result.Premises = new List <Premise>();
}
result.Premises.Add(premise);
}
if ((sanctionInfo?.ID ?? 0) > 0 &&
!_sanctionInfoCache.ContainsKey(sanctionInfo.ID))
{
_sanctionInfoCache[sanctionInfo.ID] = sanctionInfo;
if (result.SanctionInfos == null)
{
result.SanctionInfos = new List <SanctionInfo>();
}
result.SanctionInfos.Add(sanctionInfo);
}
return(result);
}
