public virtual ValidationResult ReconciliationData(ReconciliationRequest model)
{
if (model != null)
{
DateTime?startDate = null;
DateTime?endDate = null;
DateTime Odate;
// Conversion to the appropriate date format
if (DateTime.TryParseExact(model.date_from, "ddMMyyyy", System.Globalization.CultureInfo.InvariantCulture, DateTimeStyles.None, out Odate))
{
startDate = DateTime.ParseExact(model.date_from, "ddMMyyyy", System.Globalization.CultureInfo.InvariantCulture);
}
if (DateTime.TryParseExact(model.date_to, "ddMMyyyy", System.Globalization.CultureInfo.InvariantCulture, DateTimeStyles.None, out Odate))
{
endDate = DateTime.ParseExact(model.date_to, "ddMMyyyy", System.Globalization.CultureInfo.InvariantCulture);
}
// Validation
if (startDate == null || endDate == null)
{
return(new ValidationResult("1-Missing specification of the period"));
}
else if (startDate > DateTime.Now && endDate > startDate)
{
return(new ValidationResult("3-The period is in the future"));
}
else if (startDate >= endDate)
{
return(new ValidationResult("2-Beginning date follows closing date of the period"));
}
}
return(ValidationResult.Success);
}
public async Task InsertReconciliation()
{
var rInput = new ReconciliationRequest
{
ReconciliationDate = DateTime.Now
};
var result = await _rService.InsertConciliation(rInput);
Print(result);
}
public async Task ConfirmReconciliation()
{
var rInput = new ReconciliationRequest
{
ReconciliationDate = DateTime.Now
};
var response = await _rService.InsertConciliation(rInput);
var result = await _rService.ConfirmReconciliation(response.ReconciliationKey, new ReconciliationConfirmationRequest { ReconciliationKey = response.ReconciliationKey });
Print(result);
}
public async Task <ReconciliationMessage> ProvideReconciliationData(ReconciliationRequest model)
{
ImisPayment payment = new ImisPayment(_configuration, _hostingEnvironment, _loggerFactory);
var response = payment.ProvideReconciliationData(model);
ReconciliationMessage return_message = new ReconciliationMessage
{
transactions = response,
error_occurred = false
};
return(await Task.FromResult(return_message));
}
public List <ReconciliationItem> ProvideReconciliationData(ReconciliationRequest model)
{
List <ReconciliationItem> result = new List <ReconciliationItem>();
DateTime startDate = DateTime.ParseExact(model.date_from, "ddMMyyyy", System.Globalization.CultureInfo.InvariantCulture);
DateTime endDate = DateTime.ParseExact(model.date_to, "ddMMyyyy", System.Globalization.CultureInfo.InvariantCulture);
SqlParameter[] parameters =
{
new SqlParameter("@DateFrom", startDate),
new SqlParameter("@DateTo", endDate)
};
var sSQL = @"SELECT * FROM tblPayment WHERE ReceivedDate BETWEEN @DateFrom AND @DateTo";
try
{
var data = dh.GetDataTable(sSQL, parameters, CommandType.Text);
if (data.Rows.Count > 0)
{
for (int i = 0; i < data.Rows.Count; i++)
{
var rw = data.Rows[i];
result.Add(new ReconciliationItem
{
control_number = rw["PaymentID"].ToString(),
enrolment_officer_code = rw["OfficerCode"].ToString(),
insurance_number = rw["PaymentID"].ToString(),
language = rw["LanguageName"] != System.DBNull.Value ? Convert.ToString(rw["LanguageName"]) : null,
payment_date = rw["PaymentDate"] != System.DBNull.Value ? DateTime.Parse(rw["PaymentDate"].ToString()).ToString("ddMMyyyy") : null,
payment_origin = rw["PaymentOrigin"].ToString(),
receipt_identification = rw["ReceiptNo"].ToString(),
received_amount = rw["ReceivedAmount"] != System.DBNull.Value ? Convert.ToDouble(rw["ReceivedAmount"]) : 0,
received_date = rw["ReceivedDate"] != System.DBNull.Value ? DateTime.Parse(rw["ReceivedDate"].ToString()).ToString("ddMMyyyy") : null,
transaction_identification = rw["TransactionNo"].ToString(),
type_of_payment = rw["TypeOfPayment"] != System.DBNull.Value ? Convert.ToString(rw["TypeOfPayment"]) : null
});
}
}
}
catch (Exception)
{
throw;
}
return(result);
}
public async Task <ReconciliationResponse> InsertConciliation(ReconciliationRequest reconciliationInput)
{
var request = new RestRequest($"{Options.BaseUrl}/{_pathBase}", DataFormat.Json)
{
Method = Method.POST
};
request.AddJsonBody(reconciliationInput);
return(await GetPipeline <ReconciliationResponse>().Execute(new Commands.RequestCommand <ReconciliationResponse>()
{
Model = reconciliationInput,
RestRequest = request,
Profile = _baseProfile
}).MapResponse());
}
public virtual async Task <IActionResult> ProvideReconciliationData([FromBody] ReconciliationRequest model)
{
ValidationResult validation = new ValidationBase().ReconciliationData(model);
if (validation != ValidationResult.Success)
{
return(BadRequest(new { error_occured = true, error_message = validation.ErrorMessage }));
}
try
{
var response = await _payment.ProvideReconciliationData(model);
return(Ok(response));
}
catch (Exception)
{
return(BadRequest(new { error_occured = true, error_message = "Unknown Error Occured" }));
}
}
