public NomDo(DocCorrespondent d)
: this()
{
if (d != null && d.Correspondent != null)
{
this.Alias = d.Correspondent.Alias;
this.IsActive = d.Correspondent.IsActive;
this.Name = d.Correspondent.DisplayName;
this.NomValueId = d.Correspondent.CorrespondentId;
}
}
public DocCorrespondentDO(DocCorrespondent d)
{
if (d != null)
{
this.DocCorrespondentId = d.DocCorrespondentId;
this.DocId = d.DocId;
this.CorrespondentId = d.CorrespondentId;
this.Version = d.Version;
if (d.Correspondent != null)
{
this.CorrespondentDisplayName = d.Correspondent.DisplayName;
this.CorrespondentEmail = d.Correspondent.Email;
this.CorrespondentCorrespondentTypeName = d.Correspondent.CorrespondentType != null ? d.Correspondent.CorrespondentType.Name : string.Empty;
this.CorrespondentRegisterIndexCodeName = d.Correspondent.RegisterIndex != null ? string.Format("{0} {1}", d.Correspondent.RegisterIndex.Code, d.Correspondent.RegisterIndex.Name) : string.Empty;
this.BgCitizenFirstName = d.Correspondent.BgCitizenFirstName;
this.BgCitizenLastName = d.Correspondent.BgCitizenLastName;
this.BgCitizenUIN = d.Correspondent.BgCitizenUIN;
this.LegalEntityName = d.Correspondent.LegalEntityName;
this.LegalEntityBulstat = d.Correspondent.LegalEntityBulstat;
}
}
}
public void Process(int pendingIncomingDocId)
{
try
{
using (var transaction = this.unitOfWork.BeginTransaction())
{
//Init user variables
User systemUser = this.unitOfWork.DbContext.Set<User>().Single(e => e.Username == "system");
UnitUser systemUnitUser = this.unitOfWork.DbContext.Set<UnitUser>().Include(e => e.Unit).Single(e => e.UserId == systemUser.UserId);
UserContext systemUserContext = new UserContext(systemUser.UserId);
IncomingDoc incomingDoc = this.unitOfWork.DbContext.Set<IncomingDoc>()
.Include(e => e.IncomingDocFiles)
.Where(e => e.IncomingDocId == pendingIncomingDocId)
.Single();
IncomingDocFile incomingDocFile = incomingDoc.IncomingDocFiles.First();
string xmlContent = incomingDocFile.DocFileContent;
object rioApplication = rioDocumentParser.XmlDeserializeApplication(xmlContent);
ApplicationDataDo applicationDataDo = rioObjectExtractor.Extract<ApplicationDataDo>(rioApplication);
IList<AttachedDocDo> attachedDocuments = rioObjectExtractor.Extract<IList<AttachedDocDo>>(rioApplication);
MarkAttachedFilesAsUsed(attachedDocuments);
List<ElectronicDocumentDiscrepancyTypeNomenclature> discrepancies = GetValidationDiscrepancies(xmlContent, applicationDataDo, attachedDocuments);
bool isDocAcknowledged = discrepancies.Count == 0;
incomingDoc.IncomingDocStatusId = this.unitOfWork.DbContext.Set<IncomingDocStatus>()
.Where(e => e.Alias == (isDocAcknowledged ? "Registered" : "NotRegistered"))
.Single()
.IncomingDocStatusId;
List<Correspondent> docCorrespondents = this.GetDocumentCorrespondents(applicationDataDo.ElectronicServiceApplicant, applicationDataDo.ElectronicServiceApplicantContactData);
foreach (var correspondent in docCorrespondents.Where(c => c.CorrespondentId == 0))
{
this.unitOfWork.DbContext.Set<Correspondent>().Add(correspondent);
this.unitOfWork.Save();
}
//TODO: Implement
//var validationErrors = rioValidator.ValidateRioApplication(null, xmlContent)
List<string> validationErrors = new List<string>();
Doc rootDoc = null;
if (applicationDataDo.DocumentURI != null)
{
string regIndex = applicationDataDo.DocumentURI.RegisterIndex.PadLeft(4, '0');
int regNumber = int.Parse(applicationDataDo.DocumentURI.SequenceNumber);
DateTime regdDate = applicationDataDo.DocumentURI.ReceiptOrSigningDate.Value;
rootDoc = this.docRepository.GetDocByRegUri(regIndex, regNumber, regdDate);
}
string electronicServiceFileTypeUri = String.Format("{0}-{1}", applicationDataDo.DocumentTypeURI.RegisterIndex, applicationDataDo.DocumentTypeURI.BatchNumber);
int docTypeId = this.unitOfWork.DbContext.Set<DocType>().Single(e => e.ElectronicServiceFileTypeUri == electronicServiceFileTypeUri).DocTypeId;
//Initial Doc
Doc initialDoc = CreateInitialDoc(isDocAcknowledged, validationErrors, docTypeId, rootDoc == null, systemUser);
this.unitOfWork.DbContext.Set<Doc>().Add(initialDoc);
foreach (var correspondent in docCorrespondents)
{
DocCorrespondent docCorrespondent = new DocCorrespondent();
docCorrespondent.Doc = initialDoc;
docCorrespondent.Correspondent = correspondent;
this.unitOfWork.DbContext.Set<DocCorrespondent>().Add(docCorrespondent);
}
DocIncomingDoc initialDocIncomingDoc = new DocIncomingDoc();
initialDocIncomingDoc.Doc = initialDoc;
initialDocIncomingDoc.IncomingDoc = incomingDoc;
initialDocIncomingDoc.IsDocInitial = true;
initialDocIncomingDoc.CreateDate = DateTime.Now;
this.unitOfWork.DbContext.Set<DocIncomingDoc>().Add(initialDocIncomingDoc);
this.unitOfWork.Save();
DocRelation initialDocRelation = CreateInitialDocRelation(initialDoc, rootDoc);
this.unitOfWork.DbContext.Set<DocRelation>().Add(initialDocRelation);
this.unitOfWork.Save();
this.docRepository.RegisterDoc(initialDoc, systemUnitUser, systemUserContext);
AddDocUnit(initialDoc, systemUnitUser.Unit, systemUser);
var parentDocClassifications = AddDocClassification(initialDoc, systemUser);
this.unitOfWork.Save();
this.docRepository.ExecSpSetDocTokens(docId: initialDoc.DocId);
this.docRepository.ExecSpSetDocUnitTokens(docId: initialDoc.DocId);
initialDoc.SetReceiptOrder(this.docRepository.GetNextReceiptOrder(initialDoc.DocId), systemUserContext);
Guid fileKey = WriteToBlob(Utf8Utils.GetBytes(incomingDocFile.DocFileContent));
DocFileKind publicDocFileKind = this.unitOfWork.DbContext.Set<DocFileKind>().Single(e => e.Alias == "PublicAttachedFile");
var docFileType = this.unitOfWork.DbContext.Set<DocFileType>().SingleOrDefault(e => e.Alias == applicationDataDo.DocFileTypeAlias);
DocFile initialDocFile = CreateInitialDocFile(initialDoc, fileKey, docFileType.DocFileTypeId, publicDocFileKind.DocFileKindId, applicationDataDo.ApplicationSigningTime);
this.unitOfWork.DbContext.Set<DocFile>().Add(initialDocFile);
//Add attached application files as DocFiles
if (attachedDocuments != null && attachedDocuments.Count > 0)
{
foreach (var attachedAppFile in attachedDocuments)
{
byte[] fileContent = null;
if (attachedAppFile.UseAbbcdn)
{
fileContent = AbbcdnStorage.DownloadFile(Guid.Parse(attachedAppFile.UniqueIdentifier)).ContentBytes;
}
else
{
fileContent = attachedAppFile.BytesContent;
}
Guid key = WriteToBlob(fileContent);
DocFile attachedAppDocFile = CreateEApplicationAttachDocFile(attachedAppFile, initialDoc, publicDocFileKind.DocFileKindId, key);
this.unitOfWork.DbContext.Set<DocFile>().Add(attachedAppDocFile);
}
}
this.unitOfWork.Save();
//ReceiptDoc
Doc receiptDoc = CreateReceiptDoc(isDocAcknowledged, systemUser);
this.unitOfWork.DbContext.Set<Doc>().Add(receiptDoc);
DocIncomingDoc receiptDocIncomingDoc = new DocIncomingDoc();
receiptDocIncomingDoc.Doc = receiptDoc;
receiptDocIncomingDoc.IncomingDoc = incomingDoc;
receiptDocIncomingDoc.IsDocInitial = false;
receiptDocIncomingDoc.CreateDate = DateTime.Now;
this.unitOfWork.DbContext.Set<DocIncomingDoc>().Add(receiptDocIncomingDoc);
this.unitOfWork.Save();
DocRelation receiptDocRelation = CreateReceiptDocRelation(initialDoc, receiptDoc, rootDoc);
this.unitOfWork.DbContext.Set<DocRelation>().Add(receiptDocRelation);
this.unitOfWork.Save();
this.docRepository.RegisterDoc(receiptDoc, systemUnitUser, systemUserContext);
AddDocUnit(receiptDoc, systemUnitUser.Unit, systemUser);
AddDocClassification(receiptDoc, systemUser);
foreach (var item in parentDocClassifications.Where(i => i.IsInherited))
{
receiptDoc.CreateDocClassification(item.ClassificationId, item.IsInherited, systemUserContext);
}
this.unitOfWork.Save();
this.docRepository.ExecSpSetDocTokens(docId: receiptDoc.DocId);
this.docRepository.ExecSpSetDocUnitTokens(docId: receiptDoc.DocId);
receiptDoc.SetReceiptOrder(this.docRepository.GetNextReceiptOrder(receiptDoc.DocId), systemUserContext);
Guid receiptFileKey = CreateReceiptDocFileContent(initialDoc, receiptDoc, rootDoc, discrepancies, applicationDataDo);
DocFile receiptDocFile = CreateReceiptDocFile(publicDocFileKind.DocFileKindId, receiptDoc, receiptFileKey, isDocAcknowledged);
this.unitOfWork.DbContext.Set<DocFile>().Add(receiptDocFile);
// TODO
//if (applicationDataDo.SendConfirmationEmail)
//{
AddReceiveConfirmationEmailRecord(isDocAcknowledged, systemUser, docCorrespondents, rootDoc ?? initialDoc, discrepancies);
//}
this.unitOfWork.Save();
AddBeginningServiceStage(docTypeId, initialDoc);
AddCheckRegularityServiceStage(docTypeId, initialDoc);
this.unitOfWork.Save();
transaction.Commit();
}
}
catch (Exception ex)
{
logger.Error("IncommingDocProcessor Exception: " + Helper.GetDetailedExceptionInfo(ex));
using (var factory = unitOfWorkFactory())
{
this.unitOfWork = factory.Value;
var incomingDoc = this.unitOfWork.DbContext.Set<IncomingDoc>().SingleOrDefault(e => e.IncomingDocId == pendingIncomingDocId);
incomingDoc.IncomingDocStatusId = this.unitOfWork.DbContext.Set<IncomingDocStatus>().Single(e => e.Alias == "Incorrect").IncomingDocStatusId;
this.unitOfWork.Save();
}
}
}