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 FillDocRefs(int oldDocumentId, int newDocumentId)
{
//DocumentWorkflow
await FillDocumentWorkflows(oldDocumentId, newDocumentId);
//UserSignature
await FillDocumentUserSignatures(oldDocumentId);
//Attachments
await FillAttachments(oldDocumentId, newDocumentId);
try
{
////CurrentWorkflow
//var currentWorkflowSqlQuery =
// string.Format(ImportSqlQueryHelper.DocumentsCurrentWorkflowSqlQuery, newDocumentId);
//await SqlDapperConnection.ExecuteAsync(currentWorkflowSqlQuery, SourceConnectionString);
//MainAttachment
var setMainAttachmentSqlQuery =
string.Format(ImportSqlQueryHelper.SetDocumentsMainAttachmentSqlQuery, newDocumentId);
await SqlDapperConnection.ExecuteAsync(setMainAttachmentSqlQuery, SourceConnectionString);
//Status
var setStatusSqlQuery =
string.Format(ImportSqlQueryHelper.DocumentsSetStatusSqlQuery, newDocumentId);
await SqlDapperConnection.ExecuteAsync(setStatusSqlQuery, SourceConnectionString);
}
catch (Exception)
{
// ignored
}
}
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);
}
}
/// <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);
}
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);
}
}
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);
}
}
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);
}
}
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 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 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 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 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 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 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 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 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));
}
}
/// <summary>
/// Импорт заявки по номеру
/// </summary>
/// <param name="number">Входящий Номер или номер заявки</param>
/// <param name="returnNullIfExist">Вернуть NULL если уже создан</param>
/// <returns>Id импортированной заявки</returns>
public async Task <int?> ImportFromDb(string number, bool returnNullIfExist = false)
{
var validResult = Valid(number);
if (validResult != null && validResult != 0)
{
return(!returnNullIfExist ? validResult : null);
}
//Request
var newRequest = await FillRequest(number);
var newRequestId = newRequest.Id;
number = newRequest.IncomingNumber;
//Workflow
await FillWorkflows(newRequestId, number);
//Info
await FillInfo(newRequestId, number);
//Color
await FillColors(newRequestId, number);
//Customers
await FillCustomers(newRequestId, number);
//Icfems
await FillIcfems(newRequestId, number);
//Icgs
await FillIcgs(newRequestId, number);
//Icis
await FillIcis(newRequestId, number);
//Ipc
await FillIpc(newRequestId, number);
//EarlyReg
await FillEarlyReg(newRequestId, number);
//Attachments
await FillAttachments(newRequestId);
try
{
//BeneficiaryType
var beneficiarySqlQuery = string.Format(ImportSqlQueryHelper.BeneficiarySqlQuery, number);
await SqlDapperConnection.ExecuteAsync(beneficiarySqlQuery, SourceConnectionString);
//CurrentWorkflow
var currentWorkflowSqlQuery = string.Format(ImportSqlQueryHelper.CurrentWorkflowSqlQuery, newRequestId);
await SqlDapperConnection.ExecuteAsync(currentWorkflowSqlQuery, SourceConnectionString);
//MainAttachment
var setMainAttachmentSqlQuery = string.Format(ImportSqlQueryHelper.SetRequestMainAttachmentSqlQuery, newRequestId);
await SqlDapperConnection.ExecuteAsync(setMainAttachmentSqlQuery, SourceConnectionString);
}
catch (Exception)
{
// ignored
}
//Payments
await _importPaymentsHelper.ImportFromDb(number, newRequestId);
//Documents
await _importDocumentsHelper.ImportFromDb(number, newRequestId);
//Contract
await _importContractsHelper.ImportFromDb(number, newRequestId);
return(newRequestId);
}
