private static double GetDiference(this Transact transact, EventTypeEnum first, EventTypeEnum second)
{
var journal = transact.GetJournal();
return(journal.Find(l => l.Event == second).Time.Time
- journal.Find(l => l.Event == first).Time.Time);
}
public static void SendTransaction(AccountView sourceAccount, AccountView targetAccount, decimal amount)
{
if (sourceAccount == null)
{
throw new Exception("Source account does not exists.");
}
if (sourceAccount.balance < amount && !sourceAccount.description.StartsWith("outsideworld", StringComparison.InvariantCultureIgnoreCase))
{
throw new Exception("There are no enough funds on the source account.");
}
if (amount != Math.Abs(amount))
{
throw new Exception("Amount cannot be negative.");
}
if (targetAccount == null)
{
throw new Exception($"Target account with identifier {targetAccount.account_identifier} does not exists.");
}
if (sourceAccount.currency_id != targetAccount.currency_id)
{
throw new Exception("Source and target account must be in the same currency.");
}
Transact newTransact = new Transact()
{
amount = amount,
created = DateTime.Now,
source_account = sourceAccount.id,
target_account = targetAccount.id
};
Server.db.Insert(DatabaseHelper.Tables.transactions, newTransact);
}
static void Main(string[] args)
{
try
{
Account <int> acc1 = new Account <int>(345678, 10000);
Account <string> acc2 = new Account <string>("123456", 10000);
Account <double> acc3 = new Account <double>(12345.44, 10000);
DemindAccount <char> acc4 = new DemindAccount <char>('/', 10000);
DemindAccount <object> acc5 = new DemindAccount <object>(557, 10000);
Person per1 = new Person(1, 10000);
Person per2 = new Person(2, 10000);
Person per3 = new Person(3, 10000);
Person per4 = new Person(4, 10000);
Transact.Execute <Person>(per1, per2, 1000);
Transact.Execute <Person>(per3, per4, 1000);
Transact.Execute <Person>(per3, per1, 1000);
Transact.Execute <Person>(per4, per2, 1000);
}
catch (Exception ex)
{
Console.WriteLine("\n ERROR : " + ex.Message);
}
finally
{
Console.ReadKey();
}
}
public async Task <ActionResult <Transact> > PostTransact(Transact transact)
{
_context.Transact.Add(transact);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTransact", new { id = transact.TransactId }, transact));
}
public void MultipleCommit() // TODO: Review
{
var needle = Transact.CreateNeedle(1);
using (var autoResetEvent = new AutoResetEvent(false))
{
new Thread
(
() =>
{
using (var transaction = new Transact())
{
needle.Value = 2;
transaction.Commit();
needle.Value = 3;
transaction.Commit();
needle.Value = 5;
transaction.Rollback();
autoResetEvent.Set();
}
}
).Start();
autoResetEvent.WaitOne();
Assert.AreEqual(3, needle.Value);
}
}
public TransactModel Initiate(TransactForm form)
{
var payer = DataModule.Payers.Search(form.PayerMobile).Items.FirstOrDefault();
if (payer == null)
{
payer = new Payer()
{
Mobile = form.PayerMobile,
Name = form.PayerMobile
};
payer = DataModule.Payers.Insert(payer);
}
var transact = new Transact()
{
Amount = form.Amount,
CurrencyCode = "NGN",
RecipientId = form.RecipientId,
TrnxStatus = 0,
PaymentRef = form.Narration,
PayerId = payer.Id
};
transact = DataModule.Transacts.Insert(transact);
return(DataModule.TransactModels.Get(transact.Id));
}
public Transact TransactionGetById(string id)
{
var transaction = new Transact();
using (var conn = new SqlConnection(connectionString))
{
using (var cmd = new SqlCommand("dbo.TransactionGetById", conn))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@Id", SqlDbType.NVarChar).Value = id;
conn.Open();
var reader = cmd.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
transaction = new Transact
{
Account = (string)reader["Account"],
Description = (reader["Description"] != DBNull.Value) ? (string)reader["Description"] : "",
CurrencyCode = (reader["CurrencyCode"] != DBNull.Value) ? (string)reader["CurrencyCode"] : "",
Amount = (reader["Amount"] != DBNull.Value) ? (decimal)reader["Amount"] : 0m,
};
}
}
reader.Close();
}
}
return(transaction);
}
public void NestedTransaction()
{
var needleA = Transact.CreateNeedle(5);
var needleB = Transact.CreateNeedle(1);
var thread = new Thread(() =>
{
using (var transaction = new Transact())
{
needleB.Value = 2;
using (var transact = new Transact())
{
needleA.Value = 9;
Assert.AreEqual(9, needleA.Value);
Assert.AreEqual(2, needleB.Value);
transact.Commit();
}
Assert.AreEqual(9, needleA.Value);
Assert.AreEqual(2, needleB.Value);
transaction.Rollback();
Assert.AreEqual(5, needleA.Value);
Assert.AreEqual(1, needleB.Value);
}
});
thread.Start();
thread.Join();
Assert.AreEqual(5, needleA.Value);
Assert.AreEqual(1, needleB.Value);
}
public void FreeTest()
{
var needle = Transact.CreateNeedle(1);
var autoResetEvent = new AutoResetEvent(false);
// This one does not commit
new Thread(() =>
{
using (var transaction = new Transact())
{
needle.Free();
autoResetEvent.Set();
}
}).Start();
autoResetEvent.WaitOne();
Assert.AreEqual(1, needle.Value);
// This one commits
new Thread(() =>
{
using (var transaction = new Transact())
{
needle.Free();
transaction.Commit();
autoResetEvent.Set();
}
}).Start();
autoResetEvent.WaitOne();
Assert.AreEqual(0, needle.Value);
}
public async Task <IActionResult> PutTransact(int id, Transact transact)
{
if (id != transact.TransactId)
{
return(BadRequest());
}
_context.Entry(transact).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TransactExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void SimpleTest() // TODO: Review
{
var needle = Transact.CreateNeedle(1);
using (var autoResetEvent = new AutoResetEvent(false))
{
// This one does not commit
new Thread(() =>
{
using (var transaction = new Transact())
{
needle.Value = 2;
autoResetEvent.Set();
}
}).Start();
autoResetEvent.WaitOne();
Assert.AreEqual(1, needle.Value);
// This one commits
new Thread(() =>
{
using (var transaction = new Transact())
{
needle.Value = 2;
transaction.Commit();
autoResetEvent.Set();
}
}).Start();
autoResetEvent.WaitOne();
Assert.AreEqual(2, needle.Value);
}
}
public IEnumerable <NaklItem> GetDirectAcceptance(int naklId)
{
const string commandText = @"Select chz_nakl_item_id,
name,
(Select Count(*) From chz_sgtins Where chz_sgtins.chz_nakl_item_id=chz_nakl_items.chz_nakl_item_id) As count,
(vat_value * (Select Count(*) From chz_sgtins Where chz_sgtins.chz_nakl_item_id=chz_nakl_items.chz_nakl_item_id)) As nds,
((cost - vat_value)*(Select Count(*) From chz_sgtins Where chz_sgtins.chz_nakl_item_id=chz_nakl_items.chz_nakl_item_id)) As price,
(cost * (Select Count(*) From chz_sgtins Where chz_sgtins.chz_nakl_item_id=chz_nakl_items.chz_nakl_item_id)) As sum,
(Select Count(*) From chz_scanned_sgtins Where chz_scanned_sgtins.chz_nakl_item_id = chz_nakl_items.chz_nakl_item_id) As scaned_count,
(Select Count(*) From chz_sgtins Inner Join chz_scanned_sgtins On chz_sgtins.sgtin=chz_scanned_sgtins.value
Where chz_scanned_sgtins.chz_nakl_item_id = chz_nakl_items.chz_nakl_item_id And
chz_sgtins.chz_nakl_item_id = chz_nakl_items.chz_nakl_item_id
) As count_matched
From chz_nakl_items
Where chz_nakl_items.chz_nakl_id = @chz_nakl_id";
var parameter = new NaklIdParameter()
{
Id = naklId
};
var transaction = Transact <NaklItem> .Create(ConnectionString, commandText, parameter : parameter);
return(transaction.ExecuteReader());
}
public static void Write(HttpRequest httpRequest, HttpResponse httpResponse)
{
if (isDebug == true)
{
const string commandText = @"INSERT INTO chz_ui_log
(request_data,request_host,request_method,request_url,request_body,request_query_string,response_status_code,response_result,login)
VALUES (@request_data,@request_host,@request_method,@request_url,@request_body,@request_query_string,@response_status_code,@response_result,@login)";
var parameter = new InsertParameter()
{
Body = httpRequest.Body,
Url = httpRequest.Url,
Method = httpRequest.Method,
QueryString = httpRequest.QueryString,
ReguestDateTime = httpRequest.DateTime,
Host = httpRequest.Host,
Login = httpRequest.Login,
StatusCode = httpResponse.StatusCode,
Result = httpResponse.Result
};
var str = Regex.Replace(connectionString, "{login}", login);
var conStr = Regex.Replace(str, "{password}", password);
var transaction = Transact <object> .Create(conStr, commandText, parameter : parameter);
transaction.ExecuteNonQuery();
}
}
public NaklFull GetFullNaklById(int naklId)
{
const string commandText = @"Select chz_nakl_id,
chz_address_id As provider_id,
chz_companies.chz_company_id As company_id,
operation_data,
doc_data,
doc_num,
chz_receive_types.chz_receive_type_id As chz_receive_type_id,
chz_source_types.chz_source_type_id As chz_source_type_id,chz_contract_types.chz_contract_type_id As chz_contract_type_id,chz_turnover_types.chz_turnover_tupe_id As chz_turnover_tupe_id,
contract_num
From chz_nakls Inner Join chz_addresses On chz_nakls.provider_chz_address_id = chz_addresses.chz_address_id
Inner Join chz_companies On chz_companies.chz_company_id = chz_addresses.chz_company_id
Inner Join chz_receive_types On chz_nakls.chz_receive_type_id = chz_receive_types.chz_receive_type_id
Inner Join chz_source_types On chz_nakls.chz_source_type_id = chz_source_types.chz_source_type_id
Inner Join chz_contract_types On chz_nakls.chz_contract_type_id = chz_contract_types.chz_contract_type_id
Inner Join chz_turnover_types On chz_nakls.chz_turnover_tupe_id = chz_turnover_types.chz_turnover_tupe_id
Where chz_nakls.chz_nakl_id = @chz_nakl_id";
var parameter = new NaklIdParameter()
{
Id = naklId
};
var transaction = Transact <NaklFull> .Create(ConnectionString, commandText, parameter : parameter);
return(transaction.ExecuteReader().FirstOrDefault());
}
public IEnumerable <NaklGrid> Get(int?companyId, int?year, int?month, int?statusId)
{
const string commandText = @"Select chz_nakls.chz_nakl_id As chz_nakl_id,doc_num,doc_data,ProviderCompany.name As provider_name,chz_nakls__list_of_accept_types.value As accept_types_value,
chz_contract_types.value As contract_types_value,chz_nakl_statuses.value As nakl_statuses_value,class_name,(Select Sum(cost) From chz_nakl_items Where chz_nakl_items.chz_nakl_id =chz_nakls.chz_nakl_id) As sum
From chz_nakls Inner Join chz_addresses ProviderAddresses On chz_nakls.provider_chz_address_id = ProviderAddresses.chz_address_id
Inner Join chz_addresses ReceiverAddresses On chz_nakls.receiver_chz_address_id=ReceiverAddresses.chz_address_id
Inner Join chz_companies ProviderCompany On ProviderAddresses.chz_company_id=ProviderCompany.chz_company_id
Inner Join chz_companies ReceiverCompany On ReceiverAddresses.chz_company_id=ReceiverCompany.chz_company_id
Inner Join chz_nakls__list_of_accept_types On chz_nakls.chz_nakls__list_of_accept_type_id=chz_nakls__list_of_accept_types.chz_nakls__list_of_accept_type_id
Inner Join chz_contract_types On chz_nakls.chz_contract_type_id=chz_contract_types.chz_contract_type_id
Inner Join chz_nakl_statuses On chz_nakls.chz_nakl_status_id = chz_nakl_statuses.chz_nakl_status_id
Where (@company_id is Null or ProviderCompany.chz_company_id=@company_id) And
(@year is Null Or YEAR(chz_nakls.doc_data)=@year) And
(@month is Null Or MONTH(chz_nakls.doc_data)=@month) And
(@statusId is Null Or chz_nakls.chz_nakl_status_id = @statusId)";
var parameter = new NaklFiltrParameter()
{
CompanyId = companyId, Year = year, Month = month, StatusId = statusId
};
var transaction = Transact <NaklGrid> .Create(ConnectionString, commandText, parameter : parameter);
return(transaction.ExecuteReader());
}
public int GetMaxId()
{
const string commandText = @"Select Max(chz_nakl_id) From chz_nakls";
var transaction = Transact <object> .Create(ConnectionString, commandText);
return(transaction.ExecuteScalar <int>());
}
public IEnumerable <SourceTypeModel> Get()
{
const string commandText = @"Select chz_source_type_id,name From chz_source_types";
var transaction = Transact <SourceTypeModel> .Create(ConnectionString, commandText);
return(transaction.ExecuteReader());
}
public IEnumerable <NaklStatusModel> GetNaklStatusModels()
{
const string commandText = "Select chz_nakl_status_id,chz_nakl_status_name From chz_nakl__list_of_status";
var transact = Transact <NaklStatusModel> .Create(ConnectionString, commandText);
return(transact.ExecuteReader());
}
public IEnumerable <NaklItemStatus> GetAll()
{
const string commandText = @"Select chz_nakl_item_status_id,value,style From chz_nakl_item_statuses";
var transaction = Transact <NaklItemStatus> .Create(ConnectionString, commandText);
return(transaction.ExecuteReader());
}
public IEnumerable<NdsValue> GetAll()
{
const string commandText = @"Select chz_nds_value_id, value,is_default
From chz_nakls__list_of_nds_values";
var transaction = Transact<NdsValue>.Create(ConnectionString, commandText);
return transaction.ExecuteReader();
}
[Category("RaceToDeadLock")] // This test creates a race condition, that when resolved sequentially will be stuck
public void Transact_RaceCondition()
{
using (var handle = new ManualResetEvent(false))
{
int[] count = { 0, 0 };
var needle = Transact.CreateNeedle(5);
var winner = 0;
Assert.AreEqual(needle.Value, 5);
Task.Factory.StartNew
(
() =>
{
using (var transact = new Transact())
{
Interlocked.Increment(ref count[0]);
handle.WaitOne();
needle.Value += 2;
if (transact.Commit())
{
winner = 1;
}
Interlocked.Increment(ref count[1]);
}
}
);
Task.Factory.StartNew
(
() =>
{
using (var transact = new Transact())
{
Interlocked.Increment(ref count[0]);
handle.WaitOne();
needle.Value += 5;
if (transact.Commit())
{
winner = 2;
}
Interlocked.Increment(ref count[1]);
}
}
);
while (Thread.VolatileRead(ref count[0]) != 2)
{
Thread.Sleep(0);
}
handle.Set();
while (Thread.VolatileRead(ref count[1]) != 2)
{
Thread.Sleep(0);
}
// One, the other, or both
Trace.WriteLine("Winner: " + winner);
Trace.WriteLine("Value: " + needle.Value);
Assert.IsTrue((winner == 1 && needle.Value == 7) || (winner == 2 && needle.Value == 10) || (needle.Value == 12));
handle.Close();
}
}
public void Add(CreateNaklItemModel createNaklItemModel)
{
const string commandText = @"Insert Into chz_gtins(chz_nakl_id,count,const,vat_value,prod_sell_name)
Values(@chz_nakl_id,@count,@const,@vat_value,@prod_sell_name)";
var transaction = Transact <object> .Create(ConnectionString, commandText, parameter : createNaklItemModel);
transaction.ExecuteNonQuery();
}
public IEnumerable <AcceptType> GetAll()
{
const string commandText = @"Select chz_nakls__list_of_accept_type_id,value
From chz_nakls__list_of_accept_types";
var transaction = Transact <AcceptType> .Create(ConnectionString, commandText);
return(transaction.ExecuteReader());
}
public IEnumerable <Company> GetAll()
{
const string commandText = @"Select chz_company_id,inn,name
From chz_companies";
var transaction = Transact <Company> .Create(ConnectionString, commandText);
return(transaction.ExecuteReader());
}
public void Add(CreateNaklModel createNaklModel)
{
const string commandText = @"Insert Into chz_nakls(subject_id,shipper_id,operation_date,doc_num,doc_date,receive_type,source,contract_type,contract_num,is_direct,chz_nakl_status_id)
Values(@subject_id,@shipper_id,@operation_date,@doc_num,@doc_date,@receive_type,@source,@contract_type,@contract_num,0,1)";
var transaction = Transact <object> .Create(ConnectionString, commandText, parameter : createNaklModel);
transaction.ExecuteNonQuery();
}
public IEnumerable <CompanyResult> Get()
{
const string commandText = @"Select chz_companys.chz_company_id,org_name,inn,chz_address_id,text
From chz_companys Inner Join chz_addresses On chz_companys.chz_company_id = chz_addresses.chz_company_id";
var transaction = Transact <CompanyResult> .Create(ConnectionString, commandText);
return(transaction.ExecuteReader());
}
public IEnumerable <RecesiveType> GetAll()
{
const string commandText = @"Select chz_receive_type_id,value,is_default
From chz_receive_types";
var transaction = Transact <RecesiveType> .Create(ConnectionString, commandText);
return(transaction.ExecuteReader());
}
public virtual void Enter(Transact transact)
{
if (this.Transact != null)
{
throw new System.Exception("Element is busy");
}
this.Transact = transact;
this.Next = this.Delay;
}
public void RaceAndRetry() // TODO: Review
{
using (var handle = new ManualResetEvent(false))
{
int[] count = { 0, 0 };
var needle = Transact.CreateNeedle(5);
Assert.AreEqual(needle.Value, 5);
ThreadPool.QueueUserWorkItem
(
_ =>
{
using (var transact = new Transact())
{
Interlocked.Increment(ref count[0]);
do
{
Thread.Sleep(0);
handle.WaitOne();
needle.Value += 2;
} while (!transact.Commit());
}
Interlocked.Increment(ref count[1]);
}
);
ThreadPool.QueueUserWorkItem
(
_ =>
{
using (var transact = new Transact())
{
Interlocked.Increment(ref count[0]);
do
{
Thread.Sleep(0);
handle.WaitOne();
needle.Value += 5;
} while (!transact.Commit());
}
Interlocked.Increment(ref count[1]);
}
);
while (Thread.VolatileRead(ref count[0]) != 2)
{
Thread.Sleep(0);
}
handle.Set();
while (Thread.VolatileRead(ref count[1]) != 2)
{
Thread.Sleep(0);
}
// Both
// This is initial 5 with +2 and +5 - that's 12
Assert.AreEqual(12, needle.Value);
handle.Close();
}
}
public void RaceCondition() // TODO: Review
{
using (var handle = new ManualResetEvent(false))
{
int[] count = { 0, 0 };
var needle = Transact.CreateNeedle(5);
var winner = 0;
Assert.AreEqual(needle.Value, 5);
ThreadPool.QueueUserWorkItem
(
_ =>
{
using (var transact = new Transact())
{
Interlocked.Increment(ref count[0]);
handle.WaitOne();
needle.Value += 2;
if (transact.Commit())
{
winner = 1;
}
Interlocked.Increment(ref count[1]);
}
}
);
ThreadPool.QueueUserWorkItem
(
_ =>
{
using (var transact = new Transact())
{
Interlocked.Increment(ref count[0]);
handle.WaitOne();
needle.Value += 5;
if (transact.Commit())
{
winner = 2;
}
Interlocked.Increment(ref count[1]);
}
}
);
while (Thread.VolatileRead(ref count[0]) != 2)
{
Thread.Sleep(0);
}
handle.Set();
while (Thread.VolatileRead(ref count[1]) != 2)
{
Thread.Sleep(0);
}
// One, the other, or both
Assert.IsTrue((winner == 1 && needle.Value == 7) || (winner == 2 && needle.Value == 10) || (needle.Value == 12));
handle.Close();
}
}
