public Task <Unit> Handle(Query message)
{
var code = _context.Documents.Where(d => d.Id.Equals(message.DocumentId)).Select(d => d.Type.Code)
.SingleOrDefault();
var input = _context.DocumentUserInputs.SingleOrDefault(ui => ui.DocumentId.Equals(message.DocumentId));
var dto = JsonConvert.DeserializeObject <UserInputDto>(input.UserInput);
var documentGenerator = _templateGeneratorFactory.Create(code);
var generatedDocument = documentGenerator.Process(new Dictionary <string, object>
{
{ "UserId", message.UserId },
{ "RequestId", message.OwnerId },
{ "DocumentId", message.DocumentId },
{ "UserInputFields", dto.Fields },
{ "SelectedRequestIds", dto.SelectedRequestIds },
{ "PageCount", dto.PageCount }
});
_notificationSender.ProcessEmailAsync(generatedDocument, message.DocumentId).Wait();
//_context.SaveChangesAsync().Wait();
//var notificationStatuses = _context.DocumentNotificationStatuses
// .Include(ds => ds.NotificationStatus)
// .Where(dn => dn.DocumentId.Equals(message.DocumentId))
// .Select(dn => dn.NotificationStatus);
return(Unit.Task);
}
async Task <MaterialOutgoingDetailDto> IAsyncRequestHandler <Query, MaterialOutgoingDetailDto> .Handle(
Query message)
{
var documentId = message.DocumentId;
var documentWithIncludes = await _context.Documents
.Include(d => d.Addressee)
.Include(d => d.Workflows).ThenInclude(w => w.FromStage)
.Include(d => d.Workflows).ThenInclude(w => w.CurrentStage)
.Include(d => d.Workflows).ThenInclude(w => w.FromUser)
.Include(d => d.Workflows).ThenInclude(w => w.CurrentUser)
.Include(d => d.Workflows).ThenInclude(w => w.Route)
.Include(d => d.Workflows).ThenInclude(w => w.DocumentUserSignature)
.Include(d => d.MainAttachment)
.Include(d => d.Requests)
.Include(d => d.Contracts)
.Include(d => d.ProtectionDocs)
.SingleOrDefaultAsync(r => r.Id == documentId);
if (documentWithIncludes == null)
{
throw new DataNotFoundException(nameof(Document),
DataNotFoundException.OperationType.Read, documentId);
}
var result = _mapper.Map <Document, MaterialOutgoingDetailDto>(documentWithIncludes);
var requestsOwnerDtos = _mapper.Map <RequestDocument[], MaterialOwnerDto[]>(documentWithIncludes.Requests.ToArray());
var contractOwnerDtos = _mapper.Map <ContractDocument[], MaterialOwnerDto[]>(documentWithIncludes.Contracts.ToArray());
var protectionDocOwnerDtos = _mapper.Map <ProtectionDocDocument[], MaterialOwnerDto[]>(documentWithIncludes.ProtectionDocs.ToArray());
result.Owners = requestsOwnerDtos.Concat(contractOwnerDtos.Concat(protectionDocOwnerDtos)).ToArray();
var input = await _context.DocumentUserInputs
.SingleOrDefaultAsync(i => i.DocumentId == documentId);
if (input != null)
{
result.UserInput = JsonConvert.DeserializeObject <UserInputDto>(input.UserInput);
if (documentWithIncludes.MainAttachmentId == null)
{
var documentGenerator = _templateGeneratorFactory.Create(result.UserInput.Code);
var generatedFile = documentGenerator.Process(new Dictionary <string, object>
{
{ "UserId", message.UserId },
{ "RequestId", result.UserInput.OwnerId },
{ "DocumentId", result.UserInput.DocumentId },
{ "UserInputFields", result.UserInput.Fields },
{ "SelectedRequestIds", result.UserInput.SelectedRequestIds },
{ "PageCount", result.PageCount }
});
result.PageCount = generatedFile.PageCount;
}
else
{
result.PageCount = documentWithIncludes.MainAttachment.PageCount;
}
}
return(result);
}
/// <summary>
/// Создает документ (патент или сертификат) и прикрепляет его к охранному документу.
/// </summary>
/// <param name="id">Идентификатор охранного документа.</param>
/// <param name="userId">Идентификатор исполнителя.</param>
/// <returns>Асинхронная операция.</returns>
private async Task CreatePatentOrCertificate(int id, int?userId)
{
var protectionDoc = await Executor
.GetQuery <GetProtectionDocByIdQuery>()
.Process(q => q.ExecuteAsync(id));
if (protectionDoc is null)
{
throw new DataNotFoundException(nameof(ProtectionDoc), DataNotFoundException.OperationType.Read, 0);
}
string patentCode = GetPatentCode(protectionDoc);
var userInputDto = new UserInputDto
{
Code = patentCode,
Fields = new List <KeyValuePair <string, string> >(),
OwnerId = id,
OwnerType = Owner.Type.ProtectionDoc
};
var documentId = await CreateDocument(id, Owner.Type.ProtectionDoc, patentCode, DocumentType.Outgoing, userInputDto, userId);
var documentGenerator = _templateGeneratorFactory.Create(patentCode);
if (documentGenerator != null)
{
protectionDoc.PageCount = GenerateDocumentAndGetPagesCount(documentGenerator, documentId, userInputDto);
}
await Executor.GetCommand <UpdateProtectionDocCommand>().Process(c => c.ExecuteAsync(id, protectionDoc));
}
/// <summary>
/// Генерирует документ из шаблона.
/// </summary>
/// <param name="documentTypeCode">Код типа документа. Коды документов: <see cref="Iserv.Niis.Common.Codes.DicDocumentTypeCodes"/> </param>
/// <param name="documentParameters">Данные, которые используются для генерации документа.</param>
/// <returns>Сгенерированный документ.</returns>
public GeneratedDocument GenerateDocument(string documentTypeCode, Dictionary <string, object> documentParameters)
{
var documentGenerator = _documentGeneratorFactory.Create(documentTypeCode);
if (documentGenerator is null)
{
throw new ArgumentException("В системе нет генератора документа для данного типа документа.", nameof(documentTypeCode));
}
return(documentGenerator.Process(documentParameters));
}
public async Task <Document> Handle(Command message)
{
var document = await _context.Documents.SingleAsync(d => d.Id == message.DocumentId);
_numberGenerator.GenerateOutgoingNum(document);
document.SendingDate = DateTimeOffset.Now;
await _generatedNumberApplierForRequest.ApplyAsync(document.Id);
await _generatedNumberApplierForContract.ApplyAsync(document.Id);
await _context.SaveChangesAsync();
var doc = _context.Documents
.Include(d => d.Type)
.SingleOrDefault(d => d.Id == document.Id);
var input = _context.DocumentUserInputs.SingleOrDefault(ui =>
ui.DocumentId == document.Id);
var dto = JsonConvert.DeserializeObject <UserInputDto>(input.UserInput);
var documentGenerator = _templateGeneratorFactory.Create(doc.Type.Code);
var generatedDocument = documentGenerator.Process(new Dictionary <string, object>
{
{ "UserId", message.CurrentUserId },
{ "RequestId", dto.OwnerId },
{ "DocumentId", document.Id },
{ "UserInputFields", dto.Fields },
{ "SelectedRequestIds", dto.SelectedRequestIds },
{ "PageCount", dto.PageCount }
});
await _notificationTaskRegister.RegisterDocumentAsync(document.Id, generatedDocument.File);
await _context.SaveChangesAsync();
return(document);
}
public async Task <IActionResult> Get(int id, bool wasScanned, bool isMain)
{
byte[] file;
var contentType = string.Empty;
var validName = string.Empty;
//todo: Почему не работает ProcessAsync?
var document = await _executor.GetQuery <GetDocumentByIdQuery>().Process(q => q.ExecuteAsync(id));
if (document == null)
{
throw new DataNotFoundException(nameof(Domain.Entities.Document.Document), DataNotFoundException.OperationType.Read, id);
}
var input = await _executor.GetQuery <GetDocumentUserInputByDocumentIdQuery>().Process(q => q.ExecuteAsync(document.Id));
if (input != null && !wasScanned)
{
var dto = JsonConvert.DeserializeObject <UserInputDto>(input.UserInput);
var documentGenerator = _templateGeneratorFactory.Create(dto.Code);
var generatedFile = documentGenerator.Process(new Dictionary <string, object>
{
{ "UserId", NiisAmbientContext.Current.User.Identity.UserId },
{ "RequestId", dto.OwnerId },
{ "DocumentId", id },
{ "UserInputFields", dto.Fields },
{ "SelectedRequestIds", dto.SelectedRequestIds },
{ "PageCount", dto.PageCount },
{ "OwnerType", dto.OwnerType },
{ "Index", dto.Index }
});
file = generatedFile.File;
contentType = ContentType.Pdf;
var typeNameRu = document?.Type?.NameRu;
if (document.Type.Code == DicDocumentTypeCodes.NotificationOfRegistrationDecision && !string.IsNullOrEmpty(document.OutgoingNumber))
{
var documentLinksIds = new List <int>();
documentLinksIds = document.DocumentLinks.Where(d => d.ChildDocument.Type.Code == DicDocumentTypeCodes.ExpertTmRegisterOpinion).Select(d => d.ChildDocumentId).ToList();
documentLinksIds.AddRange(document.DocumentParentLinks.Where(d => d.ParentDocument.Type.Code == DicDocumentTypeCodes.ExpertTmRegisterOpinion).Select(d => d.ParentDocumentId).ToList().Where(d => !documentLinksIds.Contains(d)));
var linkFiles = new List <byte[]>();
linkFiles.Add(file);
foreach (var documentLinksId in documentLinksIds)
{
var linkFile = await GetFileByte(documentLinksId);
if (linkFile == null)
{
continue;
}
else
{
linkFiles.Add(linkFile);
}
}
if (linkFiles.Count > 0)
{
var result = MergeFile(linkFiles);
return(string.IsNullOrWhiteSpace(typeNameRu)
? File(result, contentType)
: File(result, contentType, typeNameRu));
}
}
return(string.IsNullOrWhiteSpace(typeNameRu)
? File(file, contentType)
: File(file, contentType, typeNameRu));
}
Attachment attachment = null;
if (isMain && document.MainAttachment != null)
{
attachment = document.MainAttachment;
contentType = document.MainAttachment.ContentType;
validName = document.MainAttachment.ValidName;
}
else if (document.AdditionalAttachments.Any(d => d.IsMain == false))
{
attachment = document.AdditionalAttachments.FirstOrDefault(d => d.IsMain == false);
contentType = attachment?.ContentType;
validName = attachment?.ValidName;
}
if (attachment != null)
{
var fileContent = await _fileStorage.GetAsync(attachment.BucketName, attachment.OriginalName);
var extention = Path.GetExtension(attachment.OriginalName);
if (extention != null && extention.ToLower().Contains("odt"))
{
using (var memoryStream = new MemoryStream())
{
memoryStream.Write(fileContent, 0, fileContent.Length);
memoryStream.Seek(0, SeekOrigin.Begin);
var newName = validName.Replace(".odt", ".pdf");
var pdf = _fileConverter.DocxToPdf(memoryStream, newName);
return(File(pdf.File, contentType, newName));
}
}
file = fileContent;
return(File(file, contentType, validName));
}
return(null);
}
public async Task <MaterialInternalDetailDto> Handle(Command message)
{
var document = _mapper.Map <Document>(message.MaterialDetailDto);
document.DocumentType = DocumentType.Internal;
using (var transaction = await _context.Database.BeginTransactionAsync())
{
_numberGenerator.GenerateBarcode(document);
await _context.AddAsync(document);
await _context.SaveChangesAsync();
foreach (var materialOwnerDto in message.MaterialDetailDto.Owners)
{
switch (materialOwnerDto.OwnerType)
{
case Owner.Type.Request:
{
var request = await _context.Requests.SingleAsync(r => r.Id == materialOwnerDto.OwnerId);
request.Documents.Add(new RequestDocument {
Document = document
});
break;
}
case Owner.Type.Contract:
var contract = await _context.Contracts.SingleAsync(c => c.Id == materialOwnerDto.OwnerId);
contract.Documents.Add(new ContractDocument {
Document = document
});
break;
case Owner.Type.ProtectionDoc:
var protectionDoc =
await _context.ProtectionDocs.SingleAsync(pd => pd.Id == materialOwnerDto.OwnerId);
protectionDoc.Documents.Add(new ProtectionDocDocument {
Document = document
});
break;
}
}
await _documentWorkflowApplier.ApplyInitialAsync(document, message.UserId);
var documentGenerator = _templateGeneratorFactory.Create(message.MaterialDetailDto.UserInput.Code);
var generatedFile = documentGenerator?.Process(new Dictionary <string, object>
{
{ "UserId", message.UserId },
{ "RequestId", message.MaterialDetailDto.UserInput.OwnerId },
{ "DocumentId", document.Id },
{ "UserInputFields", message.MaterialDetailDto.UserInput.Fields },
{ "SelectedRequestIds", message.MaterialDetailDto.UserInput.SelectedRequestIds },
{ "PageCount", message.MaterialDetailDto.PageCount }
});
message.MaterialDetailDto.UserInput.DocumentId = document.Id;
message.MaterialDetailDto.UserInput.PageCount = generatedFile?.PageCount;
var input = new DocumentUserInput
{
DocumentId = document.Id,
UserInput = JsonConvert.SerializeObject(message.MaterialDetailDto.UserInput)
};
_context.DocumentUserInputs.Add(input);
await _context.SaveChangesAsync();
await _requestDocumentApplier.ApplyAsync(document.Id);
await _contractDocumentApplier.ApplyAsync(document.Id);
var documentWithIncludes = await _context.Documents
.Include(d => d.Addressee)
.Include(d => d.Workflows).ThenInclude(w => w.FromStage)
.Include(d => d.Workflows).ThenInclude(w => w.CurrentStage)
.Include(d => d.Workflows).ThenInclude(w => w.FromUser)
.Include(d => d.Workflows).ThenInclude(w => w.CurrentUser)
.Include(d => d.Workflows).ThenInclude(w => w.Route)
.Include(d => d.MainAttachment)
.Include(d => d.Requests)
.Include(d => d.Contracts)
.SingleOrDefaultAsync(r => r.Id == document.Id);
transaction.Commit();
var result = _mapper.Map <MaterialInternalDetailDto>(documentWithIncludes);
var requestsOwnerDtos = _mapper.Map <RequestDocument[], MaterialOwnerDto[]>(documentWithIncludes.Requests.ToArray());
var contractOwnerDtos = _mapper.Map <ContractDocument[], MaterialOwnerDto[]>(documentWithIncludes.Contracts.ToArray());
var protectionDocOwnerDtos = _mapper.Map <ProtectionDocDocument[], MaterialOwnerDto[]>(documentWithIncludes.ProtectionDocs.ToArray());
result.Owners = requestsOwnerDtos.Concat(contractOwnerDtos.Concat(protectionDocOwnerDtos)).ToArray();
return(result);
}
}
public async Task <MaterialOutgoingDetailDto> Handle(Command message)
{
var documentId = message.DocumentId;
var material = message.MaterialDetailDto;
var document = await _context.Documents
.Include(d => d.Type)
.SingleOrDefaultAsync(r => r.Id == documentId);
if (document == null)
{
throw new DataNotFoundException(nameof(Document),
DataNotFoundException.OperationType.Update, documentId);
}
_mapper.Map(material, document);
await _requestDocumentApplier.ApplyAsync(documentId);
await _contractDocumentApplier.ApplyAsync(documentId);
await _context.SaveChangesAsync();
var requestLinksToRemove = _context.RequestsDocuments
.Where(rd => rd.DocumentId == documentId &&
!material.Owners.Where(o => o.OwnerType == Owner.Type.Request)
.Select(o => o.OwnerId).Contains(rd.RequestId));
var requestLinksToAdd = _context.Requests
.Where(r => material.Owners.Where(o => o.OwnerType == Owner.Type.Request)
.Select(o => o.OwnerId).Contains(r.Id))
.Where(r => r.Documents.All(rd => rd.DocumentId != documentId))
.Select(r => new RequestDocument {
RequestId = r.Id, DocumentId = documentId
})
.ToList();
_context.RequestsDocuments.RemoveRange((requestLinksToRemove));
await _context.RequestsDocuments.AddRangeAsync(requestLinksToAdd);
await _context.SaveChangesAsync();
var contractLinksToRemove = _context.ContractsDocuments
.Where(rd => rd.DocumentId == documentId &&
!material.Owners.Where(o => o.OwnerType == Owner.Type.Contract)
.Select(o => o.OwnerId).Contains(rd.ContractId));
var contractLinksToAdd = _context.Contracts
.Where(c => material.Owners.Where(o => o.OwnerType == Owner.Type.Contract)
.Select(o => o.OwnerId).Contains(c.Id))
.Where(c => c.Documents.All(cd => cd.DocumentId != documentId))
.Select(c => new ContractDocument {
ContractId = c.Id, DocumentId = documentId
})
.ToList();
_context.ContractsDocuments.RemoveRange(contractLinksToRemove);
await _context.ContractsDocuments.AddRangeAsync(contractLinksToAdd);
await _context.SaveChangesAsync();
var protectionDocsLinksToRemove = _context.ProtectionDocDocuments
.Where(pd => pd.DocumentId == documentId &&
!material.Owners.Where(o => o.OwnerType == Owner.Type.ProtectionDoc)
.Select(o => o.OwnerId).Contains(pd.ProtectionDocId));
var protectionDocsLinksToAdd = _context.ProtectionDocs
.Where(pd => material.Owners.Where(o => o.OwnerType == Owner.Type.ProtectionDoc)
.Select(o => o.OwnerId).Contains(pd.Id))
.Where(c => c.Documents.All(pd => pd.DocumentId != documentId))
.Select(c => new ProtectionDocDocument {
ProtectionDocId = c.Id, DocumentId = documentId
})
.ToList();
_context.ProtectionDocDocuments.RemoveRange(protectionDocsLinksToRemove);
await _context.ProtectionDocDocuments.AddRangeAsync(protectionDocsLinksToAdd);
await _context.SaveChangesAsync();
var input = await _context.DocumentUserInputs
.SingleOrDefaultAsync(i => i.DocumentId == documentId);
if (input == null)
{
input = new DocumentUserInput
{
DocumentId = document.Id,
UserInput = JsonConvert.SerializeObject(message.MaterialDetailDto.UserInput)
};
_context.DocumentUserInputs.Add(input);
}
else
{
input.UserInput = JsonConvert.SerializeObject(message.MaterialDetailDto.UserInput);
}
try
{
await _context.SaveChangesAsync();
var documentWithIncludes = await _context.Documents
.Include(r => r.Addressee)
.Include(r => r.Workflows).ThenInclude(r => r.FromStage)
.Include(r => r.Workflows).ThenInclude(r => r.CurrentStage)
.Include(r => r.Workflows).ThenInclude(r => r.FromUser)
.Include(r => r.Workflows).ThenInclude(r => r.CurrentUser)
.Include(r => r.Workflows).ThenInclude(r => r.Route)
.Include(r => r.Workflows).ThenInclude(r => r.DocumentUserSignature)
.Include(r => r.MainAttachment)
.Include(r => r.Requests)
.Include(d => d.Contracts)
.Include(d => d.ProtectionDocs)
.SingleOrDefaultAsync(r => r.Id == documentId);
var result = _mapper.Map <Document, MaterialOutgoingDetailDto>(documentWithIncludes);
var requestsOwnerDtos = _mapper.Map <RequestDocument[], MaterialOwnerDto[]>(documentWithIncludes.Requests.ToArray());
var contractOwnerDtos = _mapper.Map <ContractDocument[], MaterialOwnerDto[]>(documentWithIncludes.Contracts.ToArray());
var protectionDocOwnerDtos = _mapper.Map <ProtectionDocDocument[], MaterialOwnerDto[]>(documentWithIncludes.ProtectionDocs.ToArray());
result.Owners = requestsOwnerDtos.Concat(contractOwnerDtos.Concat(protectionDocOwnerDtos)).ToArray();
result.UserInput = JsonConvert.DeserializeObject <UserInputDto>(input.UserInput);
if (document.MainAttachmentId == null)
{
var documentGenerator = _templateGeneratorFactory.Create(result.UserInput.Code);
var generatedFile = documentGenerator.Process(new Dictionary <string, object>
{
{ "UserId", message.UserId },
{ "RequestId", result.UserInput.OwnerId },
{ "DocumentId", result.UserInput.DocumentId },
{ "UserInputFields", result.UserInput.Fields },
{ "SelectedRequestIds", result.UserInput.SelectedRequestIds },
{ "PageCount", result.PageCount }
});
result.PageCount = generatedFile.PageCount;
}
else
{
result.PageCount = document.MainAttachment.PageCount;
}
return(result);
}
catch (Exception e)
{
throw new DatabaseException(e.InnerException?.Message ?? e.Message);
}
}