public async Task <bool> UpdateEPSMappingAsync(EPSMapping mapping)
{
try
{
var p = new DynamicParameters();
p.Add("VersionID", mapping.versionID, DbType.Int32);
p.Add("MappingID", mapping.mappingID, DbType.Int32);
p.Add("PDLFlag", mapping.pdlFlag, DbType.Boolean);
p.Add("ParamID", mapping.paramID, DbType.Int32);
p.Add("WorldPayFieldName", mapping.worldPayFieldName, DbType.String);
p.Add("WorldPayTableName", mapping.worldPayTableName, DbType.String);
p.Add("WorldPayJoinFields", mapping.worldPayJoinFields, DbType.String);
p.Add("WorldPayCondition", mapping.worldPayCondition, DbType.String);
p.Add("WorldPayOrderBy", mapping.worldPayOrderBy, DbType.String);
p.Add("WorldPayFieldDescription", mapping.worldPayFieldDescription, DbType.String);
p.Add("EffectiveBeginDate", mapping.effectiveBeginDate, DbType.DateTime);
p.Add("EffectiveEndDate", mapping.effectiveEndDate, DbType.DateTime);
p.Add("VIPERTableName", mapping.viperTableName, DbType.String);
p.Add("VIPERFieldName", mapping.viperFieldName, DbType.String);
p.Add("ViperCondition", mapping.viperCondition, DbType.String);
p.Add("CharStartIndex", mapping.charStartIndex, DbType.Int32);
p.Add("CharLength", mapping.charLength, DbType.Int32);
p.Add("LastUpdatedBy", mapping.lastUpdatedBy, DbType.String);
var result = await UpdateEPSMapping(p);
return(await Task.FromResult(result));
}
catch (System.Exception)
{
throw;
}
}
private EPSMapping GetMapping(XElement element)
{
try
{
EPSMapping mapping = new EPSMapping();
foreach (XAttribute attribute in element.Attributes())
{
if (attribute.Name.LocalName.Equals("MappingID"))
{
mapping.mappingID = Int32.Parse(attribute.Value);
}
else if (attribute.Name.LocalName.Equals("PDLFlag"))
{
mapping.pdlFlag = attribute.Value == "1";
}
else if (attribute.Name.LocalName.Equals("ParamID"))
{
mapping.paramID = Int32.Parse(attribute.Value);
}
else if (attribute.Name.LocalName.Equals("WorldPayFieldDescription"))
{
mapping.worldPayFieldDescription = attribute.Value;
}
else if (attribute.Name.LocalName.Equals("EffectiveBeginDate"))
{
mapping.effectiveBeginDate = DateTime.Parse(attribute.Value);
}
else if (attribute.Name.LocalName.Equals("EffectiveEndDate"))
{
mapping.effectiveEndDate = DateTime.Parse(attribute.Value);
}
else if (attribute.Name.LocalName.Equals("VIPERTableName"))
{
mapping.viperTableName = attribute.Value;
}
else if (attribute.Name.LocalName.Equals("VIPERFieldName"))
{
mapping.viperFieldName = attribute.Value;
}
else if (attribute.Name.LocalName.Equals("ViperCondition"))
{
mapping.viperCondition = attribute.Value;
}
else if (attribute.Name.LocalName.Equals("CharStartIndex"))
{
mapping.charStartIndex = Int32.Parse(attribute.Value);
}
else if (attribute.Name.LocalName.Equals("CharLength"))
{
mapping.charLength = Int32.Parse(attribute.Value);
}
}
return(mapping);
}
catch
{
throw;
}
}
/// <summary>
///
/// </summary>
/// <param name="mapping"></param>
/// <returns></returns>
public async Task <ApiResult <EPSMappingErrorCodes> > InsertEPSMappingAsync(EPSMapping mapping)
{
ApiResult <EPSMappingErrorCodes> res = new ApiResult <EPSMappingErrorCodes>();
try
{
var response = ValidateMapping(mapping);
if (response == EPSMappingErrorCodes.Succeeded)
{
var insertResponse = await _epsMappingRepository.InsertEPSMappingAsync(mapping);
if (false == insertResponse)
{
response = EPSMappingErrorCodes.EPSMappingAllErrorMsg;
}
}
res.Result = response;
}
catch (Exception)
{
throw;
}
return(res);
}
/// <summary>
///
/// </summary>
/// <param name="mapping"></param>
/// <returns></returns>
public static String PostValidation(EPSMapping mapping)
{
String errorkey = "";
if (mapping.pdlFlag)
{
if (string.IsNullOrEmpty(mapping.paramName))
{
errorkey = "EPSMappingParamNameErrorMsg";
}
}
else
{
if (string.IsNullOrEmpty(mapping.worldPayFieldName) || string.IsNullOrEmpty(mapping.worldPayTableName))
{
errorkey = "EPSMappingTable_FieldNamerErrorMsg";
}
}
if ((string.IsNullOrEmpty(mapping.viperFieldName) || string.IsNullOrEmpty(mapping.viperTableName)) && string.IsNullOrEmpty(errorkey))
{
errorkey = "EPSMappingViperFieldsErrorMsg";
}
if ((mapping.effectiveBeginDate.HasValue == false || mapping.effectiveEndDate.HasValue == false) && string.IsNullOrEmpty(errorkey))
{
errorkey = "EPSMappingDatesErrorMsg";
}
return(errorkey);
}
public async Task InsertEPSMappingTest_Success()
{
MockEPSMappingApiRepository bApi = new MockEPSMappingApiRepository();
IDistributedCache _cache = FakeCache();
IOptions <Settings> appSettings = Substitute.For <IOptions <Settings> >();
IEPSMappingApi epsMappingApi = new EPSMappingApi(appSettings, bApi);
EPSMappingController controller = FakeController(_cache, epsMappingApi);
EPSMapping epsMapping = new EPSMapping();
epsMapping.versionID = 1;
epsMapping.pdlFlag = false;
epsMapping.paramID = 200;
epsMapping.worldPayFieldName = "PrimaryPhoneNbr";
epsMapping.worldPayTableName = "tbTranSurcharge";
epsMapping.worldPayJoinFields = null;
epsMapping.worldPayCondition = null;
epsMapping.worldPayOrderBy = null;
epsMapping.worldPayFieldDescription = "Master Cutoff Amount1";
epsMapping.effectiveBeginDate = DateTime.Now;
epsMapping.effectiveEndDate = DateTime.Now;
epsMapping.viperTableName = "Fee";
epsMapping.viperFieldName = "/ Fee / FeeRow / FeeAmount";
epsMapping.viperCondition = "Fee";
epsMapping.charStartIndex = 102;
epsMapping.charLength = 3;
epsMapping.createdByUser = "******";
//.. Act
var dinfo = await controller.Post(epsMapping);
var actualRecord = ((Microsoft.AspNetCore.Mvc.ObjectResult)dinfo).Value;
//..Assert
Assert.Equal(((bool)actualRecord), true);
}
public Task <bool> InsertEPSMappingAsync(EPSMapping mapping)
{
if (mapping.versionID > 0)
{
epsMapping.Add(mapping);
}
else
{
throw new Exception("VersionId is not provided");
}
return(Task.Run(() => true));
}
public Task <bool> UpdateEPSMappingAsync(EPSMapping mapping)
{
if (epsMapping.Any(s => s.versionID == mapping?.versionID))
{
var currentMapping = epsMapping.Where(s => s.versionID == mapping.versionID).FirstOrDefault();
epsMapping.Remove(currentMapping);
epsMapping.Add(mapping);
}
else
{
throw new Exception("Version not exists");
}
return(Task.Run(() => true));
}
public EPSMapping GetMappingFromXml(string xml)
{
try
{
EPSMapping mapping = new EPSMapping();
if (string.IsNullOrEmpty(xml))
{
return(mapping);
}
XDocument xDoc = XDocument.Parse(xml);
return(GetMapping(xDoc.Root));
}
catch
{
throw;
}
}
public async Task <ApiResult <EPSMappingErrorCodes> > UpdateEPSMappingAsync(EPSMapping mapping)
{
ApiResult <EPSMappingErrorCodes> response = new ApiResult <EPSMappingErrorCodes>();
try
{
var errorResponse = ValidateMapping(mapping);
if (errorResponse == EPSMappingErrorCodes.Succeeded)
{
await _epsMappingRepository.UpdateEPSMappingAsync(mapping);
}
response.Result = errorResponse;
}
catch (Exception)
{
throw;
}
return(response);
}
public async Task InsertEPSMappingTest_FailOnPdfFlagTrue()
{
MockEPSMappingApiRepository bApi = new MockEPSMappingApiRepository();
IDistributedCache _cache = FakeCache();
IOptions <Settings> appSettings = Substitute.For <IOptions <Settings> >();
IEPSMappingApi epsMappingApi = new EPSMappingApi(appSettings, bApi);
var localizer = new MockStringLocalizer <EPSMappingController>();
localizer[0] = new LocalizedString("EPSMappingParamNameErrorMsg", "ParamName is mandatory");
EPSMappingController controller = FakeController(_cache, epsMappingApi, localizer);
EPSMapping epsMapping = new EPSMapping();
epsMapping.versionID = 1;
epsMapping.pdlFlag = true;
epsMapping.paramID = 200;
epsMapping.worldPayFieldName = null;
epsMapping.worldPayTableName = null;
epsMapping.worldPayJoinFields = null;
epsMapping.worldPayCondition = null;
epsMapping.worldPayOrderBy = null;
epsMapping.worldPayFieldDescription = "Master Cutoff Amount1";
epsMapping.effectiveBeginDate = DateTime.Now;
epsMapping.effectiveEndDate = DateTime.Now;
epsMapping.viperTableName = "Fee";
epsMapping.viperFieldName = "/ Fee / FeeRow / FeeAmount";
epsMapping.viperCondition = null;
epsMapping.charStartIndex = 102;
epsMapping.charLength = 3;
epsMapping.createdByUser = "******";
//.. Act
var dinfo = await controller.Post(epsMapping);
var actualRecord = ((Microsoft.AspNetCore.Mvc.ObjectResult)dinfo);
//..Assert
Assert.Equal(actualRecord.StatusCode, (int)System.Net.HttpStatusCode.BadRequest);
Assert.Equal(actualRecord.Value, "ParamName is mandatory");
}
private EPSMappingErrorCodes ValidateMapping(EPSMapping mapping)
{
var response = EPSMappingErrorCodes.Succeeded;
try
{
if (mapping.pdlFlag)
{
if (string.IsNullOrEmpty(mapping.paramName))
{
response = EPSMappingErrorCodes.EPSMappingParamNameErrorMsg;
}
}
else
{
if (string.IsNullOrEmpty(mapping.worldPayFieldName) || string.IsNullOrEmpty(mapping.worldPayTableName))
{
response = EPSMappingErrorCodes.EPSMappingTable_FieldNameErrorMsg;
}
}
if ((string.IsNullOrEmpty(mapping.viperFieldName) || string.IsNullOrEmpty(mapping.viperTableName)) && response == EPSMappingErrorCodes.Succeeded)
{
response = EPSMappingErrorCodes.EPSMappingViperFieldsErrorMsg;
}
if ((mapping.effectiveBeginDate.HasValue == false || mapping.effectiveEndDate.HasValue == false) && response == EPSMappingErrorCodes.Succeeded)
{
response = EPSMappingErrorCodes.EPSMappingDatesErrorMsg;
}
}
catch (Exception)
{
throw;
}
return(response);
}
public async Task UpdateEPSMappingVersionDetailsTest_Success()
{
MockEPSMappingApiRepository api = new MockEPSMappingApiRepository();
IDistributedCache _cache = FakeCache();
IOptions <Settings> appSettings = Substitute.For <IOptions <Settings> >();
IEPSMappingApi epsMappingApi = new EPSMappingApi(appSettings, api);
EPSMappingController controller = FakeController(_cache, epsMappingApi);
EPSMapping epsMapping = new EPSMapping();
epsMapping.versionID = 3;
epsMapping.mappingID = 399;
epsMapping.pdlFlag = true;
epsMapping.paramName = "Test";
epsMapping.paramID = 200;
epsMapping.worldPayFieldName = null;
epsMapping.worldPayTableName = null;
epsMapping.worldPayJoinFields = null;
epsMapping.worldPayCondition = null;
epsMapping.worldPayOrderBy = null;
epsMapping.worldPayFieldDescription = "Master Cutoff Amount2";
epsMapping.effectiveBeginDate = DateTime.Now;
epsMapping.effectiveEndDate = DateTime.Now;
epsMapping.viperTableName = "Fee";
epsMapping.viperFieldName = "/ FeeRow / FeeAmount";
epsMapping.viperCondition = null;
epsMapping.charStartIndex = 103;
epsMapping.charLength = 3;
epsMapping.createdByUser = "******";
//.. Act
var dinfo = await controller.Update(epsMapping);
var actualRecord = ((Microsoft.AspNetCore.Mvc.ObjectResult)dinfo).Value;
var updatedMapping = api.epsMapping.Where(s => s.versionID == 3).FirstOrDefault();
//..Assert
Assert.Equal(epsMapping.pdlFlag, true);
Assert.Equal(updatedMapping, epsMapping);
}
public async Task <IActionResult> Update([FromBody] EPSMapping mapping)
{
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Info, "Starting EPS Mapping Update ", "EPSMappingController.cs", "Update"), CancellationToken.None);
if (!ModelState.IsValid)
{
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Error, ModelState.ToString(), "EPSMappingController.cs", "Update"), CancellationToken.None);
return(BadRequest(ModelState));
}
try
{
var serviceResponse = await _epsmappingApi.UpdateEPSMappingAsync(mapping);
if (serviceResponse.Result == Model.Error.EPSMappingErrorCodes.Succeeded)
{
return(Ok(true));
}
else
{
var errorKey = serviceResponse.Result.ToString();
var errorMessage = this._localizer[errorKey]?.Value;
await _loggingFacade.LogAsync(new LogEntry(LogLevels.Error, errorMessage + "Update Unsuccessful", "EPSMappingController.cs", "Update"), CancellationToken.None);
return(BadRequest(errorMessage));
}
}
catch (Exception ex)
{
var msg = this._localizer?["EPSMappingUpdateErrorMsg"]?.Value;
await _loggingFacade.LogExceptionAsync(ex, this.HttpContext?.Request?.Headers["UserName"], LogLevels.Error, "Error in EPSMappingUpdate()", CancellationToken.None);
return(this.StatusCode((int)System.Net.HttpStatusCode.InternalServerError, msg));
}
}
