private async Task <int> FillDocument(int refDocumentId) { try { var sqlQuery = string.Format(ImportSqlQueryHelper.DocumentSqlQuery, string.Join(", ", ObjectType.GetMaterilsRouteIds()), refDocumentId); var oldDocuments = await SqlDapperConnection.QueryAsync <DdDocumentExtension>(sqlQuery, TargetConnectionString); var ddDocuments = oldDocuments.ToList(); if (!ddDocuments.Any()) { return(0); } var document = await CreateDocument(ddDocuments.FirstOrDefault()); var newDocumentId = await Executor.GetCommand <CreateDocumentCommand>().Process(d => d.ExecuteAsync(document)); document.DateCreate = new DateTimeOffset(ddDocuments.First().DateCreate.GetValueOrDefault(DateTime.Now)); Executor.GetCommand <UpdateDocumentCommand>().Process(d => d.Execute(document)); document.Id = newDocumentId; SavedDocuments.Add(document); return(newDocumentId); } catch (Exception) { return(0); } }
/// <summary> /// Импорт всех заявок за датау /// </summary> /// <param name="date">Дата сбора заявок</param> /// <returns>Список id импортированных заявок</returns> public async Task <IList <int> > ImportRequestByDate(DateTime date) { var ids = new List <int>(); var requestSqlQuery = string.Format(ImportSqlQueryHelper.RequestsByDateSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), date.ToString("dd-MM-yyyy")); var oldRequests = await SqlDapperConnection.QueryAsync <string>(requestSqlQuery, TargetConnectionString); var oldRequestNumbers = oldRequests.ToList(); if (!oldRequestNumbers.Any()) { return(null); } foreach (var oldRequest in oldRequestNumbers) { var id = await ImportFromDb(oldRequest, true); if (id == null) { continue; } ids.Add(id.Value); } return(ids); }
public async Task ImportContractFromDb(int oldContractId, int newContractId) { TargetAttachmentConnectionString = Configuration.GetConnectionString("NiisDesctopAttachmentsConnection"); TargetConnectionString = Configuration.GetConnectionString("NiisDesctopConnection"); SourceConnectionString = Configuration.GetConnectionString("DefaultConnection"); var refSqlQuey = string.Format(ImportSqlQueryHelper.ContractDocRefSqlQuery, string.Join(", ", ObjectType.GetContractRouteIds()), string.Join(", ", ObjectType.GetMaterilsRouteIds()), oldContractId); var oldRefDocuments = await SqlDapperConnection.QueryAsync <RfMessageDocument>(refSqlQuey, TargetConnectionString); foreach (var oldRefDocument in oldRefDocuments) { var refDocument = CreateContractRefDocument(oldRefDocument, newContractId); if (refDocument == null) { continue; } var oldDocumentId = refDocument.DocumentId; //Document var newDocumentId = await FillDocument(refDocument.DocumentId); if (newDocumentId == 0) { continue; } refDocument.DocumentId = newDocumentId; Executor.GetCommand <CreateContractDocumentCommand>().Process(d => d.Execute(refDocument)); await FillDocRefs(oldDocumentId, newDocumentId); } }
private async Task FillPayments(string number) { var paymentsSqlQuery = string.Format(ImportSqlQueryHelper.PaymentsSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), number); var oldPayments = await SqlDapperConnection.QueryAsync <WtPlPayment>(paymentsSqlQuery, TargetConnectionString); foreach (var oldPayment in oldPayments) { var payment = await CreatePaymen(oldPayment); if (payment == null) { continue; } var result = Executor.GetCommand <CheckExistPaymentCommand>().Process(d => d.Execute(payment)); if (result) { continue; } await Executor.GetCommand <CreatePaymentCommand>().Process(d => d.ExecuteAsync(payment)); payment.DateCreate = new DateTimeOffset(oldPayment.DateCreate.GetValueOrDefault(DateTime.Now)); Executor.GetCommand <UpdatePaymentCommand>().Process(d => d.Execute(payment)); } }
private async Task <int> FillContract(int refContractId) { try { var sqlQuery = string.Format(ImportSqlQueryHelper.ContractSqlQuery, string.Join(", ", ObjectType.GetContractRouteIds()), refContractId); var oldContacts = await SqlDapperConnection.QueryAsync <DdDocument>(sqlQuery, TargetConnectionString); var ddContracts = oldContacts.ToList(); if (!ddContracts.Any()) { return(0); } var contract = await CreateContract(ddContracts.FirstOrDefault()); var newContractId = await Executor.GetCommand <CreateContractCommand>().Process(d => d.ExecuteFullObjAsync(contract)); contract.Id = newContractId; contract.DateCreate = new DateTimeOffset(ddContracts.First().DateCreate.GetValueOrDefault(DateTime.Now)); Executor.GetCommand <UpdateContractCommand>().Process(d => d.Execute(contract)); SavedContracts.Add(contract); return(newContractId); } catch (Exception) { return(0); } }
public async Task ImportFromDb(string number, int requestId) { var refSqlQuey = string.Format(ImportSqlQueryHelper.RefSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), string.Join(", ", ObjectType.GetMaterilsRouteIds()), number); var oldRefDocuments = await SqlDapperConnection.QueryAsync <RfMessageDocument>(refSqlQuey, TargetConnectionString); foreach (var oldRefDocument in oldRefDocuments) { var refDocument = CreateRefDocument(oldRefDocument, requestId); if (refDocument == null) { continue; } var oldDocumentId = refDocument.DocumentId; //Document var newDocumentId = await FillDocument(refDocument.DocumentId); if (newDocumentId == 0) { continue; } refDocument.DocumentId = newDocumentId; Executor.GetCommand <CreateRequestDocumentCommand>().Process(d => d.Execute(refDocument)); refDocument.DateCreate = new DateTimeOffset(oldRefDocument.DateCreate.GetValueOrDefault(DateTime.Now)); Executor.GetCommand <UpdateRequestDocumentCommand>().Process(d => d.Execute(refDocument)); await FillDocRefs(oldDocumentId, newDocumentId); } }
private async Task <Request> FillRequest(string number) { try { var requestSqlQuery = string.Format(ImportSqlQueryHelper.RequestSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), number); var oldRequest = await SqlDapperConnection.QueryAsync <DdDocument>(requestSqlQuery, TargetConnectionString); var ddDocuments = oldRequest.ToList(); if (!ddDocuments.Any()) { throw new NotSupportedException("Заявка не найдена, проверьте наличие Входящего и Регистрационного номера заявки"); } var ddDocument = ddDocuments.First(); var request = await CreateRequest(ddDocument); var newRequestId = await Executor.GetCommand <CreateRequestCommand>().Process(d => d.ExecuteAsync(request)); request.Id = newRequestId; request.DateCreate = new DateTimeOffset(ddDocument.DateCreate.GetValueOrDefault(DateTime.Now)); await Executor.GetCommand <UpdateRequestCommand>().Process(d => d.ExecuteAsync(request)); SavedRequests.Add(request); return(request); } catch (Exception e) { throw new NotSupportedException($"Ошибка при импорте заявки №{number}, обратитесь к Администратору", e); } }
public async Task ImportFromDb(string number, int requestId) { var refSqlQuey = string.Format(ImportSqlQueryHelper.ContractRefSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), string.Join(", ", ObjectType.GetContractRouteIds()), number); var oldRefContracts = await SqlDapperConnection.QueryAsync <RfMessageDocument>(refSqlQuey, TargetConnectionString); foreach (var oldRefContract in oldRefContracts) { var refContract = CreateRefContract(oldRefContract, requestId); if (refContract == null) { continue; } var oldContractId = refContract.ContractId; //Contract var newContractId = await FillContract(refContract.ContractId); if (newContractId == 0) { continue; } refContract.ContractId = newContractId; Executor.GetCommand <CreateContractRequestRelationsCommand>().Process(d => d.Execute(refContract)); refContract.DateCreate = new DateTimeOffset(oldRefContract.DateCreate.GetValueOrDefault(DateTime.Now)); Executor.GetCommand <UpdateContractRequestRelationsCommand>().Process(d => d.Execute(refContract)); //ContractWorkflow await FillContractWorkflows(oldContractId, newContractId); //ContractWorkflow await FillContractCustomers(oldContractId, newContractId); //attachments await FillAttachments(oldContractId, newContractId); try { //CurrentWorkflow var currentWorkflowSqlQuery = string.Format(ImportSqlQueryHelper.ContractsCurrentWorkflowSqlQuery, newContractId); await SqlDapperConnection.ExecuteAsync(currentWorkflowSqlQuery, SourceConnectionString); //MainAttachment var setMainAttachmentSqlQuery = string.Format(ImportSqlQueryHelper.SetContractsMainAttachmentSqlQuery, newContractId); await SqlDapperConnection.ExecuteAsync(setMainAttachmentSqlQuery, SourceConnectionString); } catch (Exception) { // ignored } //Documents await _importDocumentsHelper.ImportContractFromDb(oldContractId, newContractId); } }
private async Task FillIcfems(int requestId, string number) { var icfemsSqlQuery = string.Format(ImportSqlQueryHelper.IcfemsSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), number); var icfems = await SqlDapperConnection.QueryAsync <RfTmIcfem>(icfemsSqlQuery, TargetConnectionString); foreach (var icfem in icfems) { var resuestIcfem = CreateIcfem(icfem, requestId); if (resuestIcfem == null) { continue; } Executor.GetCommand <CreateRequestIcfemCommand>().Process(d => d.Execute(resuestIcfem)); } }
private async Task FillColors(int requestId, string number) { var colorSqlQuery = string.Format(ImportSqlQueryHelper.ColorSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), number); var colors = await SqlDapperConnection.QueryAsync <RfTmIcfem>(colorSqlQuery, TargetConnectionString); foreach (var color in colors) { var resuestColor = CreateColor(color, requestId); if (resuestColor == null) { continue; } Executor.GetCommand <CreateRequestColorTzCommand>().Process(d => d.Execute(resuestColor)); } }
/// <summary> /// Создание контрагента /// </summary> /// <param name="customerId"></param> /// <returns></returns> protected async Task <int?> GetCustomer(int customerId) { var customersSqlQuery = string.Format(ImportSqlQueryHelper.DicCustomersSqlQuery, customerId); var customers = await SqlDapperConnection.QueryAsync <CustomerAddressStringExtension>(customersSqlQuery, TargetConnectionString); var ddCustomers = customers.ToList(); if (!ddCustomers.Any()) { return(null); } var customer = CreateCustomer(ddCustomers.FirstOrDefault()); if (customer == null) { return(null); } var newCustomerId = await Executor.GetCommand <CreateDicCustomerCommand>().Process(d => d.ExecuteAsync(customer)); customer.Id = newCustomerId; if (!string.IsNullOrEmpty(ddCustomers.First().Phone)) { var phone = FillContactInfo(DicContactTypesCodes.Phone, newCustomerId, ddCustomers.First().Phone); customer.ContactInfos.Add(phone); } if (!string.IsNullOrEmpty(ddCustomers.First().Fax)) { var fax = FillContactInfo(DicContactTypesCodes.Fax, newCustomerId, ddCustomers.First().Fax); customer.ContactInfos.Add(fax); } if (!string.IsNullOrEmpty(ddCustomers.First().Email)) { var email = FillContactInfo(DicContactTypesCodes.Email, newCustomerId, ddCustomers.First().Email); customer.ContactInfos.Add(email); } await Executor.GetCommand <UpdateDicCustomerCommand>().Process(d => d.ExecuteAsync(customer)); //var customerInfo = CreateCustomerInfo(newCustomerId, ddCustomers.FirstOrDefault()); //if (customerInfo == null) return null; //await Executor.GetCommand<CreateAttorneyInfoCommand>().Process(d => d.ExecuteAsync(customerInfo)); return(newCustomerId); }
private async Task FillAttachments(int oldContractId, int newContractId) { var attachmentsSqlQuery = string.Format(ImportSqlQueryHelper.DocumentsAttachmentsSqlQuery, oldContractId); var oldAttachments = await SqlDapperConnection.QueryAsync <DocumentData>(attachmentsSqlQuery, TargetAttachmentConnectionString); foreach (var oldAttachment in oldAttachments) { var attachment = await CreateAttachment(oldAttachment, newContractId); if (attachment == null) { continue; } await Executor.GetCommand <CreateAttachmentCommand>().Process(d => d.ExecuteAsync(attachment)); } }
private async Task FillContractWorkflows(int oldContractId, int newContractId) { var wfSqlQuery = string.Format(ImportSqlQueryHelper.ContractsWfSqlQuery, string.Join(", ", ObjectType.GetContractRouteIds()), oldContractId); var oldWorkflows = await SqlDapperConnection.QueryAsync <WtPtWorkoffice>(wfSqlQuery, TargetConnectionString); foreach (var oldWorkflow in oldWorkflows) { var contractWorkflow = CreateWorkflow(oldWorkflow, newContractId); if (contractWorkflow == null) { continue; } await Executor.GetCommand <CreateContractWorkflowCommand>().Process(d => d.ExecuteAsync(contractWorkflow)); contractWorkflow.DateCreate = new DateTimeOffset(oldWorkflow.DateCreate.GetValueOrDefault(DateTime.Now)); Executor.GetCommand <UpdateContractWorkflowCommand>().Process(d => d.ExecuteAsync(contractWorkflow)); } }
private async Task FillInfo(int requestId, string number) { var infoSqlQuery = string.Format(ImportSqlQueryHelper.InfoSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), number); var oldInfo = await SqlDapperConnection.QueryAsync <DdInfo>(infoSqlQuery, TargetConnectionString); var ddInfos = oldInfo.ToList(); if (!ddInfos.Any()) { return; } var resuestInfo = CreateInfo(ddInfos.FirstOrDefault(), requestId); await Executor.GetCommand <CreateRequestInfoCommand>().Process(d => d.ExecuteAsync(resuestInfo)); resuestInfo.DateCreate = new DateTimeOffset(ddInfos.First().DateCreate.GetValueOrDefault(DateTime.Now)); await Executor.GetCommand <UpdateRequestInfoCommand>().Process(d => d.ExecuteAsync(resuestInfo)); }
private async Task FillDocumentUserSignatures(int oldDocuemntId) { var userSignatureSqlQuery = string.Format(ImportSqlQueryHelper.UserSignatureSqlQuery, string.Join(", ", ObjectType.GetMaterilsRouteIds()), oldDocuemntId); var oldUsersSignaturs = await SqlDapperConnection.QueryAsync <TbDocumentUsersSignature>(userSignatureSqlQuery, TargetConnectionString); foreach (var oldUsersSignatur in oldUsersSignaturs) { var usersSignatur = CreateUsersSignatur(oldUsersSignatur); if (usersSignatur == null) { continue; } await Executor.GetCommand <CreateDocumentUserSignatureCommand>().Process(d => d.Execute(usersSignatur)); usersSignatur.DateCreate = new DateTimeOffset(oldUsersSignatur.FlSignDate.GetValueOrDefault(DateTime.Now)); await Executor.GetCommand <UpdateDocumentUserSignatureCommand>().Process(d => d.Execute(usersSignatur)); } }
private async Task FillPaymentInvoices(string number, int requestId) { var paymentInvoicesSqlQuery = string.Format(ImportSqlQueryHelper.PaymentInvoicesSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), number); var oldPaymentInvoices = await SqlDapperConnection.QueryAsync <WtPlFixpayment>(paymentInvoicesSqlQuery, TargetConnectionString); foreach (var oldPaymentInvoice in oldPaymentInvoices) { var paymentInvoice = CreatePaymentInvoice(oldPaymentInvoice, requestId); if (paymentInvoice == null) { continue; } await Executor.GetCommand <CreatePaymentInvoiceCommand>().Process(d => d.ExecuteAsync(paymentInvoice)); paymentInvoice.DateCreate = new DateTimeOffset(oldPaymentInvoice.DateCreate.GetValueOrDefault(DateTime.Now)); Executor.GetCommand <UpdatePaymentInvoiceCommand>().Process(d => d.Execute(paymentInvoice)); } }
private async Task FillIcgs(int requestId, string number) { var icgsSqlQuery = string.Format(ImportSqlQueryHelper.IcgsSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), number); var icgs = await SqlDapperConnection.QueryAsync <RfTmIcgs>(icgsSqlQuery, TargetConnectionString); foreach (var icg in icgs) { var resuestIcg = CreateIcg(icg, requestId); if (resuestIcg == null) { continue; } Executor.GetCommand <CreateRequestIcgsCommand>().Process(d => d.Execute(resuestIcg)); resuestIcg.DateCreate = new DateTimeOffset(icg.DateCreate.GetValueOrDefault(DateTime.Now)); await Executor.GetCommand <UpdateIcgsRequestCommand>().Process(d => d.ExecuteAsync(resuestIcg)); } }
private async Task FillIpc(int requestId, string number) { var ipcSqlQuery = string.Format(ImportSqlQueryHelper.IpcSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), number); var ipces = await SqlDapperConnection.QueryAsync <RfIpc>(ipcSqlQuery, TargetConnectionString); foreach (var ipc in ipces) { var resuestIpc = CreateIpc(ipc, requestId); if (resuestIpc == null) { continue; } Executor.GetCommand <CreateRequestIpcCommand>().Process(d => d.Execute(resuestIpc)); resuestIpc.DateCreate = new DateTimeOffset(ipc.DateCreate.GetValueOrDefault(DateTime.Now)); Executor.GetCommand <UpdateRequestIpcCommand>().Process(d => d.Execute(resuestIpc)); } }
private async Task FillContractCustomers(int oldContractId, int newContractId) { var customersSqlQuery = string.Format(ImportSqlQueryHelper.ContractCustomersSqlQuery, string.Join(", ", ObjectType.GetContractRouteIds()), oldContractId); var customers = await SqlDapperConnection.QueryAsync <RfCustomerAddressExtention>(customersSqlQuery, TargetConnectionString); foreach (var customer in customers) { var contractCustomer = await CreateCustomer(customer, newContractId); if (contractCustomer == null) { continue; } await Executor.GetCommand <CreateContractCustomerCommand>().Process(d => d.ExecuteAsync(contractCustomer)); contractCustomer.DateCreate = new DateTimeOffset(customer.DateCreate.GetValueOrDefault(DateTime.Now)); await Executor.GetCommand <UpdateContractCustomerCommand>().Process(d => d.ExecuteAsync(contractCustomer)); } }
private async Task FillEarlyReg(int requestId, string number) { var earlyRegsSqlQuery = string.Format(ImportSqlQueryHelper.EarlyRegsSqlQuery, string.Join(", ", ObjectType.GetRequestRouteIds()), number); var earlyRegs = await SqlDapperConnection.QueryAsync <WtPtEarlyreg>(earlyRegsSqlQuery, TargetConnectionString); foreach (var earlyReg in earlyRegs) { var resuestEarlyReg = CreateEarlyReg(earlyReg, requestId); if (resuestEarlyReg == null) { continue; } Executor.GetCommand <CreateRequestEarlyRegCommand>().Process(d => d.Execute(resuestEarlyReg)); resuestEarlyReg.DateCreate = new DateTimeOffset(earlyReg.DateCreate.GetValueOrDefault(DateTime.Now)); Executor.GetCommand <UpdateRequestEarlyRegCommand>().Process(d => d.Execute(resuestEarlyReg)); } }
private async Task FillAttachments(int newRequestId) { var request = SavedRequests.FirstOrDefault(d => d.Id == newRequestId); if (request?.ExternalId == null) { return; } var attachmentsSqlQuery = string.Format(ImportSqlQueryHelper.AttachmentsSqlQuery, request.ExternalId); var oldAttachments = await SqlDapperConnection.QueryAsync <DocumentData>(attachmentsSqlQuery, TargetAttachmentConnectionString); foreach (var oldAttachment in oldAttachments) { var attachment = await CreateAttachment(oldAttachment, request); if (attachment == null) { continue; } await Executor.GetCommand <CreateAttachmentCommand>().Process(d => d.ExecuteAsync(attachment)); } }