private static void GetDataByCriteriaTest(string criteria, object[] parameters, string predicate = "=")
{
TransactionWork transactionWork = null;
SqlParameter[] parameterCustomer = CreateUSP(criteria, parameters);
SqlParameter[] parameterReg = CreateUSP(criteria, parameters);
SqlParameter[] parameterInv = CreateUSP(criteria, parameters);
SqlParameter[] parameterInvBenefits = CreateUSP(criteria, parameters);
SqlParameter[] parameterAddr = CreateUSP(criteria, parameters);
try
{
using (transactionWork = (TransactionWork)TransactionFactory.Create())
{
transactionWork.Execute(_tables.CustomerDataTable, $"uspGetCustomerBy{criteria}",
parameterCustomer);
transactionWork.Execute(_tables.RegisterDataTable, $"uspGetRegisterBy{criteria}", parameterReg);
transactionWork.Execute(_tables.InvalidDataTable, $"uspGetInvalidBy{criteria}", parameterInv);
transactionWork.Execute(_tables.InvalidBenefitsDataTable, $"uspGetInvalidBenefitsBy{criteria}",
parameterInvBenefits);
transactionWork.Execute(_tables.AddressDataTable, $"uspGetAddressBy{criteria}", parameterAddr);
transactionWork.Commit();
}
WhereClasure(criteria, parameters, predicate);
}
catch (Exception)
{
transactionWork?.Rollback();
throw;
}
}
public static void FillDictionary()
{
ClearData();
TransactionWork transactionWork = null;
try
{
using (transactionWork = (TransactionWork)TransactionFactory.Create())
{
transactionWork.ReadData(_tables.DispancerDataSet.Tables["ApppTpr"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["Gender"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["AdminDivision"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["TypeStreet"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["ChiperRecept"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["BenefitsCategory"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["DisabilityGroup"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["Land"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["RegisterType"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["WhyDeRegister"]);
transactionWork.Commit();
}
}
catch (Exception)
{
transactionWork?.Rollback();
throw;
}
}
public static void SaveEntity(string entityName)
{
TransactionWork transactionWork = null;
try
{
using (transactionWork = (TransactionWork)TransactionFactory.Create())
{
for (int i = 0; i < _tables.DispancerDataSet.Tables.Count; i++)
{
if (_tables.DispancerDataSet.Tables[i].TableName == entityName)
{
transactionWork.UpdateData(_tables.DispancerDataSet.Tables[i]);
break;
}
}
transactionWork.Commit();
}
}
catch (Exception)
{
transactionWork?.Rollback();
throw;
}
}
public static void Update()
{
TransactionWork transactionWork = null;
try
{
using (transactionWork = (TransactionWork)TransactionFactory.Create())
{
for (int i = 0; i < _tables.DispancerDataSet.Tables.Count; i++)
{
if (_tables.DispancerDataSet.Tables[i].TableName != _tables.ErrorDataTable.TableName)
{
transactionWork.UpdateData(_tables.DispancerDataSet.Tables[i]);
}
}
_tables.ErrorDataTable.Clear();
transactionWork.Commit();
}
}
catch (Exception)
{
transactionWork?.Rollback();
throw;
}
}
public static void FillCustomerData()
{
ClearData();
TransactionWork transactionWork = null;
try
{
using (transactionWork = (TransactionWork)TransactionFactory.Create())
{
transactionWork.ReadData(_tables.DispancerDataSet.Tables["Customer"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["Address"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["Invalid"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["InvalidBenefitsCategory"]);
transactionWork.ReadData(_tables.DispancerDataSet.Tables["Register"]);
transactionWork.Commit();
}
whereClasure = String.Empty;
value = null;
dbType = string.Empty;
}
catch (Exception)
{
transactionWork?.Rollback();
throw;
}
}
private static void GetDataByGlossary(string glossaryName, int id)
{
TransactionWork transactionWork = null;
string storageProcedureName = string.Format("uspGet{0}By{1}", "Customer", glossaryName);
SqlParameter parameter = new SqlParameter();
parameter.DbType = DbType.Int32;
parameter.ParameterName = "@ID";
parameter.Value = id;
string storageProcedureNameReg = string.Format("uspGet{0}By{1}", "Register", glossaryName);
SqlParameter parameterReg = new SqlParameter();
parameterReg.DbType = DbType.Int32;
parameterReg.ParameterName = "@ID";
parameterReg.Value = id;
string storageProcedureNameInv = string.Format("uspGet{0}By{1}", "Invalid", glossaryName);
SqlParameter parameterInv = new SqlParameter();
parameterInv.DbType = DbType.Int32;
parameterInv.ParameterName = "@ID";
parameterInv.Value = id;
string storageProcedureNameInvBenefits = string.Format("uspGet{0}By{1}", "InvalidBenefits", glossaryName);
SqlParameter parameterInvBenefits = new SqlParameter();
parameterInvBenefits.DbType = DbType.Int32;
parameterInvBenefits.ParameterName = "@ID";
parameterInvBenefits.Value = id;
string storageProcedureNameAddr = string.Format("uspGet{0}By{1}", "Address", glossaryName);
SqlParameter parameterAddr = new SqlParameter();
parameterAddr.DbType = DbType.Int32;
parameterAddr.ParameterName = "@ID";
parameterAddr.Value = id;
try
{
using (transactionWork = (TransactionWork)TransactionFactory.Create())
{
transactionWork.Execute(_tables.CustomerDataTable, storageProcedureName, parameter);
transactionWork.Execute(_tables.RegisterDataTable, storageProcedureNameReg, parameterReg);
transactionWork.Execute(_tables.InvalidDataTable, storageProcedureNameInv, parameterInv);
transactionWork.Execute(_tables.InvalidBenefitsDataTable, storageProcedureNameInvBenefits, parameterInvBenefits);
transactionWork.Execute(_tables.AddressDataTable, storageProcedureNameAddr, parameterAddr);
transactionWork.Commit();
}
WhereClasure(glossaryName, new object[] { id }, "=");
//whereClasure = "where " + glossaryName + "ID = @param";
//value = id;
//dbType = "@param int";
}
catch (Exception)
{
transactionWork?.Rollback();
throw;
}
}
private static void GetDataByCustomerID(int id)
{
TransactionWork transactionWork = null;
String storageProcedureName = "uspGetCustomers";
SqlParameter parameter = new SqlParameter();
parameter.DbType = DbType.Int32;
parameter.Size = 4;
parameter.ParameterName = "@CustomerID";
parameter.Value = id;
SqlParameter parameterReg = new SqlParameter();
parameterReg.DbType = DbType.Int32;
parameterReg.Size = 4;
parameterReg.ParameterName = "@CustomerID";
parameterReg.Value = id;
SqlParameter parameterInv = new SqlParameter();
parameterInv.DbType = DbType.Int32;
parameterInv.Size = 4;
parameterInv.ParameterName = "@CustomerID";
parameterInv.Value = id;
SqlParameter parameterAddr = new SqlParameter();
parameterAddr.DbType = DbType.Int32;
parameterAddr.Size = 4;
parameterAddr.ParameterName = "@CustomerID";
parameterAddr.Value = id;
try
{
using (transactionWork = (TransactionWork)TransactionFactory.Create())
{
transactionWork.Execute(_tables.CustomerDataTable, storageProcedureName, parameter);
transactionWork.Execute(_tables.RegisterDataTable, "uspGetRegisterByCustomerID", parameterReg);
transactionWork.Execute(_tables.InvalidDataTable, "uspGetInvalidByCustomerID", parameterInv);
transactionWork.Execute(_tables.AddressDataTable, "uspGetAddressByCustomerID", parameterAddr);
transactionWork.Commit();
}
whereClasure = "where vgc.CustomerID = @param";
value = id;
dbType = "@param int";
}
catch (Exception)
{
transactionWork?.Rollback();
throw;
}
}
internal void Commit(Transaction transaction, IList <ITableSource> visibleTables,
IEnumerable <ITableSource> selectedFromTables,
IEnumerable <IMutableTable> touchedTables, TransactionRegistry journal)
{
var state = new TransactionWork(this, transaction, selectedFromTables, touchedTables, journal);
// Exit early if nothing changed (this is a Read-only transaction)
if (!state.HasChanges)
{
CloseTransaction(state.Transaction);
return;
}
lock (commitLock) {
var changedTablesList = state.Commit(objectStates);
// Flush the journals up to the minimum commit id for all the tables
// that this transaction changed.
long minCommitId = Database.TransactionFactory.OpenTransactions.MinimumCommitId(null);
foreach (var master in changedTablesList)
{
master.MergeChanges(minCommitId);
}
int nsjsz = objectStates.Count;
for (int i = nsjsz - 1; i >= 0; --i)
{
var namespaceJournal = objectStates[i];
// Remove if the commit id for the journal is less than the minimum
// commit id
if (namespaceJournal.CommitId < minCommitId)
{
objectStates.RemoveAt(i);
}
}
// Set a check point in the store system. This means that the
// persistance state is now stable.
StoreSystem.SetCheckPoint();
}
}
public static void ExportToExcel()
{
DataTable table = new DataTable();
TransactionWork transactionWork = null;
SqlParameter[] parameters = new SqlParameter[3];
SqlParameter parameter = new SqlParameter();
parameter.DbType = DbType.String;
parameter.Size = 100;
parameter.ParameterName = "@whereClasure";
parameter.Value = whereClasure;
parameters[0] = parameter;
parameter = new SqlParameter();
parameter.DbType = DbType.String;
parameter.ParameterName = "@Param";
parameter.Size = 100;
if (value == null)
{
parameter.Value = string.Empty;
}
else
{
parameter.Value = value;
}
parameter.IsNullable = true;
parameters[1] = parameter;
parameter = new SqlParameter();
parameter.DbType = DbType.String;
parameter.Size = 30;
parameter.ParameterName = "@ParamType";
parameter.Value = dbType;
parameter.IsNullable = true;
parameters[2] = parameter;
try
{
using (transactionWork = (TransactionWork)TransactionFactory.Create())
{
transactionWork.Execute(table, "uspDynamicQuery", parameters);
transactionWork.Commit();
}
}
catch (Exception)
{
transactionWork?.Rollback();
throw;
}
FastExportingMethod.ExportToExcel(table,
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "List"));
FastExportingMethod.GemExportToExcel(table,
Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "List2.xls"));
table.Dispose();
table = null;
GC.Collect();
GC.WaitForPendingFinalizers();
}
