public ActionResult GetPaymentTable(long claimFieldDocId, int take, int skip, IEnumerable <Sort> sort,
Kendo.DynamicLinq.Filter filter, string defaultSortField, long claimFieldId)
{
PageSetting pageSetting = CommonUtil.GetPageSetting(take, skip, sort, filter, defaultSortField,
Constants.PaymentTableFields, claimFieldId);
ClaimFieldDoc claimFieldDoc = new ClaimFieldDoc
{
ClaimFieldDocId = claimFieldDocId,
PageSetting = pageSetting,
ClaimFieldId = claimFieldId,
UserName = GetCurrentUserName(),
SessionTimeOut = Convert.ToInt32(GlobalConfigVariable.CommandTimeout)
};
PaymentTableContainer paymentTableContainer = PostApiResponse <PaymentTableContainer>(Constants.PaymentTable,
Constants.GetPaymentTable, claimFieldDoc);
if (paymentTableContainer != null)
{
return(Json(new DataSourceResult
{
Total = paymentTableContainer.Total,
Data = paymentTableContainer.ClaimFieldValues
}));
}
return(Json(null));
}
/// <summary>
/// Inserts the claim field document.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <param name="convertToDataTable">The convert to data table.</param>
/// <returns></returns>
private long InsertClaimFieldDoc(ClaimFieldDoc claimFieldDoc, DataTable convertToDataTable)
{
// Initialize the Stored Procedure
_databaseCommandObj = _databaseSqlObj.GetStoredProcCommand("[AddEditClaimFieldDocs]");
// Pass parameters to Stored Procedure(i.e., @ParamName), add values for
_databaseSqlObj.AddInParameter(_databaseCommandObj, "@ClaimFieldDocID", SqlDbType.BigInt,
claimFieldDoc.ClaimFieldDocId);
_databaseSqlObj.AddInParameter(_databaseCommandObj, "@FileName", SqlDbType.VarChar,
claimFieldDoc.FileName.ToTrim());
_databaseSqlObj.AddInParameter(_databaseCommandObj, "@TableName", SqlDbType.VarChar,
claimFieldDoc.TableName.ToTrim());
_databaseSqlObj.AddInParameter(_databaseCommandObj, "@ClaimFieldID", SqlDbType.BigInt,
claimFieldDoc.ClaimFieldId);
_databaseSqlObj.AddInParameter(_databaseCommandObj, "@ColumnHeaderFirst", SqlDbType.VarChar,
claimFieldDoc.ColumnHeaderFirst.ToTrim());
_databaseSqlObj.AddInParameter(_databaseCommandObj, "@ColumnHeaderSecond", SqlDbType.VarChar,
claimFieldDoc.ColumnHeaderSecond.ToTrim());
_databaseSqlObj.AddInParameter(_databaseCommandObj, "@FacilityID", SqlDbType.BigInt,
claimFieldDoc.FacilityId);
_databaseSqlObj.AddInParameter(_databaseCommandObj, "@XmlClaimFieldValues",
SqlDbType.Structured, convertToDataTable);
_databaseSqlObj.AddInParameter(_databaseCommandObj, "@UserName", SqlDbType.VarChar,
claimFieldDoc.UserName);
// Retrieve the results of the Stored Procedure in Dataset
long returnValue = Convert.ToInt64(_databaseSqlObj.ExecuteScalar(_databaseCommandObj));
return(returnValue);
}
/// <summary>
/// Determines whether [is table name exists] [the specified claim field docs].
/// </summary>
/// <param name="claimFieldDocs">The claim field docs.</param>
/// <returns></returns>
public bool IsTableNameExists(ClaimFieldDoc claimFieldDocs)
{
_databaseCommandObj = _databaseObj.GetStoredProcCommand("CheckDuplicateTableName");
_databaseObj.AddInParameter(_databaseCommandObj, "@TableName", DbType.String, claimFieldDocs.TableName);
_databaseObj.AddInParameter(_databaseCommandObj, "@FacilityId", DbType.Int64, claimFieldDocs.FacilityId);
return((bool)_databaseObj.ExecuteScalar(_databaseCommandObj));
}
public void RenamePaymentTableByTableNameIsNull()
{
var claimFieldDocRepository = new Mock <IClaimFieldDocRepository>();
// Arrange
ClaimFieldDoc claimColumnsInfo = new ClaimFieldDoc
{
ClaimFieldDocId = 129988,
FacilityId = 1085,
TableName = " ",
UserName = "******"
};
ClaimFieldDoc expectedResult = new ClaimFieldDoc
{
ClaimFieldDocId = 0
};
claimFieldDocRepository.Setup(f => f.RenamePaymentTable(claimColumnsInfo)).Returns(expectedResult);
_target = new ClaimFieldDocLogic(claimFieldDocRepository.Object);
//Act
ClaimFieldDoc actual = _target.RenamePaymentTable(claimColumnsInfo);
//Assert
Assert.AreEqual(expectedResult.ClaimFieldDocId, actual.ClaimFieldDocId);
}
public void GetClaimFieldDocsTestIfClaimFieldValuesIsNull()
{
// Arrange
_mockClaimFieldDocRepository = new Mock <IClaimFieldDocRepository>();
var dataVal = new ClaimFieldDoc
{
ContractId = 237043,
ClaimFieldId = 4,
ClaimFieldDocId = 271326,
NodeId = 0
};
var claimFieldDocs = new List <ClaimFieldDoc>
{
new ClaimFieldDoc {
ClaimFieldDocId = 1, TableName = "Test 1", ClaimFieldValues = null
}
};
_mockClaimFieldDocRepository.Setup(x => x.GetClaimFieldDocs(dataVal)).Returns(claimFieldDocs);
_target = new ClaimFieldDocLogic(_mockClaimFieldDocRepository.Object);
//Act
List <ClaimFieldDoc> actual = _target.GetClaimFieldDocs(dataVal);
// Assert
var firstOrDefault = actual.FirstOrDefault(q => q.ClaimFieldDocId != 0);
if (firstOrDefault != null)
{
Assert.AreEqual(claimFieldDocs[0].TableName, firstOrDefault.TableName);
}
Assert.AreEqual(actual.Count, claimFieldDocs.Count);
}
/// <summary>
/// Gets the payment table.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <returns></returns>
public PaymentTableContainer GetPaymentTable(ClaimFieldDoc claimFieldDoc)
{
if (claimFieldDoc != null && claimFieldDoc.ClaimFieldId == (byte)Enums.ClaimFieldTypes.CustomPaymentType)
{
return(_paymentTableRepository.GetCustomPaymentTable(claimFieldDoc));
}
return(_paymentTableRepository.GetPaymentTable(claimFieldDoc));
}
public JsonResult IsDocumentInUse(long claimFieldDocId)
{
ClaimFieldDoc claimFieldDoc = new ClaimFieldDoc
{
ClaimFieldDocId = claimFieldDocId,
UserName = GetCurrentUserName()
};
return(Json(new { contractDetails = PostApiResponse <List <ContractLog> >(Constants.ClaimFieldDoc, Constants.IsDocumentInUse, claimFieldDoc) }));
}
/// <summary>
/// Gets the payment table.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <returns></returns>
public PaymentTableContainer GetPaymentTable(ClaimFieldDoc claimFieldDoc)
{
PaymentTableContainer paymentTableContainer = new PaymentTableContainer
{
ClaimFieldValues = new List <ClaimFieldValue>()
};
if (claimFieldDoc != null)
{
//holds the response
string finalStrXml = string.Empty;
//Checks for Payers, if payers exists stores it in DB
if (claimFieldDoc.PageSetting != null &&
claimFieldDoc.PageSetting.SearchCriteriaList != null &&
claimFieldDoc.PageSetting.SearchCriteriaList.Any())
{
finalStrXml = claimFieldDoc.XmlSerialize();
}
// Initialize the Stored Procedure
_databaseCommandObj = _databaseObj.GetStoredProcCommand("GetPaymentTable");
_databaseCommandObj.CommandTimeout = claimFieldDoc.SessionTimeOut;
// Pass parameters to Stored Procedure(i.e., @ParamName), add values for
_databaseObj.AddInParameter(_databaseCommandObj, "@ClaimFieldDocID", DbType.Int64,
claimFieldDoc.ClaimFieldDocId);
_databaseObj.AddInParameter(_databaseCommandObj, "@UserName", DbType.String, claimFieldDoc.UserName);
// ReSharper disable once PossibleNullReferenceException
_databaseObj.AddInParameter(_databaseCommandObj, "@Take", DbType.Int32, claimFieldDoc.PageSetting.Take);
_databaseObj.AddInParameter(_databaseCommandObj, "@Skip", DbType.Int32, claimFieldDoc.PageSetting.Skip);
_databaseObj.AddInParameter(_databaseCommandObj, "@SortField", DbType.String, claimFieldDoc.PageSetting.SortField);
_databaseObj.AddInParameter(_databaseCommandObj, "@SortDirection", DbType.String, claimFieldDoc.PageSetting.SortDirection);
_databaseObj.AddInParameter(_databaseCommandObj, "@XmlSearchCriteria", DbType.Xml, finalStrXml);
// Retrieve the results of the Stored Procedure in Dataset
DataSet paymentTableDataSet = _databaseObj.ExecuteDataSet(_databaseCommandObj);
if (paymentTableDataSet.IsTableDataPopulated() && paymentTableDataSet.Tables.Count > 1)
{
paymentTableContainer.Total = Convert.ToInt32(paymentTableDataSet.Tables[0].Rows[0][0]);
// Bind Claimfield Value Data
paymentTableContainer.ClaimFieldValues = new List <ClaimFieldValue>();
paymentTableContainer.ClaimFieldValues =
(from DataRow row in paymentTableDataSet.Tables[1].Rows
select new ClaimFieldValue
{
Identifier = Convert.ToString(row["Identifier"]),
Value = Convert.ToString(row["Value"])
}).ToList();
}
}
return(paymentTableContainer);
}
public ActionResult Delete(long claimFieldDocId)
{
ClaimFieldDoc claimFieldDoc = new ClaimFieldDoc
{
ClaimFieldDocId = claimFieldDocId,
UserName = GetCurrentUserName()
};
//FIXED-SEP15 use Enum for method -- "Delete"
return(Json(new { success = PostApiResponse <bool>(Constants.ClaimFieldDoc, Convert.ToString(Enums.Action.Delete), claimFieldDoc) }));
}
/// <summary>
/// Deletes the specified claim field document.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <returns></returns>
public bool Delete(ClaimFieldDoc claimFieldDoc)
{
_databaseCommandObj = _databaseObj.GetStoredProcCommand("DeleteClaimFieldDocByID");
_databaseObj.AddInParameter(_databaseCommandObj, "@ClaimFieldDocId", DbType.Int64,
claimFieldDoc.ClaimFieldDocId);
_databaseObj.AddInParameter(_databaseCommandObj, "@UserName", DbType.String, claimFieldDoc.UserName);
bool returnValue = _databaseObj.ExecuteNonQuery(_databaseCommandObj) > 0;
//returns the response to Business layer
return(returnValue);
}
public void AddClaimFieldDocsIfNotNull()
{
_mockClaimFieldDocRepository = new Mock <IClaimFieldDocRepository>();
_mockClaimFieldDocRepository.Setup(f => f.AddClaimFieldDocs(It.IsAny <ClaimFieldDoc>())).Returns(1);
_target = new ClaimFieldDocLogic(_mockClaimFieldDocRepository.Object);
var objAddClaimFieldDocs = new ClaimFieldDoc {
ContractId = 1
};
long actual = _target.AddClaimFieldDocs(objAddClaimFieldDocs);
Assert.AreEqual(1, actual);
}
public ActionResult RenamePaymentTable(long claimFieldDocId, string tableName)
{
ClaimFieldDoc claimFieldDoc = new ClaimFieldDoc
{
ClaimFieldDocId = claimFieldDocId,
TableName = tableName,
UserName = GetCurrentUserName(),
FacilityId = GetCurrentFacilityId()
};
ClaimFieldDoc claimFieldDocs = PostApiResponse <ClaimFieldDoc>(Constants.ClaimFieldDoc,
Constants.RenamePaymentTable, claimFieldDoc);
return(Json(claimFieldDocs));
}
public List <ClaimFieldDoc> GetClaimFieldDocs(ClaimFieldDoc claimFieldDoc)
{
List <ClaimFieldDoc> claimFieldDocList = _claimFieldDocsRepository.GetClaimFieldDocs(claimFieldDoc);
if (claimFieldDocList != null && claimFieldDocList.Any() && claimFieldDocList.First().ClaimFieldValues != null)
{
List <ClaimFieldValue> claimFieldValueList = claimFieldDocList.First().ClaimFieldValues.ToList();
if (claimFieldValueList.Any())
{
claimFieldDocList.ForEach(
a => a.ClaimFieldValues = claimFieldValueList.Where(b => b.ClaimFieldDocId == a.ClaimFieldDocId).ToList());
}
}
return(claimFieldDocList);
}
/// <summary>
/// Gets the claim field document.
/// </summary>
/// <param name="claimFieldDocId">The claim field document identifier.</param>
/// <param name="dtDoc">The dt document.</param>
/// <param name="dtDocValues">The dt document values.</param>
/// <returns></returns>
protected static ClaimFieldDoc GetClaimFieldDoc(long claimFieldDocId, DataTable dtDoc, DataTable dtDocValues)
{
ClaimFieldDoc claimFieldDoc = new ClaimFieldDoc();
if (dtDoc != null && dtDoc.Rows.Count > 0)
{
claimFieldDoc = (from DataRow row in dtDoc.Rows
where Convert.ToInt64(row["ClaimFieldDocID"]) == claimFieldDocId
select new ClaimFieldDoc
{
ClaimFieldDocId = Convert.ToInt64(row["ClaimFieldDocID"]),
FileName = DBNull.Value == row["FileName"] ? null : Convert.ToString(row["FileName"]),
TableName = DBNull.Value == row["TableName"]
? null
: Convert.ToString(row["TableName"]),
ColumnHeaderFirst = DBNull.Value == row["ColumnHeaderFirst"]
? null
: Convert.ToInt64(row["ClaimFieldID"]) == (byte)Enums.ClaimFieldTypes.CustomPaymentType
? Convert.ToString(row["ColumnHeaderFirst"])
.Substring(0,
Convert.ToString(row["ColumnHeaderFirst"])
.IndexOf(",", StringComparison.Ordinal))
: Convert.ToString(row["ColumnHeaderFirst"]),
ColumnHeaderSecond = Convert.ToInt64(row["ClaimFieldID"]) == (byte)Enums.ClaimFieldTypes.CustomPaymentType
? DBNull.Value == row["ColumnHeaderFirst"]
? null
: Convert.ToString(row["ColumnHeaderFirst"])
.Substring(
Convert.ToString(row["ColumnHeaderFirst"])
.IndexOf(Constants.Comma, StringComparison.Ordinal) + 1,
Convert.ToString(row["ColumnHeaderFirst"]).Length -
Convert.ToString(row["ColumnHeaderFirst"])
.IndexOf(Constants.Comma, StringComparison.Ordinal) - 1)
: DBNull.Value == row["ColumnHeaderSecond"]
? null
: Convert.ToString(row["ColumnHeaderSecond"]),
ClaimFieldId = DBNull.Value == row["ClaimFieldID"]
? (long?)null
: Convert.ToInt64(row["ClaimFieldID"]),
ClaimFieldValues = GetClaimFieldValues(Convert.ToInt64(row["ClaimFieldDocID"]),
dtDocValues, Convert.ToInt64(row["ClaimFieldID"]))
}).FirstOrDefault();
}
return(claimFieldDoc);
}
public void Delete()
{
_mockClaimFieldDocRepository = new Mock <IClaimFieldDocRepository>();
var result = new ClaimFieldDoc {
ClaimFieldDocId = 271326
};
_mockClaimFieldDocRepository.Setup(x => x.Delete(result)).Returns(true);
_target = new ClaimFieldDocLogic(_mockClaimFieldDocRepository.Object);
//Act
bool actual = _target.Delete(result);
// Assert
Assert.AreEqual(actual, true);
}
public void GetClaimFieldDocsTestIfNotNull()
{
//Arrange
_mockClaimFieldDocRepository = new Mock <IClaimFieldDocRepository>();
var dataVal = new ClaimFieldDoc {
ContractId = 8, ClaimFieldId = 5, ClaimFieldDocId = 10
};
var result = new List <ClaimFieldDoc>();
_mockClaimFieldDocRepository.Setup(f => f.GetClaimFieldDocs(It.IsAny <ClaimFieldDoc>())).Returns(result);
_target = new ClaimFieldDocLogic(_mockClaimFieldDocRepository.Object);
//Act
List <ClaimFieldDoc> actual = _target.GetClaimFieldDocs(dataVal);
//Assert
Assert.AreEqual(result, actual);
}
public void GetCustomPaymentTable()
{
var repository = new Mock <IPaymentTableRepository>();
PaymentTableContainer result = new PaymentTableContainer();
var value = new ClaimFieldDoc {
ClaimFieldDocId = 10101, ClaimFieldId = 35, PageSetting = new PageSetting {
Skip = 0, SortDirection = "", SortField = "", Take = 5
}
};
repository.Setup(
f => f.GetCustomPaymentTable(value)).Returns(result);
PaymentTableLogic target = new PaymentTableLogic(repository.Object);
PaymentTableContainer actual =
target.GetPaymentTable(value);
Assert.AreEqual(result, actual);
}
//Fixed-2016-R3-S2 : In stored procedure RenameClaimFieldDocByID and RenamePaymentTable rename @FacilityId to @FacilityID.
// Other variables should use pascal naming convention. id should be ID.
/// <summary>
/// Rename Payment Table.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <returns></returns>
public ClaimFieldDoc RenamePaymentTable(ClaimFieldDoc claimFieldDoc)
{
_databaseCommandObj = _databaseObj.GetStoredProcCommand("RenameClaimFieldDocByID");
_databaseObj.AddInParameter(_databaseCommandObj, "@ClaimFieldDocId", DbType.Int64,
claimFieldDoc.ClaimFieldDocId);
_databaseObj.AddInParameter(_databaseCommandObj, "@TableName", DbType.String,
claimFieldDoc.TableName);
_databaseObj.AddInParameter(_databaseCommandObj, "@UserName", DbType.String, claimFieldDoc.UserName);
_databaseObj.AddInParameter(_databaseCommandObj, "@FacilityId", DbType.Int64, claimFieldDoc.FacilityId);
DataSet claimFieldDocModelDataSet = _databaseObj.ExecuteDataSet(_databaseCommandObj);
//Check if output result tables exists or not
if (claimFieldDocModelDataSet.IsTableDataPopulated())
{
claimFieldDoc.ClaimFieldDocId = Convert.ToInt32(claimFieldDocModelDataSet.Tables[0].Rows[0][0]);
}
return(claimFieldDoc);
//returns the response to Business layer
}
/// <summary>
/// Validates the and save.
/// </summary>
/// <param name="responseStatus">The response status.</param>
/// <param name="filePath">The file path.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="claimFieldId">The claim field identifier.</param>
/// <param name="tableName">Name of the table.</param>
/// <param name="facilityId">The facility identifier.</param>
/// <returns></returns>
private string ValidateAndSave(string responseStatus, string filePath, string fileName, long claimFieldId,
string tableName, int facilityId)
{
if (Path.GetExtension(fileName) != null)
{
// Validating the uploaded file
// ReSharper disable once PossibleNullReferenceException
//FIXED-SEP15 Create variable for Path.GetExtension(fileName).Remove(0, 1) and replace magic number 0,1 with constant.
string fileExtension = Path.GetExtension(fileName).Remove(Constants.Zero, Constants.One);
PaymentTableViewModel paymentTableViewModel = PaymentTableUtil.ValidateData(filePath, fileExtension,
claimFieldId);
if (string.IsNullOrEmpty(paymentTableViewModel.Message))
{
//Read claim fields details from imported file xls/xlsx/Csv
ClaimFieldDoc claimFieldDoc = PaymentTableUtil.GetPaymentTableClaimFields(tableName,
// ReSharper disable once PossibleNullReferenceException
fileName, fileExtension, claimFieldId, facilityId, paymentTableViewModel.CalimFieldValues, GetCurrentUserName());
//If imported table is not empty
if (claimFieldDoc.ClaimFieldValues.Count > 0)
{
//Save Document data into DB
responseStatus = AddClaimDocumentItemsByBatch(claimFieldDoc) > 0
? Constants.TableSuccessfullyUploaded
: Constants.TableFailedToUpload;
}
else
{
responseStatus = Constants.EmptyFile;
}
}
else
{
responseStatus = paymentTableViewModel.Message;
}
}
return(responseStatus);
}
public void GetClaimFieldDocsTestIfClaimFieldDocListIsNull()
{
// Arrange
_mockClaimFieldDocRepository = new Mock <IClaimFieldDocRepository>();
var dataVal = new ClaimFieldDoc
{
ContractId = 237043,
ClaimFieldId = 4,
ClaimFieldDocId = 271326,
NodeId = 0
};
_mockClaimFieldDocRepository.Setup(x => x.GetClaimFieldDocs(dataVal)).Returns((List <ClaimFieldDoc>)null);
_target = new ClaimFieldDocLogic(_mockClaimFieldDocRepository.Object);
//Act
List <ClaimFieldDoc> actual = _target.GetClaimFieldDocs(dataVal);
// Assert
Assert.AreEqual(null, actual);
}
/// <summary>
/// Checks the claim field document.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <returns></returns>
public List <ContractLog> IsDocumentInUse(ClaimFieldDoc claimFieldDoc)
{
_databaseCommandObj = _databaseObj.GetStoredProcCommand("IsDocumentInUse");
_databaseObj.AddInParameter(_databaseCommandObj, "@ClaimFieldDocId", DbType.Int64, claimFieldDoc.ClaimFieldDocId);
DataSet paymentTable = _databaseObj.ExecuteDataSet(_databaseCommandObj);
if (paymentTable.IsTableDataPopulated(0))
{
List <ContractLog> claimFieldDocInfo = (from DataRow row in paymentTable.Tables[0].Rows
select new ContractLog
{
ModelName = Convert.ToString(row["ModelName"]),
ContractName = Convert.ToString(row["ContractName"]),
ServiceTypeName = Convert.ToString(row["ContractServiceTypeName"]),
}).ToList();
//returns the response to Business layer
return(claimFieldDocInfo);
}
//returns null if exception occurs or no data found
return(null);
}
public void IsDocumentInUseTest()
{
_mockClaimFieldDocRepository = new Mock <IClaimFieldDocRepository>();
var dataVal = new ClaimFieldDoc {
ClaimFieldDocId = 271326
};
var result = new List <ContractLog>
{
new ContractLog {
ModelName = "Model 1", ContractName = "Contract 1", ServiceTypeName = "Service 1"
}
};
_mockClaimFieldDocRepository.Setup(x => x.IsDocumentInUse(dataVal)).Returns(result);
_target = new ClaimFieldDocLogic(_mockClaimFieldDocRepository.Object);
//Act
List <ContractLog> actual = _target.IsDocumentInUse(dataVal);
// Assert
Assert.AreEqual(actual, result);
}
/// <summary>
/// Rename Payment Table.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <returns></returns>
public ClaimFieldDoc RenamePaymentTable(ClaimFieldDoc claimFieldDoc)
{
return(_claimFieldDocsRepository.RenamePaymentTable(claimFieldDoc));
}
public PaymentTableContainer GetPaymentTable(ClaimFieldDoc claimFieldDoc)
{
return(_paymentTableLogic.GetPaymentTable(claimFieldDoc));
}
public bool IsTableNameExists(ClaimFieldDoc data)
{
return(_paymentTableLogic.IsTableNameExists(data));
}
/// <summary>
/// Adds the claim field docs.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <returns></returns>
public long AddClaimFieldDocs(ClaimFieldDoc claimFieldDoc)
{
long claimFieldDocId = 0;
//Checks if input request is not null
if (claimFieldDoc != null)
{
//holds the response
DataTable convertToDataTable = new DataTable();
// If we are uploading custom payment table
if (claimFieldDoc.ClaimFieldId == (byte)Enums.ClaimFieldTypes.CustomPaymentType)
{
//Looping through each claim field value
foreach (var claimFieldValue in claimFieldDoc.ClaimFieldValues)
{
//Checks for ClaimFieldValues
if (claimFieldDoc.ClaimFieldValues != null && claimFieldDoc.ClaimFieldValues.Any())
{
List <UploadTable> claimFieldValueList = new List <UploadTable>
{
new UploadTable
{
InsertDate = null,
UpdateDate = null,
Identifier = null,
Value = claimFieldValue.Value
}
};
// Converting the data to data table to insert more records
convertToDataTable = Utilities.ToDataTable(claimFieldValueList);
}
// Inserting into database
claimFieldDocId = InsertClaimFieldDoc(claimFieldDoc, convertToDataTable);
}
}
// other than custom payment table
else
{
//Checks for ClaimFieldValues
if (claimFieldDoc.ClaimFieldValues != null && claimFieldDoc.ClaimFieldValues.Any())
{
List <UploadTable> claimFieldValueList =
(from ClaimFieldValue row in claimFieldDoc.ClaimFieldValues
select new UploadTable
{
InsertDate = null,
UpdateDate = null,
Identifier = row.Identifier,
Value = row.Value,
FacilityId = null,
ClaimFieldDocId = null
}).ToList();
convertToDataTable = Utilities.ToDataTable(claimFieldValueList);
claimFieldDocId = InsertClaimFieldDoc(claimFieldDoc, convertToDataTable);
}
}
//returns response to Business layer
return(claimFieldDocId);
}
return(0);
}
/// <summary>
/// Gets the table look up details by contract unique identifier.
/// </summary>
/// <param name="claimFieldDoc"></param>
/// <returns></returns>
public List <ClaimFieldDoc> GetClaimFieldDocs(ClaimFieldDoc claimFieldDoc)
{
//holds the response data
List <ClaimFieldDoc> claimFieldDocs = new List <ClaimFieldDoc>();
// Initialize the Stored Procedure
_databaseCommandObj = _databaseObj.GetStoredProcCommand("GetTableLookUpDetailsByContractID");
_databaseObj.AddInParameter(_databaseCommandObj, "@ContractId", DbType.Int64, claimFieldDoc.ContractId);
_databaseObj.AddInParameter(_databaseCommandObj, "@ClaimFieldId", DbType.Int64,
claimFieldDoc.ClaimFieldId);
_databaseObj.AddInParameter(_databaseCommandObj, "@ClaimFieldDocId", DbType.Int64,
claimFieldDoc.ClaimFieldDocId);
// Retrieve the results of the Stored Procedure
DataSet claimFieldDocDetails = _databaseObj.ExecuteDataSet(_databaseCommandObj);
//Map datatable to business objects
// sending 0 to insure that table at index is having valid data.
if (claimFieldDocDetails.IsTableDataPopulated(0))
{
DataTable dataTable = claimFieldDocDetails.Tables[0];
for (int indexCount = 0; indexCount < dataTable.Rows.Count; indexCount++)
{
ClaimFieldDoc tempData = new ClaimFieldDoc
{
TableName = Convert.ToString(dataTable.Rows[indexCount]["TableName"]),
ClaimFieldDocId = DBNull.Value != dataTable.Rows[indexCount]["ClaimFieldDocID"]
? long.Parse(dataTable.Rows[indexCount]["ClaimFieldDocID"].ToString()) : 0
};
claimFieldDocs.Add(tempData);
}
if (claimFieldDocs.Any())
{
List <ClaimFieldValue> claimFieldValueList = new List <ClaimFieldValue>();
if (claimFieldDocDetails.IsTableDataPopulated(1))
{
dataTable = claimFieldDocDetails.Tables[1];
for (int indexCount = 0; indexCount < dataTable.Rows.Count; indexCount++)
{
ClaimFieldValue tempData = new ClaimFieldValue
{
ColumnHeaderSecond = Convert.ToString(dataTable.Rows[indexCount]["ColumnHeaderSecond"]),
ColumnHeaderFirst = Convert.ToString(dataTable.Rows[indexCount]["ColumnHeaderFirst"]),
Value = Convert.ToString(dataTable.Rows[indexCount]["Value"]),
Identifier = Convert.ToString(dataTable.Rows[indexCount]["Identifier"]),
ClaimFieldValueId = DBNull.Value == dataTable.Rows[indexCount]["ClaimFieldValueID"]
? long.Parse(dataTable.Rows[indexCount]["ClaimFieldValueID"].ToString()) : 0,
ClaimFieldDocId = DBNull.Value != dataTable.Rows[indexCount]["ClaimFieldDocID"]
? long.Parse(dataTable.Rows[indexCount]["ClaimFieldDocID"].ToString()) : 0
};
claimFieldValueList.Add(tempData);
}
}
if (true & claimFieldDocs.Any() && claimFieldValueList.Any())
{
claimFieldDocs.First().ClaimFieldValues = claimFieldValueList.ToList();
}
}
}
//returns the response to Business layer
return(claimFieldDocs);
}
public List <ContractLog> IsDocumentInUse(ClaimFieldDoc claimFieldDoc)
{
return(_claimFieldDocsRepository.IsDocumentInUse(claimFieldDoc));
}
/// <summary>
/// Deletes the specified claim field document.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <returns></returns>
public bool Delete(ClaimFieldDoc claimFieldDoc)
{
return(_claimFieldDocsRepository.Delete(claimFieldDoc));
}
/// <summary>
/// Adds the claim field docs.
/// </summary>
/// <param name="claimFieldDoc">The claim field document.</param>
/// <returns></returns>
public long AddClaimFieldDocs(ClaimFieldDoc claimFieldDoc)
{
return(_claimFieldDocsRepository.AddClaimFieldDocs(claimFieldDoc));
}
