public async Task CreateBillingRequest(List <BillingRequest> billingRequests)
{
foreach (var billing in billingRequests)
{
try
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(billing.BillingSystemId);
var validator = GetValidator(sapSystem);
validator.ValidateRequest(billing);
var billingRequest = GetMapper(sapSystem).MapDopplerBillingRequestToSapSaleOrder(billing);
_queuingService.AddToTaskQueue(
new SapTask
{
BillingRequest = billingRequest,
TaskType = SapTaskEnum.BillingRequest
}
);
}
catch (Exception e)
{
_logger.LogError($"Failed at generating billing request for user: {billing.Id}. Error: {e.Message}");
await _slackService.SendNotification($"Failed at generating billing request for user: {billing.Id}. Error: {e.Message}");
}
}
}
public async Task <InvoiceResponse> GetInvoiceByDopplerInvoiceIdAndOrigin(int billingSystemId, int dopplerInvoiceId, string origin)
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(billingSystemId);
var response = await _sapServiceSettingsFactory.CreateHandler(sapSystem).TryGetInvoiceByInvoiceIdAndOrigin(dopplerInvoiceId, origin);
return((response != null) ? GetMapper(sapSystem).MapToInvoice(response) : null);
}
public async Task <SapTaskResult> Handle(SapTask dequeuedTask)
{
try
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(dequeuedTask.DopplerUser.BillingSystemId);
var sapTaskHandler = _sapServiceSettingsFactory.CreateHandler(sapSystem);
dequeuedTask = await sapTaskHandler.CreateBusinessPartnerFromDopplerUser(dequeuedTask);
return(!dequeuedTask.ExistentBusinessPartner.CreateDate.HasValue ?
await CreateBusinessPartner(dequeuedTask, sapSystem) :
await UpdateBusinessPartner(dequeuedTask, sapSystem));
}
catch (Exception ex)
{
var exceptionMessage = $"Failed to create or update the Business Partner for the user: {(dequeuedTask.BusinessPartner?.CardCode ?? string.Empty)}. Error: {ex.Message}";
_logger.LogError(ex, exceptionMessage);
return(new SapTaskResult
{
IsSuccessful = false,
IdUser = dequeuedTask.DopplerUser?.Id.ToString(),
SapResponseContent = exceptionMessage,
TaskName = "Create Or Update Business Partner"
});
}
}
public async Task <SapTaskResult> Handle(SapTask dequeuedTask)
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(dequeuedTask.DopplerUser.BillingSystemId);
var sapTaskHandler = _sapServiceSettingsFactory.CreateHandler(sapSystem);
dequeuedTask = await sapTaskHandler.CreateBusinessPartnerFromDopplerUser(dequeuedTask);
return(!dequeuedTask.ExistentBusinessPartner.CreateDate.HasValue ?
await CreateBusinessPartner(dequeuedTask, sapSystem) :
await UpdateBusinessPartner(dequeuedTask, sapSystem));
}
public async Task <SapTaskResult> Handle(SapTask dequeuedTask)
{
try
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(dequeuedTask.CreditNoteRequest.BillingSystemId);
var sapTaskHandler = _sapServiceSettingsFactory.CreateHandler(sapSystem);
var existentInvoice = await sapTaskHandler.TryGetInvoiceByInvoiceIdAndOrigin(dequeuedTask.CreditNoteRequest.InvoiceId, "doppler");
if (existentInvoice != null)
{
var sapResponse = await CreateCreditNote(existentInvoice, dequeuedTask, sapSystem);
if (sapResponse.IsSuccessful)
{
if (dequeuedTask.CreditNoteRequest.Type == (int)CreditNoteEnum.Refund &&
dequeuedTask.CreditNoteRequest.TransactionApproved)
{
var response = JsonConvert.DeserializeObject <SapCreditNoteResponse>(sapResponse.SapResponseContent);
return(await SendOutgoingPaymentToSap(sapSystem, response, dequeuedTask.CreditNoteRequest.TransferReference));
}
}
else
{
_logger.LogError($"Credit Note could'n create to SAP because exists an error: '{sapResponse.SapResponseContent}'.");
}
return(sapResponse);
}
else
{
return(new SapTaskResult
{
IsSuccessful = false,
IdUser = dequeuedTask.CreditNoteRequest?.ClientId.ToString(),
SapResponseContent = $"Credit Note could'n create to SAP because the invoice does not exist: '{dequeuedTask.CreditNoteRequest?.InvoiceId}'.",
TaskName = "Creating Credit Note Request"
});
}
}
catch (Exception ex)
{
return(new SapTaskResult
{
IsSuccessful = false,
IdUser = dequeuedTask.CreditNoteRequest?.ClientId.ToString(),
SapResponseContent = $"Error creating Credit Note for Invoice Id: '{ dequeuedTask.CreditNoteRequest.InvoiceId }'. Message: '{ ex.Message}'",
TaskName = "Creating Credit Note Request"
});
}
}
public async Task <SapTaskResult> Handle(SapTask dequeuedTask)
{
try
{
var origin = dequeuedTask.BillingRequest.PlanType == 5 ? "relay" : "doppler";
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(dequeuedTask.BillingRequest.BillingSystemId);
var sapTaskHandler = _sapServiceSettingsFactory.CreateHandler(sapSystem);
var existentInvoice = dequeuedTask.BillingRequest.InvoiceId != 0 ? await sapTaskHandler.TryGetInvoiceByInvoiceIdAndOrigin(dequeuedTask.BillingRequest.InvoiceId, origin) : null;
var sapResponse = (dequeuedTask.TaskType == Enums.SapTaskEnum.BillingRequest) ? await CreateInvoice(dequeuedTask, sapSystem) : await UpdateInvoice(dequeuedTask, sapSystem, existentInvoice);
if (sapResponse.IsSuccessful)
{
var serviceSetting = SapServiceSettings.GetSettings(_sapConfig, sapSystem);
if (serviceSetting.BillingConfig.NeedCreateIncomingPayments &&
dequeuedTask.BillingRequest.TransactionApproved)
{
var response = JsonConvert.DeserializeObject <SapSaleOrderInvoiceResponse>(sapResponse.SapResponseContent);
return(await SendIncomingPaymentToSap(serviceSetting, sapSystem, existentInvoice ?? response, dequeuedTask.BillingRequest.TransferReference, dequeuedTask.BillingRequest.PaymentDate));
}
}
else
{
_logger.LogError($"Invoice/Sales Order could'n create to SAP because exists an error: '{sapResponse.SapResponseContent}'.");
var ss = dequeuedTask.TaskType;
return(new SapTaskResult
{
IsSuccessful = false,
SapResponseContent = $"Invoice/Sales Order could'n create to SAP because exists an error: '{sapResponse.SapResponseContent}'.",
TaskName = dequeuedTask.TaskType == Enums.SapTaskEnum.BillingRequest ? "Creating Billing Request" : "Updating Billing Request",
IdUser = dequeuedTask.BillingRequest?.UserId.ToString()
});
}
return(sapResponse);
}
catch (Exception ex)
{
return(new SapTaskResult
{
IsSuccessful = false,
SapResponseContent = ex.Message,
TaskName = "Creating Billing Request",
IdUser = dequeuedTask.BillingRequest?.UserId.ToString()
});
}
}
public async Task <SapTaskResult> UpdatePaymentStatusHandle(SapTask dequeuedTask)
{
try
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(dequeuedTask.CreditNoteRequest.BillingSystemId);
var sapTaskHandler = _sapServiceSettingsFactory.CreateHandler(sapSystem);
var existentCreditNote = await sapTaskHandler.TryGetCreditNoteByCreditNoteId(dequeuedTask.CreditNoteRequest.CreditNoteId);
if (existentCreditNote == null)
{
return(new SapTaskResult
{
IsSuccessful = false,
IdUser = dequeuedTask.CreditNoteRequest?.ClientId.ToString(),
SapResponseContent = $"Credit Note could'n update to SAP because the credit note does not exist: '{dequeuedTask.CreditNoteRequest.CreditNoteId}'.",
TaskName = "Updating Credit Note Request"
});
}
var sapResponse = await UpdateCreditNote(existentCreditNote, dequeuedTask, sapSystem);
if (!sapResponse.IsSuccessful)
{
_logger.LogError($"Credit Note could'n update to SAP because exists an error: '{sapResponse.SapResponseContent}'.");
return(sapResponse);
}
if (dequeuedTask.CreditNoteRequest.Type != (int)CreditNoteEnum.Refund || !dequeuedTask.CreditNoteRequest.TransactionApproved)
{
_logger.LogError("The outgoing payment couldn't create in SAP because the type of the credit note must be 'Refund' and the transaction approved: '{SapResponseContent}'", sapResponse.SapResponseContent);
return(sapResponse);
}
return(await SendOutgoingPaymentToSap(sapSystem, existentCreditNote, dequeuedTask.CreditNoteRequest.TransferReference));
}
catch (Exception ex)
{
return(new SapTaskResult
{
IsSuccessful = false,
IdUser = dequeuedTask.CreditNoteRequest?.ClientId.ToString(),
SapResponseContent = $"Error updating Credit Note: '{ dequeuedTask.CreditNoteRequest.CreditNoteId }'. Message: '{ ex.Message }'",
TaskName = "Updating Credit Note Request"
});
}
}
public Task CreateOrUpdateBusinessPartner(DopplerUserDto dopplerUser)
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(dopplerUser.BillingSystemId);
if (!GetValidator(sapSystem).IsValid(dopplerUser, sapSystem, _sapConfig, out var userVerificationError))
{
throw new ValidationException(userVerificationError);
}
_logger.LogInformation($"Add to Task in Queue: {SapTaskEnum.CreateOrUpdateBusinessPartner}");
_queuingService.AddToTaskQueue(
new SapTask()
{
TaskType = SapTaskEnum.CreateOrUpdateBusinessPartner,
DopplerUser = dopplerUser
}
);
return(Task.CompletedTask);
}
public async Task CancelCreditNote(CancelCreditNoteRequest cancelCreditNoteRequest)
{
try
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(cancelCreditNoteRequest.BillingSystemId);
var validator = GetValidator(sapSystem);
validator.ValidateCancelCreditNote(cancelCreditNoteRequest);
_queuingService.AddToTaskQueue(
new SapTask
{
CancelCreditNoteRequest = cancelCreditNoteRequest,
TaskType = SapTaskEnum.CancelCreditNote
}
);
}
catch (Exception e)
{
_logger.LogError($"Failed at cancel credit note request for invoice: {cancelCreditNoteRequest.CreditNoteId}.", e);
await _slackService.SendNotification($"Failed at cancel credit note request for invoice: {cancelCreditNoteRequest.CreditNoteId}. Error: {e.Message}");
}
}
public async Task UpdateCreditNotePaymentStatus(UpdateCreditNotePaymentStatusRequest updateCreditNotePaymentStatusRequest)
{
try
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(updateCreditNotePaymentStatusRequest.BillingSystemId);
var validator = GetValidator(sapSystem);
validator.ValidateUpdateCreditNotePaymentStatusRequest(updateCreditNotePaymentStatusRequest);
var creditNoteRequest = GetMapper(sapSystem).MapUpdateCreditNotePaymentStatusRequestToCreditNoteRequest(updateCreditNotePaymentStatusRequest);
_queuingService.AddToTaskQueue(
new SapTask
{
CreditNoteRequest = creditNoteRequest,
TaskType = SapTaskEnum.UpdateCreditNote
}
);
}
catch (Exception e)
{
_logger.LogError($"Failed at update credit note request for invoice: {updateCreditNotePaymentStatusRequest.CreditNoteId}.", e);
await _slackService.SendNotification($"Failed at update credit note request for invoice: {updateCreditNotePaymentStatusRequest.CreditNoteId}. Error: {e.Message}");
}
}
public async Task <SapTaskResult> CancelCreditNoteHandle(SapTask dequeuedTask)
{
try
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(dequeuedTask.CancelCreditNoteRequest.BillingSystemId);
var sapTaskHandler = _sapServiceSettingsFactory.CreateHandler(sapSystem);
var existentCreditNote = await sapTaskHandler.TryGetCreditNoteByCreditNoteId(dequeuedTask.CancelCreditNoteRequest.CreditNoteId);
if (existentCreditNote == null)
{
return(new SapTaskResult
{
IsSuccessful = false,
SapResponseContent = $"Credit Note could'n cancel to SAP because the credit note does not exist: '{dequeuedTask.CancelCreditNoteRequest.CreditNoteId}'.",
TaskName = "Canceling Credit Note Request"
});
}
var sapResponse = await CancelCreditNote(existentCreditNote, dequeuedTask, sapSystem);
if (!sapResponse.IsSuccessful)
{
_logger.LogError($"Credit Note could'n cancel to SAP because exists an error: '{sapResponse.SapResponseContent}'.");
}
return(sapResponse);
}
catch (Exception ex)
{
return(new SapTaskResult
{
IsSuccessful = false,
SapResponseContent = $"Error canceling Credit Note: '{ dequeuedTask.CancelCreditNoteRequest.CreditNoteId }'. Message: '{ ex.Message}'",
TaskName = "Canceling Credit Note Request"
});
}
}
public async Task <SapTaskResult> Handle(SapTask dequeuedTask)
{
try
{
var sapSystem = SapSystemHelper.GetSapSystemByBillingSystem(dequeuedTask.BillingRequest.BillingSystemId);
var sapTaskHandler = _sapServiceSettingsFactory.CreateHandler(sapSystem);
var businessPartner = await sapTaskHandler.TryGetBusinessPartner(dequeuedTask.BillingRequest.UserId, dequeuedTask.BillingRequest.FiscalID, dequeuedTask.BillingRequest.PlanType);
var billingValidator = GetValidator(sapSystem);
if (!billingValidator.CanCreate(businessPartner, dequeuedTask.BillingRequest))
{
return(new SapTaskResult
{
IsSuccessful = false,
SapResponseContent = $"Failed at generating billing request for the user: {dequeuedTask.BillingRequest.UserId}.",
TaskName = "Creating Billing Request"
});
}
dequeuedTask.BillingRequest.CardCode = businessPartner.CardCode;
var serviceSetting = SapServiceSettings.GetSettings(_sapConfig, sapSystem);
var message = new HttpRequestMessage
{
RequestUri = new Uri($"{serviceSetting.BaseServerUrl}{serviceSetting.BillingConfig.Endpoint}"),
Content = new StringContent(JsonConvert.SerializeObject(dequeuedTask.BillingRequest),
Encoding.UTF8,
"application/json"),
Method = HttpMethod.Post
};
var cookies = await sapTaskHandler.StartSession();
message.Headers.Add("Cookie", cookies.B1Session);
message.Headers.Add("Cookie", cookies.RouteId);
var client = _httpClientFactory.CreateClient();
var sapResponse = await client.SendAsync(message);
var responseContent = await sapResponse.Content.ReadAsStringAsync();
if (sapResponse.IsSuccessStatusCode)
{
if (serviceSetting.BillingConfig.NeedCreateIncomingPayments &&
dequeuedTask.BillingRequest.TransactionApproved)
{
responseContent = await sapResponse.Content.ReadAsStringAsync();
var response = JsonConvert.DeserializeObject <SapSaleOrderInvoiceResponse>(responseContent);
return(await SendIncomingPaymentToSap(serviceSetting, sapSystem, response, dequeuedTask.BillingRequest.TransferReference, cookies));
}
}
else
{
_logger.LogError($"Invoice/Sales Order could'n create to SAP because exists an error: '{responseContent}'.");
}
return(new SapTaskResult
{
IsSuccessful = sapResponse.IsSuccessStatusCode,
SapResponseContent = responseContent,
TaskName = "Creating Billing Request"
});
}
catch (Exception ex)
{
return(new SapTaskResult
{
IsSuccessful = false,
SapResponseContent = ex.Message,
TaskName = "Creating Billing Request"
});
}
}
