public Result <WarrantyRequest, RequestConversionFailure> Build(
VerifyWarrantyCaseRequest verifyWarrantyCaseRequest,
WarrantyCaseOperation operation,
Guid requestId)
{
try
{
var(requestType, actionType) = GetRequestTypeActionType(operation);
var warrantyRequest = new WarrantyRequest
{
RequestId = requestId,
RequestType = requestType,
Action = actionType,
WarrantyCaseId = verifyWarrantyCaseRequest.WarrantyCaseId,
TransactionDate = operation != WarrantyCaseOperation.Cancel
? GetTransactionDateString(verifyWarrantyCaseRequest.TransactionDateTime)
: null,
OrderDetails = GetOrderDetails(verifyWarrantyCaseRequest, operation),
};
return(new Result <WarrantyRequest, RequestConversionFailure>(warrantyRequest));
}
catch (Exception e)
{
return(new Result <WarrantyRequest, RequestConversionFailure>(
new RequestConversionFailure($"Cannot build request of RequestId: `{requestId}` because:" + Environment.NewLine + e.Message)));
}
}
public ValidatableRequest(
VerifyWarrantyCaseRequest request,
WarrantyCaseOperation operation)
{
Request = request;
Operation = operation;
}
public ValidatableResponse(
VerifyWarrantyCaseRequest request,
WarrantyCaseOperation operation,
Guid requestId,
WarrantyResponse warrantyResponse)
{
Request = request;
Operation = operation;
RequestId = requestId;
WarrantyResponse = warrantyResponse;
}
public Result <WarrantyCaseResponse, IFailure> Convert(
VerifyWarrantyCaseRequest request,
WarrantyCaseOperation operation,
Guid requestId,
WarrantyResponse warrantyResponse)
{
try
{
var warrantyCaseResponse = new WarrantyCaseResponse(
orderId: request.OrderId,
warrantyCaseId: warrantyResponse.Header.WarrantyCaseId !)
{
Operation = operation,
WarrantyCaseStatus = WarrantyCaseStatusMap[warrantyResponse.Body !.CaseStatus],
public Result <Unit, IFailure> Validate(
VerifyWarrantyCaseRequest request,
WarrantyCaseOperation operation,
Guid requestId,
WarrantyResponse warrantyResponse)
{
if (warrantyResponse.Header.WarrantyResponseErrors
.FirstOrDefault(e => e.Type == WarrantyResponseErrorType.ServiceNotAvailable)
is WarrantyResponseError serviceNotAvailableError)
{
return(new Result <Unit, IFailure>(
new ServiceNotAvailableFailure(serviceNotAvailableError.Message)));
}
if (warrantyResponse.Header.WarrantyResponseErrors
.FirstOrDefault(e => e.Type == WarrantyResponseErrorType.InvalidRequest)
is WarrantyResponseError invalidRequestError)
{
return(new Result <Unit, IFailure>(
new InvalidRequestFailure(invalidRequestError.Message)));
}
if (warrantyResponse.Header.WarrantyResponseErrors
.FirstOrDefault(e => e.Type == WarrantyResponseErrorType.InternalError)
is WarrantyResponseError warrantyServiceInternalError)
{
return(new Result <Unit, IFailure>(
new WarrantyServiceInternalErrorFailure(warrantyServiceInternalError.Message)));
}
var validatableResponse = new ValidatableResponse(
request,
operation,
requestId,
warrantyResponse);
var validationResult = Validator.Validate(validatableResponse);
if (validationResult.IsValid)
{
return(new Result <Unit, IFailure>(Unit.Value));
}
var errorMessages = string.Join(Environment.NewLine, validationResult.Errors.Select(x => x.ErrorMessage));
return(new Result <Unit, IFailure>(
new ResponseValidationFailure(
$"Response of RequestId: `{requestId}` failed validation:" + Environment.NewLine + errorMessages)));
}
public Result <Unit, RequestValidationFailure> Validate(
VerifyWarrantyCaseRequest request,
WarrantyCaseOperation operation,
Guid requestId)
{
var validatableRequest = new ValidatableRequest(
request,
operation);
var validationResult = Validator.Validate(validatableRequest);
if (validationResult.IsValid)
{
return(new Result <Unit, RequestValidationFailure>(Unit.Value));
}
var errorMessages = string.Join(Environment.NewLine, validationResult.Errors.Select(x => x.ErrorMessage));
return(new Result <Unit, RequestValidationFailure>(
new RequestValidationFailure(
$"Request of RequestId: `{requestId}` failed validation:" + Environment.NewLine + errorMessages)));
}
// success means called Thrid Party, saved raw request and raw response, (and saved warrantyProof), and returns a converted response
// ---
// anything here after SaveExternalPartyResponse in BudgetDatabase should be pure (non-deterministic and no side-effect)
// so that the saved ExternalPartyResponse can be a source of truth
internal async Task <Result <WarrantyCaseResponse, IFailure> > PerformVerifyAction(
VerifyWarrantyCaseRequest request,
WarrantyCaseOperation operation,
Guid requestId)
{
var validateRequestResult = RequestValidator.Validate(request, operation, requestId);
if (!validateRequestResult.IsSuccess)
{
return(new Result <WarrantyCaseResponse, IFailure>(validateRequestResult.Failure !));
}
var build = RequestBuilder.Build(request, operation, requestId);
if (!build.IsSuccess)
{
return(new Result <WarrantyCaseResponse, IFailure>(build.Failure !));
}
var warrantyRequest = build.Success !;
var saveWarrantyRequest = await BudgetDataWrapper.SaveExternalPartyRequest(
new ExternalPartyRequest(
orderId : request.OrderId,
request : JsonConvert.SerializeObject(warrantyRequest))
{
Operation = operation,
RequestId = requestId,
});
if (!saveWarrantyRequest.IsSuccess)
{
return(new Result <WarrantyCaseResponse, IFailure>(saveWarrantyRequest.Failure !));
}
var call = await ExternalPartyWrapper.Call(warrantyRequest);
if (!call.IsSuccess)
{
return(new Result <WarrantyCaseResponse, IFailure>(call.Failure !));
}
var rawResponse = call.Success !;
var saveWarrantyResponse = await BudgetDataWrapper.SaveExternalPartyResponse(
new ExternalPartyResponse(
orderId : request.OrderId,
response : JsonConvert.SerializeObject(rawResponse))
{
Operation = operation,
RequestId = requestId,
});
if (!saveWarrantyResponse.IsSuccess)
{
return(new Result <WarrantyCaseResponse, IFailure>(saveWarrantyRequest.Failure !));
}
var validateResponse = ResponseValidator.Validate(request, operation, requestId, rawResponse);
if (!validateResponse.IsSuccess)
{
return(new Result <WarrantyCaseResponse, IFailure>(validateResponse.Failure !));
}
var convertResponse = ResponseConverter.Convert(request, operation, requestId, rawResponse);
if (!convertResponse.IsSuccess)
{
return(new Result <WarrantyCaseResponse, IFailure>(convertResponse.Failure !));
}
var convertedResponse = convertResponse.Success !;
if (operation == WarrantyCaseOperation.Commit &&
convertedResponse.WarrantyCaseStatus == WarrantyCaseStatus.Committed)
{
var saveWarrantyProof = await ComprehensiveDataWrapper.SaveWarrantyProof(
new WarrantyProof(
orderId : request.OrderId,
warrantyCaseId : convertedResponse.WarrantyCaseId,
proof : rawResponse.Body !.OrderReports.Single().WarrantyProof !)
{
RequestId = requestId,
});
internal (WarrantyRequestType, WarrantyRequestAction?) GetRequestTypeActionType(
WarrantyCaseOperation operation) =>
operation switch
{
