private async Task RecursiveInsertFascicleFoldersAsync(Fascicle fascicle, FascicleFolder parent,
IEnumerable <FascicleFolder> fascicleFolders, IEnumerable <FascicleFolder> foldersToEvaluate)
{
if (foldersToEvaluate == null || !foldersToEvaluate.Any())
{
return;
}
FascicleFolder fascicleNode;
foreach (FascicleFolder folder in foldersToEvaluate)
{
fascicleNode = new FascicleFolder
{
UniqueId = Guid.NewGuid(),
Fascicle = fascicle,
Name = folder.Name,
Category = folder.Category,
Status = FascicleFolderStatus.Active,
Typology = FascicleFolderTypology.SubFascicle,
ParentInsertId = parent.UniqueId
};
_unitOfWork.Repository <FascicleFolder>().Insert(fascicleNode);
await _unitOfWork.SaveChangesAsync();
await RecursiveInsertFascicleFoldersAsync(fascicle, fascicleNode, fascicleFolders,
fascicleFolders.Where(f => f.ParentInsertId.HasValue && f.ParentInsertId.Value == folder.UniqueId));
}
}
/// <summary>
/// protocol cat = faccicle cat || protocol cat contine fasscicle cat
/// </summary>
/// <param name="objectToValidate"></param>
protected override void ValidateObject(FascicleDocumentUnitValidator objectToValidate)
{
if (objectToValidate.ReferenceType != ReferenceType.Fascicle)
{
return;
}
bool result = false;
FascicleFolder fascicleFolder = objectToValidate.FascicleFolder == null ? null : CurrentUnitOfWork.Repository <FascicleFolder>().GetByFolderId(objectToValidate.FascicleFolder.UniqueId);
DocumentUnit documentUnit = objectToValidate.DocumentUnit == null ? null : CurrentUnitOfWork.Repository <DocumentUnit>().GetById(objectToValidate.DocumentUnit.UniqueId).FirstOrDefault();
Fascicle fascicle = objectToValidate.Fascicle == null ? null : CurrentUnitOfWork.Repository <Fascicle>().GetByUniqueId(objectToValidate.Fascicle.UniqueId);
ICollection <CategoryFascicleTableValuedModel> categoryFascicles = CurrentUnitOfWork.Repository <CategoryFascicle>().GetCategorySubFascicles(fascicle.Category.EntityShortId);
if (documentUnit != null && documentUnit.Category != null && fascicle != null && fascicle.Category != null &&
(documentUnit.Category.UniqueId == fascicle.Category.UniqueId || (categoryFascicles.Any() && categoryFascicles.Any(c => c.IdCategory == documentUnit.Category.EntityShortId))))
{
result = true;
}
if (!result)
{
GenerateInvalidateResult();
}
}
public IHttpActionResult GetFascicleSummary(Guid uniqueId)
{
return(ActionHelper.TryCatchWithLoggerGeneric(() =>
{
Fascicle fascicle = _unitOfWork.Repository <Fascicle>().GetByUniqueId(uniqueId);
if (fascicle == null)
{
throw new ArgumentNullException("Fascicle not found");
}
FascicleModel model = _mapper.Map <Fascicle, FascicleModel>(fascicle);
ICollection <PrivateCommonModels.ContactTableValuedModel> contacts = _unitOfWork.Repository <Fascicle>().GetContacts(fascicle);
List <FascicleContactModel> contactModels = _mapper.Map <ICollection <PrivateCommonModels.ContactTableValuedModel>, ICollection <FascicleContactModel> >(contacts).ToList();
model.Contacts = contactModels;
FascicleFolder internetFolder = _unitOfWork.Repository <FascicleFolder>().GetInternetFolderByFascicle(uniqueId).SingleOrDefault();
if (internetFolder != null)
{
ICollection <DocumentUnitTableValuedModel> documentUnits = _unitOfWork.Repository <DocumentUnit>().GetFascicleDocumentUnitsPrivate(fascicle, internetFolder.UniqueId, Guid.Empty);
ICollection <GenericDocumentUnitModel> genericDocumentUnits = _mapper.Map <ICollection <DocumentUnitTableValuedModel>, ICollection <GenericDocumentUnitModel> >(documentUnits).ToList();
model.DocumentUnits = genericDocumentUnits;
}
return Ok(new List <FascicleModel>()
{
model
}.AsQueryable());
}, _logger, LogCategories));
}
public async Task <IHttpActionResult> GetFascicleFlatDocuments(Guid uniqueId)
{
return(await ActionHelper.TryCatchWithLoggerGeneric(async() =>
{
FascicleFolder internetFolder = _unitOfWork.Repository <FascicleFolder>().GetInternetFolderByFascicle(uniqueId).SingleOrDefault();
if (internetFolder == null)
{
return Ok(new List <FascicleModel>()
{
}.AsQueryable());
}
ICollection <FascicleDocument> miscellaneas = _unitOfWork.Repository <FascicleDocument>().GetByIdFascicleFolder(internetFolder.UniqueId, true).ToList();
ICollection <FascicleDocumentUnit> documentUnits = _unitOfWork.Repository <FascicleDocumentUnit>().GetByIdFascicleFolder(internetFolder.UniqueId, true).ToList();
ICollection <DocumentUnitChain> documentUnitChains = documentUnits.SelectMany(s => _unitOfWork.Repository <DocumentUnitChain>().GetByDocumentUnit(s.DocumentUnit, true)).ToList();
ICollection <Guid> chains = miscellaneas.Select(s => s.IdArchiveChain).Union(documentUnitChains.Select(s => s.IdArchiveChain)).ToList();
FascicleModel model = _mapper.Map <Fascicle, FascicleModel>(internetFolder.Fascicle);
IList <DocumentModel> documents = new List <DocumentModel>();
ICollection <ModelDocument.Document> biblosDocuments;
foreach (Guid archiveChain in chains)
{
biblosDocuments = await _documentService.GetDocumentsFromChainAsync(archiveChain);
foreach (ModelDocument.Document biblosDocument in biblosDocuments)
{
documents.Add(new DocumentModel(biblosDocument.IdDocument, biblosDocument.Name)
{
DocumentType = DocumentType.Miscellanea,
ChainId = biblosDocument.IdChain.Value
});
}
}
model.Documents = documents;
return Ok(new List <FascicleModel>()
{
model
}.AsQueryable());
}, _logger, LogCategories));
}
private async Task ValidateWorkflowRules(Guid fascicleId, List <ValidationMessageModel> errorResult, ICollection <WorkflowRule> deserializedWorkflowRules)
{
foreach (WorkflowRule workflowRule in deserializedWorkflowRules)
{
WorkflowRule wfRule = workflowRule;
FascicleFolder fascicleFolder = _unitOfWork.Repository <FascicleFolder>().GetByIdFascicleAndLevel(fascicleId, 2).FirstOrDefault();
bool isExist = _unitOfWork.Repository <FascicleFolder>().NameAlreadyExists(wfRule.Name, fascicleFolder.UniqueId, fascicleId);
if (isExist == false)
{
errorResult.Add(new ValidationMessageModel
{
Key = "WorkflowStart",
Message = $"Non esiste cartella di fascicolo {wfRule.Name}"
});
}
ValidateWorkflowRules(wfRule.HasFile, errorResult,
$"Convalida del nome {EnumHelper.GetDescription(WorkflowValidationRulesType.HasFile)} non è selezionata per { wfRule.Name}",
$"Non c'è valore per {wfRule.Name} - {EnumHelper.GetDescription(WorkflowValidationRulesType.HasFile)} la convalida {wfRule.HasFile}",
_unitOfWork.Repository <FascicleDocument>().HasFascicleDocument(wfRule.Name, fascicleId));
ValidateWorkflowRules(wfRule.HasDocumentUnit, errorResult,
$"Convalida del nome {EnumHelper.GetDescription(WorkflowValidationRulesType.HasDocumentUnit)} non è selezionata per { wfRule.Name}",
$"Non c'è valore per {wfRule.Name} - {EnumHelper.GetDescription(WorkflowValidationRulesType.HasDocumentUnit)} la convalida {wfRule.HasDocumentUnit}",
_unitOfWork.Repository <FascicleDocumentUnit>().HasFascicleDocumentUnit(wfRule.Name, fascicleId));
List <FascicleDocument> fascicleDocuments = _unitOfWork.Repository <FascicleDocument>().HasFascicleDocumentSigned(wfRule.Name, fascicleId, true).ToList();
bool hasSignedFile = await _documentService.IsDocumentsSignedAsync(fascicleDocuments.Select(x => x.UniqueId).ToList());
ValidateWorkflowRules(wfRule.HasSignedFile, errorResult,
$"Convalida del nome {EnumHelper.GetDescription(WorkflowValidationRulesType.HasSignedFile)} non è selezionata per { wfRule.Name}",
$"Non c'è valore per {wfRule.Name} - {EnumHelper.GetDescription(WorkflowValidationRulesType.HasSignedFile)} la convalida {wfRule.HasSignedFile}", hasSignedFile);
}
if (errorResult.Count() > 0)
{
throw new DSWValidationException("Evaluate start workflow validation error", errorResult, null, DSWExceptionCode.VA_RulesetValidation);
}
}
protected override void AfterSave(Fascicle entity)
{
try
{
_logger.WriteDebug(new LogMessage($"VecompSoftware.DocSuite.Private.WebAPI.Controllers.Entity.Fascicles.AfterSave with entity UniqueId {entity.UniqueId}"), LogCategories);
if (CurrentDeleteActionType.HasValue && CurrentDeleteActionType == DeleteActionType.CancelFascicle)
{
IQueryable <FascicleDocumentUnit> documentUnits = _unitOfWork.Repository <FascicleDocumentUnit>().GetByFascicle(entity.UniqueId);
ServiceBusMessage message;
foreach (FascicleDocumentUnit item in documentUnits)
{
if (item.DocumentUnit.Environment == (int)DSWEnvironmentType.Protocol)
{
Protocol protocol = _unitOfWork.Repository <Protocol>().GetByUniqueId(item.DocumentUnit.UniqueId).Single();
message = GenerateMessage(item.DocumentUnit.Category, (int)DSWEnvironmentType.Protocol,
(categoryFascicle) => new CommandUpdateProtocol(_parameterEnvService.CurrentTenantName, _parameterEnvService.CurrentTenantId, item.DocumentUnit.TenantAOO.UniqueId, null, null, null,
new IdentityContext(_currentIdentity.FullUserName), protocol, categoryFascicle, null));
Task.Run(async() =>
{
await _queueService.SubscribeQueue(message.ChannelName).SendToQueueAsync(message);
}).Wait();
}
if (item.DocumentUnit.Environment == (int)DSWEnvironmentType.Resolution)
{
Resolution resolution = _unitOfWork.Repository <Resolution>().GetByUniqueId(item.DocumentUnit.UniqueId).Single();
ResolutionModel resolutionModel = _mapper.Map(resolution, new ResolutionModel());
_mapper.FileResolution = _unitOfWork.Repository <FileResolution>().GetByResolution(item.DocumentUnit.EntityId).SingleOrDefault();
_mapper.ResolutionRoles = _unitOfWork.Repository <ResolutionRole>().GetByResolution(item.DocumentUnit.EntityId);
message = GenerateMessage(item.DocumentUnit.Category, (int)DSWEnvironmentType.Resolution,
(categoryFascicle) => new CommandUpdateResolution(_parameterEnvService.CurrentTenantName, _parameterEnvService.CurrentTenantId, item.DocumentUnit.TenantAOO.UniqueId,
new IdentityContext(_currentIdentity.FullUserName), resolutionModel, categoryFascicle, null));
Task.Run(async() =>
{
await _queueService.SubscribeQueue(message.ChannelName).SendToQueueAsync(message);
}).Wait();
}
if (item.DocumentUnit.Environment == (int)DSWEnvironmentType.DocumentSeries)
{
DocumentSeriesItem documentSeriesItem = _unitOfWork.Repository <DocumentSeriesItem>().GetFullByUniqueId(item.DocumentUnit.UniqueId).SingleOrDefault();
message = GenerateMessage(item.DocumentUnit.Category, (int)DSWEnvironmentType.DocumentSeries,
(categoryFascicle) => new CommandUpdateDocumentSeriesItem(_parameterEnvService.CurrentTenantName, _parameterEnvService.CurrentTenantId, item.DocumentUnit.TenantAOO.UniqueId, null,
new IdentityContext(_currentIdentity.FullUserName), documentSeriesItem, categoryFascicle, null));
Task.Run(async() =>
{
await _queueService.SubscribeQueue(message.ChannelName).SendToQueueAsync(message);
}).Wait();
}
if (item.DocumentUnit.Environment >= 100)
{
UDSBuildModel commandModel = _mapperUnitOfwork.Repository <IDomainMapper <DocumentUnit, UDSBuildModel> >().Map(item.DocumentUnit, new UDSBuildModel());
commandModel.UniqueId = item.DocumentUnit.UniqueId;
commandModel.RegistrationDate = item.DocumentUnit.RegistrationDate;
commandModel.RegistrationUser = item.DocumentUnit.RegistrationUser;
message = GenerateMessage(item.DocumentUnit.Category, item.DocumentUnit.Environment,
(categoryFascicle) => new CommandCQRSUpdateUDSData(_parameterEnvService.CurrentTenantName, _parameterEnvService.CurrentTenantId, item.DocumentUnit.TenantAOO.UniqueId,
new IdentityContext(_currentIdentity.FullUserName), commandModel, categoryFascicle, null, null, null, null));
Task.Run(async() =>
{
await _queueService.SubscribeQueue(message.ChannelName).SendToQueueAsync(message);
}).Wait();
}
}
}
if (CurrentInsertActionType.HasValue || CurrentUpdateActionType.HasValue)
{
if (CurrentInsertActionType.HasValue)
{
Task.Run(async() =>
{
FascicleFolder fascicleNode = new FascicleFolder
{
UniqueId = Guid.NewGuid(),
Fascicle = entity,
Name = "Fascicolo",
Category = entity.Category,
Status = FascicleFolderStatus.Active,
Typology = FascicleFolderTypology.Fascicle
};
_unitOfWork.Repository <FascicleFolder>().Insert(fascicleNode);
await _unitOfWork.SaveChangesAsync();
_logger.WriteDebug(new LogMessage($"Created principal folder from Fascicle.UniqueId {entity.UniqueId}"), LogCategories);
Fascicle fascicleTemplateModel = null;
if (entity.FascicleTemplate != null && !string.IsNullOrEmpty(entity.FascicleTemplate.JsonModel))
{
fascicleTemplateModel = JsonConvert.DeserializeObject <Fascicle>(entity.FascicleTemplate.JsonModel, Defaults.DefaultJsonSerializer);
if (fascicleTemplateModel != null && fascicleTemplateModel.FascicleFolders.Any())
{
_logger.WriteDebug(new LogMessage($"Evaluating fascicle template {entity.FascicleTemplate.UniqueId} with {fascicleTemplateModel.FascicleFolders.Count} folders from Fascicle.UniqueId {entity.UniqueId}"), LogCategories);
IEnumerable <FascicleFolder> results = fascicleTemplateModel.FascicleFolders.Where(f => f.Typology == FascicleFolderTypology.SubFascicle);
await RecursiveInsertFascicleFoldersAsync(entity, fascicleNode, results, results.Where(f => !f.ParentInsertId.HasValue));
}
}
}).Wait();
}
IIdentityContext identity = new IdentityContext(_currentIdentity.FullUserName);
Fascicle fascicle = _unitOfWork.Repository <Fascicle>().GetByUniqueId(entity.UniqueId);
ICQRS command = new CommandCreateFascicle(_parameterEnvService.CurrentTenantName, _parameterEnvService.CurrentTenantId, Guid.Empty, identity, fascicle);
if (CurrentUpdateActionType.HasValue)
{
command = new CommandUpdateFascicle(_parameterEnvService.CurrentTenantName, _parameterEnvService.CurrentTenantId, Guid.Empty, identity, fascicle);
}
foreach (IWorkflowAction workflowAction in WorkflowActions)
{
workflowAction.IdWorkflowActivity = IdWorkflowActivity;
command.WorkflowActions.Add(workflowAction);
}
ServiceBusMessage message = _cqrsMapper.Map(command, new ServiceBusMessage());
if (message == null || string.IsNullOrEmpty(message.ChannelName))
{
throw new DSWException($"Queue name to command [{command}] is not mapped", null, DSWExceptionCode.SC_Mapper);
}
Task.Run(async() =>
{
await _queueService.SubscribeQueue(message.ChannelName).SendToQueueAsync(message);
}).Wait();
}
}
catch (DSWException ex)
{
_logger.WriteError(ex, LogCategories);
}
base.AfterSave(entity);
}
public async Task ExecuteAsync(ICommandBuildFascicle command)
{
Fascicle fascicle = new Fascicle();
FascicleBuildModel fascicleBuildModel = command.ContentType.ContentTypeValue;
FascicleModel fascicleModel = fascicleBuildModel.Fascicle;
IdWorkflowActivity = fascicleBuildModel.IdWorkflowActivity;
List <DossierFolderModel> dossierFolderDoAction = new List <DossierFolderModel>();
string fascicleInsertActionType;
if (!fascicleModel.FascicleType.HasValue || !_fascicleTypeInsertActionDescription.TryGetValue(fascicleModel.FascicleType.Value, out fascicleInsertActionType))
{
_logger.WriteError(new LogMessage($"Undefined or unsupported fascicle type {fascicleModel.FascicleType}"), LogCategories);
throw new ServiceBusEvaluationException(new EvaluationModel {
CommandName = nameof(command), CorrelationId = command.CorrelationId
});
}
try
{
if (RetryPolicyEvaluation != null && !string.IsNullOrEmpty(RetryPolicyEvaluation.ReferenceModel))
{
fascicleModel = JsonConvert.DeserializeObject <FascicleModel>(RetryPolicyEvaluation.ReferenceModel, _serializerSettings);
}
else
{
RetryPolicyEvaluation = new EvaluationModel();
}
//Attraverso le WebAPI comunicando col verbo POST col controller Rest Fascicle creare l'entità Fascicle
#region [ Creazione Fascicle ]
if (!RetryPolicyEvaluation.Steps.Any(f => f.Name == "ENTITY"))
{
if (!fascicleModel.Category.IdCategory.HasValue)
{
throw new ArgumentNullException("fascicleModel.Category.IdCategory", "IdCategory must be defined");
}
if (fascicleModel.UniqueId == Guid.Empty)
{
throw new ArgumentException("fascicleModel.UniqueId", $"Invalid FascicleModel UniqueId {fascicleModel.UniqueId}");
}
fascicle.MetadataValues = fascicleModel.MetadataValues;
fascicle.UniqueId = fascicleModel.UniqueId;
fascicle.Rack = fascicleModel.Rack;
fascicle.Note = fascicleModel.Note;
fascicle.Manager = fascicleModel.Manager;
fascicle.FascicleObject = fascicleModel.FascicleObject;
fascicle.MetadataDesigner = fascicleModel.MetadataDesigner;
if (fascicleModel.FascicleTemplate != null)
{
fascicle.FascicleTemplate = new ProcessFascicleTemplate
{
JsonModel = fascicleModel.FascicleTemplate.JsonModel,
Name = fascicleModel.FascicleTemplate.Name,
UniqueId = fascicleModel.FascicleTemplate.UniqueId ?? Guid.NewGuid(),
StartDate = fascicleModel.FascicleTemplate.StartDate,
EndDate = fascicleModel.FascicleTemplate.EndDate,
RegistrationDate = fascicleModel.FascicleTemplate.RegistrationDate,
RegistrationUser = fascicleModel.FascicleTemplate.RegistrationUser
};
}
if (fascicleModel.MetadataRepository != null)
{
fascicle.MetadataRepository = new MetadataRepository()
{
UniqueId = fascicleModel.MetadataRepository.Id
};
}
if (fascicleModel.FascicleType != null)
{
fascicle.FascicleType = (DocSuiteWeb.Entity.Fascicles.FascicleType)fascicleModel.FascicleType.Value;
}
if (fascicleModel.VisibilityType != null)
{
fascicle.VisibilityType = (DocSuiteWeb.Entity.Fascicles.VisibilityType)fascicleModel.VisibilityType.Value;
}
if (fascicleModel.Conservation != null)
{
fascicle.Conservation = fascicleModel.Conservation.Value;
}
if (fascicleModel.DossierFolders.Any())
{
dossierFolderDoAction.AddRange(fascicleModel.DossierFolders.Where(f => f.Status == DocSuiteWeb.Model.Entities.Dossiers.DossierFolderStatus.DoAction));
List <DossierFolder> dossierFolders = new List <DossierFolder>();
DossierFolder folder;
foreach (DossierFolderModel dossierFolderModel in fascicleModel.DossierFolders.Where(f => f.Status != DocSuiteWeb.Model.Entities.Dossiers.DossierFolderStatus.DoAction))
{
if (dossierFolderModel.Status == DocSuiteWeb.Model.Entities.Dossiers.DossierFolderStatus.Fascicle || dossierFolderModel.Status == DocSuiteWeb.Model.Entities.Dossiers.DossierFolderStatus.FascicleClose)
{
_logger.WriteWarning(new LogMessage($"Fascicle {fascicle.GetTitle()} has wrong dossierfolder({dossierFolderModel.UniqueId}) reference type and it going to replace with parent association"), LogCategories);
folder = await _webApiClient.GetDossierFolderParentAsync(dossierFolderModel.UniqueId);
folder.Category = new Category()
{
EntityShortId = (short)fascicleModel.Category.IdCategory.Value
};
if (folder == null)
{
_logger.WriteError(new LogMessage($"DossierFolder {dossierFolderModel.UniqueId} doesn't have parent. it will be skip"), LogCategories);
continue;
}
dossierFolders.Add(folder);
}
else
{
dossierFolders.Add(new DossierFolder()
{
UniqueId = dossierFolderModel.UniqueId,
Status = (VecompSoftware.DocSuiteWeb.Entity.Dossiers.DossierFolderStatus)dossierFolderModel.Status,
Category = dossierFolderModel.IdCategory.HasValue ? new Category()
{
EntityShortId = dossierFolderModel.IdCategory.Value
} : null
});
}
}
fascicle.DossierFolders = dossierFolders;
}
fascicle.Contacts = new List <Contact>();
if (fascicleModel.Contacts != null && fascicleModel.Contacts.Count > 0)
{
foreach (ContactModel contact in fascicleModel.Contacts.Where(f => f.EntityId.HasValue))
{
fascicle.Contacts.Add(new Contact()
{
EntityId = contact.EntityId.Value
});
}
}
fascicle.Category = new Category()
{
EntityShortId = (short)fascicleModel.Category.IdCategory.Value
};
fascicle.FascicleRoles = new List <FascicleRole>();
if (fascicleModel.FascicleRoles != null && fascicleModel.FascicleRoles.Count > 0)
{
fascicle.FascicleRoles = fascicleModel.FascicleRoles.Where(x => x.Role.IdRole.HasValue).Select(s =>
new FascicleRole()
{
Role = new Role()
{
EntityShortId = s.Role.IdRole.Value
},
IsMaster = s.IsMaster,
AuthorizationRoleType = (AuthorizationRoleType)s.AuthorizationRoleType
}).ToList();
}
RetryPolicyEvaluation.Steps.Add(new StepModel()
{
Name = "ENTITY",
LocalReference = JsonConvert.SerializeObject(fascicle, _serializerSettings)
});
}
else
{
StepModel messageStatus = RetryPolicyEvaluation.Steps.First(f => f.Name == "ENTITY");
fascicle = JsonConvert.DeserializeObject <Fascicle>(messageStatus.LocalReference);
}
if (!RetryPolicyEvaluation.Steps.Any(f => f.Name == "ENTITY_CREATED"))
{
fascicle.WorkflowName = fascicleBuildModel.WorkflowName;
fascicle.IdWorkflowActivity = fascicleBuildModel.IdWorkflowActivity;
fascicle.WorkflowAutoComplete = fascicleBuildModel.WorkflowAutoComplete;
foreach (IWorkflowAction workflowAction in fascicleBuildModel.WorkflowActions)
{
fascicle.WorkflowActions.Add(workflowAction);
}
_logger.WriteDebug(new LogMessage(JsonConvert.SerializeObject(fascicle, _serializerSettings)), LogCategories);
fascicle = await _webApiClient.PostEntityAsync(fascicle, fascicleInsertActionType);
_logger.WriteInfo(new LogMessage($"Fascicle {fascicle.GetTitle()} has been created"), LogCategories);
DossierFolder dossierFolder;
foreach (DossierFolderModel item in dossierFolderDoAction)
{
dossierFolder = await _webApiClient.PutEntityAsync(new DossierFolder()
{
UniqueId = item.UniqueId,
Category = new Category()
{
EntityShortId = fascicle.Category.EntityShortId
},
Fascicle = fascicle,
JsonMetadata = item.JsonMetadata,
Name = item.Name,
Status = DocSuiteWeb.Entity.Dossiers.DossierFolderStatus.Fascicle
});
_logger.WriteInfo(new LogMessage($"DoAction DossierFolder {item.Name} update to new fascicle"), LogCategories);
fascicle.DossierFolders.Add(dossierFolder);
}
RetryPolicyEvaluation.Steps.Add(new StepModel()
{
Name = "ENTITY_CREATED",
LocalReference = JsonConvert.SerializeObject(fascicle, _serializerSettings)
});
}
else
{
StepModel messageStatus = RetryPolicyEvaluation.Steps.First(f => f.Name == "ENTITY_CREATED"); //Posso fare first direttamente perche sono nell else
fascicle = JsonConvert.DeserializeObject <Fascicle>(messageStatus.LocalReference);
}
#endregion
#region [ Creazione FascicleFolders ]
if (!RetryPolicyEvaluation.Steps.Any(f => f.Name == "FASCICLE_FOLDERS"))
{
if (fascicleModel.FascicleFolders.Count > 0)
{
FascicleFolder defaultFolder = await _webApiClient.GetDefaultFascicleFolderAsync(fascicle.UniqueId);
FascicleFolder fascicleFolder;
foreach (FascicleFolderModel fascicleFolderModel in fascicleModel.FascicleFolders)
{
fascicleFolder = new FascicleFolder()
{
UniqueId = fascicleFolderModel.UniqueId,
Fascicle = fascicle,
ParentInsertId = defaultFolder.UniqueId,
Name = fascicleFolderModel.Name,
Status = (DocSuiteWeb.Entity.Fascicles.FascicleFolderStatus)fascicleFolderModel.Status,
Typology = (DocSuiteWeb.Entity.Fascicles.FascicleFolderTypology)fascicleFolderModel.Typology
};
await _webApiClient.PostEntityAsync(fascicleFolder);
_logger.WriteInfo(new LogMessage($"Fascicle folder {fascicleFolder.Name} has been created"), LogCategories);
}
}
RetryPolicyEvaluation.Steps.Add(new StepModel()
{
Name = "FASCICLE_FOLDERS",
LocalReference = JsonConvert.SerializeObject(fascicle, _serializerSettings)
});
}
else
{
StepModel messageStatus = RetryPolicyEvaluation.Steps.First(f => f.Name == "FASCICLE_FOLDERS");
fascicle = JsonConvert.DeserializeObject <Fascicle>(messageStatus.LocalReference);
}
#endregion
//Attraverso le WebAPI comunicando col verbo POST col controller Rest FascicleDocument e inserire tutti gli inserti inseriti in Biblos popolando la navigation property FascicleDocuments (FascicleDocument table) coi relativi identificativi Guid di Biblos
#region [ Creazione FascicleDocument ]
if (!RetryPolicyEvaluation.Steps.Any(f => f.Name == "FASCICLE"))
{
foreach (FascicleDocumentModel model in fascicleModel.FascicleDocuments)
{
fascicle.FascicleDocuments.Add(new FascicleDocument
{
UniqueId = model.UniqueId,
ChainType = (DocSuiteWeb.Entity.DocumentUnits.ChainType)model.ChainType,
IdArchiveChain = model.IdArchiveChain,
RegistrationUser = model.RegistrationUser,
RegistrationDate = model.RegistrationDate.Value,
LastChangedUser = model.LastChangedUser
});
}
RetryPolicyEvaluation.Steps.Add(new StepModel()
{
Name = "FASCICLE",
LocalReference = JsonConvert.SerializeObject(fascicle, _serializerSettings)
});
}
else
{
StepModel messageStatus = RetryPolicyEvaluation.Steps.First(f => f.Name == "FASCICLE");
fascicle = JsonConvert.DeserializeObject <Fascicle>(messageStatus.LocalReference);
}
if (!RetryPolicyEvaluation.Steps.Any(f => f.Name == "FASCICLE_CREATED"))
{
fascicle = await _webApiClient.PutEntityAsync(fascicle, fascicle.FascicleType == DocSuiteWeb.Entity.Fascicles.FascicleType.Activity?UpdateActionType.ActivityFascicleUpdate.ToString() : string.Empty);
RetryPolicyEvaluation.Steps.Add(new StepModel()
{
Name = "FASCICLE_CREATED",
LocalReference = JsonConvert.SerializeObject(fascicle, _serializerSettings)
});
}
else
{
StepModel messageStatus = RetryPolicyEvaluation.Steps.First(f => f.Name == "FASCICLE_CREATED");
fascicle = JsonConvert.DeserializeObject <Fascicle>(messageStatus.LocalReference);
}
#endregion
//Attraverso le WebAPI comunicando col verbo POST inviare l'evento EventoCompleteFascicleBuild
#region [ EventoCompleteFascicleBuild ]
fascicleModel.RegistrationDate = fascicle.RegistrationDate;
fascicleModel.RegistrationUser = fascicle.RegistrationUser;
fascicleModel.Year = fascicle.Year;
fascicleModel.Title = fascicle.Title;
fascicleModel.StartDate = fascicle.StartDate;
fascicleModel.Number = fascicle.Number;
fascicleBuildModel.Fascicle = fascicleModel;
IEventCompleteFascicleBuild eventCompleteFascicleBuild = new EventCompleteFascicleBuild(Guid.NewGuid(), command.CorrelationId ?? fascicleBuildModel.UniqueId,
command.TenantName, command.TenantId, command.TenantAOOId, command.Identity, fascicleBuildModel, null);
if (!await _webApiClient.PushEventAsync(eventCompleteFascicleBuild))
{
_logger.WriteError(new LogMessage($"EventCompleteFascicleBuild {fascicle.GetTitle()} has not been sended"), LogCategories);
throw new Exception("IEventCompleteFascicleBuild not sended");
}
_logger.WriteInfo(new LogMessage($"EventCompleteFascicleBuild {eventCompleteFascicleBuild.Id} has been sended"), LogCategories);
#endregion
}
catch (Exception ex)
{
RetryPolicyEvaluation.ReferenceModel = JsonConvert.SerializeObject(fascicleModel, _serializerSettings);
_logger.WriteError(ex, LogCategories);
throw new ServiceBusEvaluationException(RetryPolicyEvaluation);
}
}
