public static UDSRepository GetByIdDocumentUnit(this IRepository <UDSRepository> repository, Guid idDocumentUnit, bool optimization = false)
{
UDSRepository result = repository.Query(t => t.DocumentUnits.Any(f => f.UniqueId == idDocumentUnit && f.Environment >= 100), optimization)
.SelectAsQueryable()
.FirstOrDefault();
return(result);
}
private UDSRepository MapUDSRepositoryModel(UDSRepository udsRepository, UDSRepositoryModel udsRepositoryModel)
{
udsRepository.UniqueId = udsRepositoryModel.Id;
udsRepository.DSWEnvironment = udsRepositoryModel.DSWEnvironment;
udsRepository.Name = udsRepository.Name;
udsRepository.Status = udsRepository.Status;
return(udsRepository);
}
public async Task <IHttpActionResult> Post([FromBody] BuildActionModel model, Guid idRepository)
{
return(await WebApiHelpers.ActionHelper.TryCatchWithLoggerAsync(async() =>
{
UDSRepository repository = _unitOfWork.Repository <UDSRepository>().Find(idRepository);
if (repository != null && model != null && !string.IsNullOrEmpty(model.Model))
{
UDSRelationModel relationModel = JsonConvert.DeserializeObject <UDSRelationModel>(model.Model);
ICollection <UDSRole> rolesToManage = GetEntityRoles(relationModel.Roles, repository);
ICollection <UDSUser> usersToManage = GetEntityUsers(relationModel.Users, repository);
ICollection <UDSPECMail> pecMailsToManage = GetEntityPECMails(relationModel.PECMails, repository);
ICollection <UDSMessage> messagesToManage = GetEntityMessages(relationModel.Messages, repository);
ICollection <UDSDocumentUnit> documentUnitsToManage = GetEntityDocumentUnits(relationModel.DocumentUnits, repository);
ICollection <UDSContact> contactsToManage = GetEntityContacts(relationModel.Contacts, repository);
ICollection <UDSCollaboration> collaborationsToManage = GetEntityCollaborations(relationModel.Collaborations, repository);
if (model.BuildType == BuildActionType.Build)
{
_unitOfWork.BeginTransaction();
await BuildUDSRoleAsync(rolesToManage);
await BuildUDSUserAsync(usersToManage);
await BuildUDSPECMailAsync(pecMailsToManage);
await BuildUDSMessageAsync(messagesToManage);
await BuildUDSDocumentUnitAsync(documentUnitsToManage);
await BuildUDSContactAsync(contactsToManage);
await BuildUDSCollaborationAsync(collaborationsToManage);
await _unitOfWork.SaveAsync();
}
if (model.BuildType == BuildActionType.Synchronize)
{
_unitOfWork.BeginTransaction();
await SynchroniseUDSRoleAsync(rolesToManage, model.ReferenceId, repository);
await SynchroniseUDSUserAsync(usersToManage, model.ReferenceId, repository);
await SynchroniseUDSPECMailAsync(pecMailsToManage, model.ReferenceId, repository);
await SynchroniseUDSMessageAsync(messagesToManage, model.ReferenceId, repository);
await SynchroniseUDSDocumentUnitAsync(documentUnitsToManage, model.ReferenceId, repository);
await SynchroniseUDSContactAsync(contactsToManage, model.ReferenceId, repository);
await SynchroniseUDSCollaborationAsync(collaborationsToManage, model.ReferenceId, repository);
await _unitOfWork.SaveAsync();
}
}
return Ok(model);
}, BadRequest, Content, InternalServerError, _logger, LogCategories));
}
internal static UDSLog CreateUDSLog(Guid idUDS, UDSRepository repository, string logDescription, UDSLogType logType, string registrationUser, DateTimeOffset?logDate = null, string systemComputer = "")
{
UDSLog log = new UDSLog()
{
LogType = logType,
LogDescription = logDescription,
SystemComputer = string.IsNullOrEmpty(systemComputer) ? Environment.MachineName : systemComputer,
Entity = repository,
RegistrationDate = logDate.HasValue && logDate.Value != DateTimeOffset.MinValue ? logDate.Value : DateTimeOffset.UtcNow,
RegistrationUser = registrationUser,
IdUDS = idUDS,
Environment = repository.DSWEnvironment,
};
log.Hash = HashGenerator.GenerateHash(string.Concat(log.RegistrationUser, "|", log.LogType, "|", log.LogDescription, "|", log.UniqueId, "|", idUDS, "|", log.RegistrationDate.ToString("yyyyMMddHHmmss")));
return(log);
}
private async Task SaveUDSRepositoryAsync(UDSBuildModel model, string idContainer)
{
try
{
if (model.UDSRepository != null)
{
if (!model.UDSRepository.ActiveDate.HasValue)
{
_logger.WriteError(new LogMessage("Active date is empty"), LogCategories);
throw new ArgumentNullException("Active date is empty");
}
UDSRepository udsRepository = new UDSRepository(model.UDSRepository.Id);
UDSSchemaRepository lastSchemaRepository = CurrentUDSSchemaRepository;
_logger.WriteInfo(new LogMessage(string.Concat("Last valid Repository : ", lastSchemaRepository.UniqueId)), LogCategories);
udsRepository.ActiveDate = model.UDSRepository.ActiveDate.Value;
udsRepository.ExpiredDate = null;
udsRepository.LastChangedDate = DateTimeOffset.UtcNow;
udsRepository.Version = 1;
udsRepository.ModuleXML = model.XMLContent;
udsRepository.Name = model.UDSRepository.Name;
udsRepository.SchemaRepository = lastSchemaRepository;
udsRepository.SequenceCurrentYear = (short)model.UDSRepository.ActiveDate.Value.Year;
udsRepository.Alias = model.UDSRepository.Alias;
udsRepository.DSWEnvironment = model.UDSRepository.DSWEnvironment;
udsRepository.Status = DocSuiteWeb.Entity.UDS.UDSRepositoryStatus.Confirmed;
udsRepository.Container = new DocSuiteWeb.Entity.Commons.Container()
{
EntityShortId = Convert.ToInt16(idContainer)
};
udsRepository = await UpdateUDSRepositoryAsync(udsRepository);
_logger.WriteInfo(new LogMessage(string.Concat("Repository is updated: ", udsRepository.UniqueId)), LogCategories);
}
}
catch (Exception ex)
{
_logger.WriteError(ex, LogCategories);
throw ex;
}
}
private async Task SynchroniseUDSRoleAsync(ICollection <UDSRole> rolesToManage, Guid udsId, UDSRepository repository)
{
ICollection <UDSRole> oldAuthorizations = _unitOfWork.Repository <UDSRole>().GetByUDSId(udsId).ToList();
foreach (UDSRole item in oldAuthorizations.Where(f => !rolesToManage.Any(c => c.Relation.EntityShortId == f.Relation.EntityShortId)))
{
item.Repository = repository;
await _udsAuthorizationService.DeleteAsync(item);
}
foreach (UDSRole item in rolesToManage.Where(f => !oldAuthorizations.Any(c => c.Relation.EntityShortId == f.Relation.EntityShortId)))
{
await _udsAuthorizationService.CreateAsync(item);
}
}
private ICollection <UDSCollaboration> GetEntityCollaborations(ICollection <UDSCollaborationModel> udsCollaborationModels, UDSRepository repository)
{
ICollection <UDSCollaboration> collaborations = new List <UDSCollaboration>();
UDSCollaboration udsCollaboration;
foreach (UDSCollaborationModel collaboration in udsCollaborationModels)
{
udsCollaboration = _mapperUnitOfWork.Repository <IUDSCollaborationEntityMapper>().Map(collaboration, new UDSCollaboration());
udsCollaboration.Relation = _unitOfWork.Repository <Collaboration>().Find(collaboration.IdCollaboration);
udsCollaboration.Environment = repository.DSWEnvironment;
udsCollaboration.Repository = repository;
collaborations.Add(udsCollaboration);
}
return(collaborations);
}
private ICollection <UDSContact> GetEntityContacts(ICollection <UDSContactModel> udsContactModels, UDSRepository repository)
{
ICollection <UDSContact> contacts = new List <UDSContact>();
UDSContact udsContact;
foreach (UDSContactModel contact in udsContactModels)
{
udsContact = _mapperUnitOfWork.Repository <IUDSContactEntityMapper>().Map(contact, new UDSContact());
udsContact.Environment = repository.DSWEnvironment;
udsContact.Repository = repository;
if (udsContact.ContactType == (short)UDSContactType.Normal)
{
udsContact.Relation = _unitOfWork.Repository <Contact>().Find(contact.IdContact);
}
contacts.Add(udsContact);
}
return(contacts);
}
/// <summary>
/// Aggiorno la UDSRepository attiva in questo momento.
/// Aggiongo la repository presente nel comando
/// Associo l'ultimo schema
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private async Task UpdateUDSRepositoryAsync(UDSBuildModel model, bool requiredRevisionUDSRepository = true)
{
try
{
if (model.UDSRepository != null)
{
if (!model.UDSRepository.ActiveDate.HasValue)
{
_logger.WriteError(new LogMessage("Active date is empty"), LogCategories);
throw new ArgumentNullException("Active date is empty");
}
UDSRepository currentRepository = await GetCurrentUDSRepositoryAsync(model.UDSRepository.Name);
UDSRepository newRepository = await GetUDSRepositoryAsync(model.UDSRepository.Id);
_logger.WriteInfo(new LogMessage($"Last valid Repository is {CurrentUDSSchemaRepository.UniqueId}"), LogCategories);
if (requiredRevisionUDSRepository)
{
currentRepository.ExpiredDate = model.UDSRepository.ActiveDate;
newRepository.ActiveDate = model.UDSRepository.ActiveDate.Value;
newRepository.ExpiredDate = null;
newRepository.LastChangedDate = DateTimeOffset.UtcNow;
newRepository.ModuleXML = model.XMLContent;
newRepository.Name = model.UDSRepository.Name;
newRepository.SchemaRepository = CurrentUDSSchemaRepository;
newRepository.Version = ++currentRepository.Version;
newRepository.Status = DocSuiteWeb.Entity.UDS.UDSRepositoryStatus.Confirmed;
newRepository.SequenceCurrentYear = currentRepository.SequenceCurrentYear;
newRepository.SequenceCurrentNumber = currentRepository.SequenceCurrentNumber;
currentRepository = await UpdateUDSRepositoryAsync(currentRepository);
_logger.WriteInfo(new LogMessage($"Repository {currentRepository.UniqueId}/{currentRepository.Name}/{newRepository.Version} has expired"), LogCategories);
newRepository = await UpdateUDSRepositoryAsync(newRepository);
_logger.WriteInfo(new LogMessage($"Repository {newRepository.UniqueId}/{newRepository.Name}/{newRepository.Version} has been successfully confirmed."), LogCategories);
}
else
{
currentRepository.ModuleXML = model.XMLContent;
currentRepository = await UpdateUDSRepositoryAsync(currentRepository);
_logger.WriteInfo(new LogMessage($"Repository {newRepository.UniqueId}/{newRepository.Name}/{newRepository.Version} has been successfully updated."), LogCategories);
newRepository = await DeleteUDSRepositoryAsync(newRepository);
if (newRepository != null)
{
_logger.WriteInfo(new LogMessage($"Draft repository {newRepository.UniqueId}/{newRepository.Name}/{newRepository.Version} has been deleted"), LogCategories);
}
else
{
_logger.WriteWarning(new LogMessage($"Error occoured during deleting draft repository {newRepository.UniqueId}/{newRepository.Name}/{newRepository.Version}"), LogCategories);
}
}
}
}
catch (Exception ex)
{
_logger.WriteError(ex, LogCategories);
throw ex;
}
}
private async Task SynchroniseUDSContactAsync(ICollection <UDSContact> contactsToManage, Guid udsId, UDSRepository repository)
{
ICollection <UDSContact> oldContacts = _unitOfWork.Repository <UDSContact>().GetByUDSId(udsId).ToList();
foreach (UDSContact item in oldContacts.Where(f => !contactsToManage.Any(c => (c.ContactType == (short)UDSContactType.Normal && c.Relation != null && f.Relation != null && c.Relation.EntityId == f.Relation.EntityId) || (c.ContactType == (short)UDSContactType.Manual && c.ContactManual == f.ContactManual))))
{
item.Repository = repository;
await _udsContactService.DeleteAsync(item);
}
foreach (UDSContact item in contactsToManage.Where(f => !oldContacts.Any(c => (c.ContactType == (short)UDSContactType.Normal && c.Relation != null && f.Relation != null && c.Relation.EntityId == f.Relation.EntityId) || (c.ContactType == (short)UDSContactType.Manual && c.ContactManual == f.ContactManual))))
{
await _udsContactService.CreateAsync(item);
}
}
private async Task SynchroniseUDSMessageAsync(ICollection <UDSMessage> messagesToManage, Guid udsId, UDSRepository repository)
{
ICollection <UDSMessage> oldMessages = _unitOfWork.Repository <UDSMessage>().GetByUDSId(udsId).ToList();
foreach (UDSMessage item in oldMessages.Where(f => !messagesToManage.Any(c => c.Relation.EntityId == f.Relation.EntityId)))
{
item.Repository = repository;
await _udsMessageService.DeleteAsync(item);
}
foreach (UDSMessage item in messagesToManage.Where(f => !oldMessages.Any(c => c.Relation.EntityId == f.Relation.EntityId)))
{
await _udsMessageService.CreateAsync(item);
}
}
private ICollection <UDSRole> GetEntityRoles(ICollection <UDSRoleModel> roleModels, UDSRepository repository)
{
ICollection <UDSRole> roles = new List <UDSRole>();
UDSRole udsRole;
foreach (UDSRoleModel roleModel in roleModels)
{
udsRole = _mapperUnitOfWork.Repository <IUDSRoleEntityMapper>().Map(roleModel, new UDSRole());
udsRole.Relation = _unitOfWork.Repository <Role>().Find(roleModel.IdRole);
udsRole.Environment = repository.DSWEnvironment;
udsRole.Repository = repository;
roles.Add(udsRole);
}
return(roles);
}
public static UDSRepository GetByName(this IRepository <UDSRepository> repository, string name, bool optimization = true)
{
UDSRepository result = repository.Query(t => t.Name.Equals(name), optimization).SelectAsQueryable().FirstOrDefault();
return(result);
}
public static UDSRepository GetPreviousVersionWithUDSTypologies(this IRepository <UDSRepository> repository, UDSRepository entityUDSRepository)
{
IQueryable <UDSRepository> temp = repository.Query(x => x.Name.Equals(entityUDSRepository.Name) && x.ExpiredDate != null && x.Version == entityUDSRepository.Version - 1)
.Include(t => t.UDSTypologies)
.SelectAsQueryable();
return(temp.FirstOrDefault());
}
private async Task SynchroniseUDSUserAsync(ICollection <UDSUser> usersToManage, Guid udsId, UDSRepository repository)
{
ICollection <UDSUser> oldUsers = _unitOfWork.Repository <UDSUser>().GetByUDSId(udsId).ToList();
foreach (UDSUser item in oldUsers.Where(f => !usersToManage.Any(c => c.Account == f.Account)))
{
item.Repository = repository;
await _udsUserService.DeleteAsync(item);
}
foreach (UDSUser item in usersToManage.Where(f => !oldUsers.Any(c => c.Account == f.Account)))
{
await _udsUserService.CreateAsync(item);
}
}
private async Task SynchroniseUDSPECMailAsync(ICollection <UDSPECMail> pecMailsToManage, Guid udsId, UDSRepository repository)
{
ICollection <UDSPECMail> oldPECMails = _unitOfWork.Repository <UDSPECMail>().GetByUDSId(udsId).ToList();
foreach (UDSPECMail item in oldPECMails.Where(f => !pecMailsToManage.Any(c => c.Relation.EntityId == f.Relation.EntityId)))
{
item.Repository = repository;
await _udsPECMailService.DeleteAsync(item);
}
foreach (UDSPECMail item in pecMailsToManage.Where(f => !oldPECMails.Any(c => c.Relation.EntityId == f.Relation.EntityId)))
{
await _udsPECMailService.CreateAsync(item);
}
}
private ICollection <UDSUser> GetEntityUsers(ICollection <UDSUserModel> udsUserModels, UDSRepository repository)
{
ICollection <UDSUser> users = new List <UDSUser>();
UDSUser udsUser;
foreach (UDSUserModel userModel in udsUserModels)
{
udsUser = _mapperUnitOfWork.Repository <IUDSUserEntityMapper>().Map(userModel, new UDSUser());
udsUser.Environment = repository.DSWEnvironment;
udsUser.Repository = repository;
users.Add(udsUser);
}
return(users);
}
private async Task SynchroniseUDSDocumentUnitAsync(ICollection <UDSDocumentUnit> documentUnitsToManage, Guid udsId, UDSRepository repository)
{
ICollection <UDSDocumentUnit> oldDocumentUnits = _unitOfWork.Repository <UDSDocumentUnit>().GetByUDSId(udsId).ToList();
foreach (UDSDocumentUnit item in oldDocumentUnits.Where(f => !documentUnitsToManage.Any(c => c.Relation.UniqueId == f.Relation.UniqueId)))
{
item.Repository = repository;
await _udsDocumentUnitService.DeleteAsync(item);
}
foreach (UDSDocumentUnit item in documentUnitsToManage.Where(f => !oldDocumentUnits.Any(c => c.Relation.UniqueId == f.Relation.UniqueId)))
{
await _udsDocumentUnitService.CreateAsync(item);
}
}
private ICollection <UDSPECMail> GetEntityPECMails(ICollection <UDSPECMailModel> udsPecMailModels, UDSRepository repository)
{
ICollection <UDSPECMail> pecMails = new List <UDSPECMail>();
UDSPECMail udsPECMail;
foreach (UDSPECMailModel pecMail in udsPecMailModels)
{
udsPECMail = _mapperUnitOfWork.Repository <IUDSPECMailEntityMapper>().Map(pecMail, new UDSPECMail());
udsPECMail.Relation = _unitOfWork.Repository <PECMail>().Find(pecMail.IdPECMail);
udsPECMail.Environment = repository.DSWEnvironment;
udsPECMail.Repository = repository;
pecMails.Add(udsPECMail);
}
return(pecMails);
}
private async Task SynchroniseUDSCollaborationAsync(ICollection <UDSCollaboration> collaborationsToManage, Guid udsId, UDSRepository repository)
{
ICollection <UDSCollaboration> oldCollaborations = _unitOfWork.Repository <UDSCollaboration>().GetByUDSId(udsId).ToList();
foreach (UDSCollaboration item in oldCollaborations.Where(f => !collaborationsToManage.Any(c => c.Relation.EntityId == f.Relation.EntityId)))
{
item.Repository = repository;
await _udsCollaborationService.DeleteAsync(item);
}
foreach (UDSCollaboration item in collaborationsToManage.Where(f => !oldCollaborations.Any(c => c.Relation.EntityId == f.Relation.EntityId)))
{
await _udsCollaborationService.CreateAsync(item);
}
}
private ICollection <UDSMessage> GetEntityMessages(ICollection <UDSMessageModel> udsMessageModels, UDSRepository repository)
{
ICollection <UDSMessage> messages = new List <UDSMessage>();
UDSMessage udsMessage;
foreach (UDSMessageModel message in udsMessageModels)
{
udsMessage = _mapperUnitOfWork.Repository <IUDSMessageEntityMapper>().Map(message, new UDSMessage());
udsMessage.Relation = _unitOfWork.Repository <DocSuiteWeb.Entity.Messages.Message>().Find(message.IdMessage);
udsMessage.Environment = repository.DSWEnvironment;
udsMessage.Repository = repository;
messages.Add(udsMessage);
}
return(messages);
}
private ICollection <UDSDocumentUnit> GetEntityDocumentUnits(ICollection <UDSDocumentUnitModel> udsDocumentUnitModels, UDSRepository repository)
{
ICollection <UDSDocumentUnit> documentUnits = new List <UDSDocumentUnit>();
UDSDocumentUnit udsDocumentUnit;
foreach (UDSDocumentUnitModel documentUnit in udsDocumentUnitModels)
{
udsDocumentUnit = _mapperUnitOfWork.Repository <IUDSDocumentUnitEntityMapper>().Map(documentUnit, new UDSDocumentUnit());
udsDocumentUnit.Relation = _unitOfWork.Repository <DocumentUnit>().Find(documentUnit.IdDocumentUnit);
udsDocumentUnit.Environment = repository.DSWEnvironment;
udsDocumentUnit.Repository = repository;
documentUnits.Add(udsDocumentUnit);
}
return(documentUnits);
}
protected void PrepareDocumentUnitLog(FascicleDocumentUnit entity, FascicleLog fascicleLog)
{
if (entity.DocumentUnit.Environment == (int)DSWEnvironmentType.Protocol)
{
Protocol protocol = _unitOfWork.Repository <Protocol>().GetByUniqueId(entity.DocumentUnit.UniqueId).SingleOrDefault();
ProtocolLog protocolLog = new ProtocolLog()
{
Year = entity.DocumentUnit.Year,
Number = entity.DocumentUnit.Number,
LogDate = fascicleLog.RegistrationDate.DateTime,
LogType = "FS",
Program = "Private.WebAPI",
LogDescription = fascicleLog.LogDescription,
RegistrationUser = fascicleLog.RegistrationUser,
SystemComputer = fascicleLog.SystemComputer,
Entity = protocol,
};
protocolLog.Hash = HashGenerator.GenerateHash(string.Concat(protocolLog.RegistrationUser, "|", protocolLog.Year, "|", protocolLog.Number, "|", protocolLog.LogType, "|", protocolLog.LogDescription, "|", protocolLog.UniqueId, "|", protocolLog.Entity.UniqueId, "|", protocolLog.LogDate.ToString("yyyyMMddHHmmss")));
_unitOfWork.Repository <ProtocolLog>().Insert(protocolLog);
}
if (entity.DocumentUnit.Environment == (int)DSWEnvironmentType.Resolution)
{
Resolution resolution = _unitOfWork.Repository <Resolution>().GetByUniqueId(entity.DocumentUnit.UniqueId).SingleOrDefault();
ResolutionLog resolutionLog = new ResolutionLog()
{
LogDate = fascicleLog.RegistrationDate.DateTime,
LogType = "FS",
Program = "Private.WebAPI",
LogDescription = fascicleLog.LogDescription,
RegistrationUser = fascicleLog.RegistrationUser,
SystemComputer = fascicleLog.SystemComputer,
Entity = resolution,
};
resolutionLog.Hash = HashGenerator.GenerateHash(string.Concat(resolutionLog.RegistrationUser, "|", resolutionLog.LogType, "|", resolutionLog.LogDescription, "|", resolutionLog.UniqueId, "|", resolutionLog.Entity.UniqueId, "|", resolutionLog.LogDate.ToString("yyyyMMddHHmmss")));
_unitOfWork.Repository <ResolutionLog>().Insert(resolutionLog);
}
if (entity.DocumentUnit.Environment == (int)DSWEnvironmentType.DocumentSeries)
{
DocumentSeriesItem documentSeriesItem = _unitOfWork.Repository <DocumentSeriesItem>().GetByUniqueId(entity.DocumentUnit.UniqueId).SingleOrDefault();
DocumentSeriesItemLog documentSeriesItemLog = new DocumentSeriesItemLog()
{
LogDate = fascicleLog.RegistrationDate.DateTime,
LogType = "FS",
Program = "Private.WebAPI",
LogDescription = fascicleLog.LogDescription,
RegistrationUser = fascicleLog.RegistrationUser,
SystemComputer = fascicleLog.SystemComputer,
Entity = documentSeriesItem,
};
documentSeriesItemLog.Hash = HashGenerator.GenerateHash(string.Concat(documentSeriesItemLog.RegistrationUser, "|", documentSeriesItemLog.LogType, "|", documentSeriesItemLog.LogDescription, "|", documentSeriesItemLog.UniqueId, "|", documentSeriesItemLog.Entity.UniqueId, "|", documentSeriesItemLog.LogDate.ToString("yyyyMMddHHmmss")));
_unitOfWork.Repository <DocumentSeriesItemLog>().Insert(documentSeriesItemLog);
}
if (entity.DocumentUnit.Environment >= 100)
{
UDSRepository uDSRepository = _unitOfWork.Repository <UDSRepository>().GetByIdDocumentUnit(entity.DocumentUnit.UniqueId);
UDSLog log = new UDSLog()
{
LogType = UDSLogType.Delete,
LogDescription = fascicleLog.LogDescription,
SystemComputer = string.IsNullOrEmpty(fascicleLog.SystemComputer) ? Environment.MachineName : fascicleLog.SystemComputer,
Entity = uDSRepository,
RegistrationDate = fascicleLog.RegistrationDate.DateTime,
RegistrationUser = fascicleLog.RegistrationUser,
IdUDS = entity.DocumentUnit.UniqueId,
Environment = entity.DocumentUnit.Environment,
};
log.Hash = HashGenerator.GenerateHash(string.Concat(log.RegistrationUser, "|", log.LogType, "|", log.LogDescription, "|", log.UniqueId, "|", log.IdUDS, "|", log.RegistrationDate.ToString("yyyyMMddHHmmss")));
_unitOfWork.Repository <UDSLog>().Insert(log);
}
}
