public async Task DeletionSucceeds()
{
// Arrange
using var trx = TransactionFactory.ReadCommitted();
var idsToDelete = new List <int> {
Declarations.PeterUserId
};
// Act
var(result, emails) = await Repo.Users__Delete(idsToDelete, validateOnly : false, top : Top, userId : UserId);
// Assert
Assert.False(result.IsError);
Assert.Empty(result.Errors);
var email = Assert.Single(emails);
Assert.Equal("*****@*****.**", email);
var afterUser = await Repo.Users
.FilterByIds(idsToDelete)
.FirstOrDefaultAsync(Context);
Assert.Null(afterUser);
}
public async Task InvitationSucceeds()
{
// Arrange
using var trx = TransactionFactory.ReadCommitted();
var id = LucyUserId; // New user
var ids = new List <int> {
id
};
// Act
var(result, users) = await Repo.Users__Invite(ids, validateOnly : false, top : Top, userId : UserId);
// Assert
Assert.False(result.IsError);
Assert.Empty(result.Errors);
var user = Assert.Single(users);
Assert.Equal(id, user.Id);
Assert.Equal("Lucy", user.Name);
Assert.Equal("لوسي", user.Name2);
Assert.Equal("*****@*****.**", user.Email);
var afterUser = await Repo.Users.FilterByIds(ids).FirstOrDefaultAsync(Context);
Assert.NotNull(afterUser.InvitedAt);
Assert.Equal((byte)1, afterUser.State);
}
internal void WithdrawWithSpecTime(decimal amount, DateTime dateTime)
{
if (amount <= 0)
{
throw new BusinessRulesException("Amount cannot be lower than 0!");
}
// get incurred fee and add to total amount to reduce
decimal totalAmountToReduce = 0;
decimal serviceFee = GetIncurredFee();
totalAmountToReduce += amount;
totalAmountToReduce += serviceFee;
// Perform changing balance first to check if satisfying the transferring conditions
Account.ChangeBalance(-totalAmountToReduce);
// Generate transaction
Transaction transaction = TransactionFactory.GenerateTransactionWithSpecTime(Account.AccountNumber, null, TransactionType.Withdraw, amount, null, dateTime);
Account.Transactions.Add(transaction);
Console.WriteLine("\nGenerated Transaction: \n{0}", transaction);
// apply incurred fee and generate service fee transaction
if (serviceFee != 0)
{
Transaction feeTransaction = TransactionFactory.GenerateTransactionWithSpecTime(Account.AccountNumber, null, TransactionType.ServiceCharge, serviceFee, null, dateTime);
Account.Transactions.Add(feeTransaction);
Console.WriteLine("\nGenerated Transaction: \n{0}", feeTransaction);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var response = new TransactionsStreamResponse();
var jsonToken = JToken.Load(reader);
if (jsonToken.Type == JTokenType.Object)
{
bool isHeartbeat = jsonToken["type"].Value <string>() == "HEARTBEAT";
if (isHeartbeat)
{
var heartbeat = new TransactionsHeartbeat();
serializer.Populate(jsonToken.CreateReader(), heartbeat);
response.heartbeat = heartbeat;
}
else
{
ITransaction transaction = TransactionFactory.Create(jsonToken["type"].Value <string>());
serializer.Populate(jsonToken.CreateReader(), transaction);
response.transaction = transaction;
}
return(response);
}
else
{
throw new ArgumentException(string.Format("Unexpected JTokenType ({0}) in reader.", jsonToken.Type.ToString()));
}
}
public void TransactionRollback()
{
TestUtilities.ResetDatabase();
using (var scope = TransactionFactory.Create())
{
Company companyGwiSoftware = new Company();
companyGwiSoftware.Name = "GWI Software";
companyGwiSoftware.Location = "Vancouver";
CompanyService.Save(companyGwiSoftware);
Customer customerDanGreen = new Customer();
customerDanGreen.FirstName = "Dan";
customerDanGreen.LastName = "Green";
customerDanGreen.CompanyId = companyGwiSoftware.Id;
CustomerService.Save(customerDanGreen);
Assert.AreNotEqual(null, customerDanGreen.Id);
}
var companies = CompanyService.GetCollection();
Assert.AreEqual(1, companies.Count);
var customers = CustomerService.GetCollection();
Assert.AreEqual(2, customers.Count);
}
public static void InsertNewDetailTrans(int transId, int productId, int quantity)
{
DetailTransaction detailTrans = TransactionFactory.CreateNewDetailTrans(transId, productId, quantity);
db.DetailTransactions.Add(detailTrans);
db.SaveChanges();
}
// Transfer between accounts set in this adapter
private void Transfer(decimal amount, DateTime dateTime)
{
if (amount <= 0)
{
throw new BusinessRulesException("Amount cannot be lower than 0!");
}
// get incurred fee and add to total amount to reduce
decimal serviceFee = GetIncurredFee();
decimal totalAmountToReduce = 0;
totalAmountToReduce += amount;
totalAmountToReduce += serviceFee;
// Perform changing balance first to check if satisfying the transferring conditions
RootAccount.ChangeBalance(-totalAmountToReduce);
DestinationAccount.ChangeBalance(amount);
// apply incurred fee and generate its transaction to root account
if (serviceFee != 0)
{
Transaction feeTransaction = TransactionFactory.GenerateTransactionWithSpecTime(RootAccount.AccountNumber, null, TransactionType.ServiceCharge, serviceFee, null, dateTime);
RootAccount.Transactions.Add(feeTransaction);
}
// Add transaction
RootAccount.Transactions.Add(Transaction);
// Remove to avoid Save changes glitch where account ant Destination becomes the same
DestinationAccount.ReceivingTransactions.Add(Transaction);
Transaction.DestinationAccount = DestinationAccount;
Transaction.Account = RootAccount;
}
public bool VerifyTransactionFromTopResident(bool startTransaction)
{
try
{
Transaction createdTrans;
if (startTransaction)
{
var db = Application.DocumentManager.MdiActiveDocument.Database;
using (var trans = db.TransactionManager.StartTransaction())
{
createdTrans = TransactionFactory.CreateFromTop();
}
}
else
{
createdTrans = TransactionFactory.CreateFromTop();
}
return(createdTrans != null);
}
catch
{
return(false);
}
}
public async Task HandleCallback(SmsEventNotification smsEvent, CancellationToken cancellation)
{
// Nothing to do
if (smsEvent == null || smsEvent.TenantId == null || smsEvent.TenantId == 0) // Right now we do not handle null tenant Ids, those were probably sent from identity or admin servers
{
return;
}
// Map the event to the database representation
var state = smsEvent.Event switch
{
SmsEvent.Sent => MessageState.Sent,
SmsEvent.Failed => MessageState.SendingFailed,
SmsEvent.Delivered => MessageState.Delivered,
SmsEvent.Undelivered => MessageState.DeliveryFailed,
_ => throw new InvalidOperationException($"[Bug] Unknown {nameof(SmsEvent)} = {smsEvent.Event}"), // Future proofing
};
// Update the state in the database (should we make it serializable?)
var repo = _repoFactory.GetRepository(tenantId: smsEvent.TenantId.Value);
// Begin serializable transaction
using var trx = TransactionFactory.Serializable(TransactionScopeOption.RequiresNew);
await repo.Notifications_Messages__UpdateState(
id : smsEvent.MessageId,
state : state,
timestamp : smsEvent.Timestamp,
error : smsEvent.Error,
cancellation : cancellation);;
trx.Complete();
}
public void TransactionFactoryUpdateTest()
{
String currency = "USD";
String merchant = "IG Group";
String desc = "Test Update";
Decimal amount = 56.12M;
DateTime tdate = DateTime.Now;
TransactionFactory tf = TransactionFactory.Instance();
ITransaction output = tf.Get(1);
Transaction input = new Transaction();
input.TransactionId = output.TransactionId;
input.CurrencyCode = currency;
input.Description = desc;
input.Merchant = merchant;
input.TransactionAmount = amount;
input.TransactionDate = output.TransactionDate;
output = tf.Update(input);
Assert.IsNotNull(output);
Assert.IsTrue(output.ModifiedDate >= tdate && output.ModifiedDate <= DateTime.Now,
String.Format("CreationDateTest {0} >= {1} <= {2}", output.ModifiedDate, tdate, DateTime.Now));
Assert.IsTrue(output.CreatedDate <= output.ModifiedDate, String.Format("ModifiedDateTest {0} <= {1}", output.CreatedDate, output.ModifiedDate));
Assert.AreEqual(currency, output.CurrencyCode);
Assert.AreEqual(merchant, output.Merchant);
Assert.AreEqual(desc, output.Description);
Assert.AreEqual(amount, output.TransactionAmount);
}
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;
}
}
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 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 async Task SavingDuplicateEmailsFails()
{
var chloe = Chloe();
var jordan = Jordan();
jordan.Email = chloe.Email; // Error!
// Arrange
var users = new List <UserForSave> {
chloe, jordan
};
// Act
using var trx = TransactionFactory.ReadCommitted();
var result = await Repo.Users__Save(users, returnIds : true, validateOnly : false, top : Top, userId : UserId);
// Assert
Assert.True(result.IsError);
Assert.Collection(result.Errors,
error =>
{
Assert.Equal("[0].Email", error.Key);
Assert.Equal("Error_TheEmail0IsDuplicated", error.ErrorName);
Assert.Equal(chloe.Email.ToLower(), error.Argument1.ToLower());
},
error =>
{
Assert.Equal("[1].Email", error.Key);
Assert.Equal("Error_TheEmail0IsDuplicated", error.ErrorName);
Assert.Equal(chloe.Email.ToLower(), error.Argument1.ToLower());
}
);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jsonToken = JToken.Load(reader);
if (jsonToken.Type == JTokenType.Array)
{
var transactions = new List <ITransaction>();
var jsonArray = (JArray)jsonToken;
foreach (var item in jsonArray)
{
var transaction = TransactionFactory.Create(item["type"].Value <string>());
serializer.Populate(item.CreateReader(), transaction);
transactions.Add(transaction);
}
return(transactions);
}
else if (jsonToken.Type == JTokenType.Object)
{
ITransaction transaction = TransactionFactory.Create(jsonToken["type"].Value <string>());
serializer.Populate(jsonToken.CreateReader(), transaction);
return(transaction);
}
else
{
throw new ArgumentException(string.Format("Unexpected JTokenType ({0}) in reader.", jsonToken.Type.ToString()));
}
}
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 TransactionAddManager(CSVParser parser = null, TransactionFactory transactionFactory = null,
ReportWatcher reportWatcher = null)
{
this._parser = parser;
this._transactionFactory = transactionFactory;
this.ReportWatcher = reportWatcher;
}
public async Task TransactionCommitAsync()
{
TestUtilities.ResetDatabase();
using (var scope = TransactionFactory.CreateAsync())
{
Company companyGwiSoftware = new Company();
companyGwiSoftware.Name = "GWI Software";
companyGwiSoftware.Location = "Vancouver";
await CompanyService.SaveAsync(companyGwiSoftware);
Customer customerDanGreen = new Customer();
customerDanGreen.FirstName = "Dan";
customerDanGreen.LastName = "Green";
customerDanGreen.CompanyId = companyGwiSoftware.Id;
await CustomerService.SaveAsync(customerDanGreen);
Assert.AreNotEqual(null, customerDanGreen.Id);
scope.Complete();
}
var companies = await CompanyService.GetCollectionAsync();
Assert.AreEqual(2, companies.Count);
var customers = await CustomerService.GetCollectionAsync();
Assert.AreEqual(3, customers.Count);
}
public override void UpdateAll()
{
if (_cleared)
{
return;
}
if (Junctions == null || Roads == null)
{
return;
}
using (var acTrans = TransactionFactory.CreateFromNew())
{
if (ValidateRoads())
{
GenerateLayout();
}
else
{
FinalizeLayout();
}
acTrans.Commit();
}
}
public static string FindByUserId(int userId)
{
List <TransactionHeader> result = new List <TransactionHeader>();
var headers = TransactionRepository.FindByUserId(userId);
if (headers.Count < 1)
{
return("");
}
else
{
foreach (var header in headers)
{
List <TransactionDetail> finalDetail = new List <TransactionDetail>();
List <TransactionDetail> transactionDetails = TransactionRepository.FindDetailByHeaderId(header.Id);
foreach (var detail in transactionDetails)
{
Product product = ProductRepository.FindByProductId(detail.ProductId);
finalDetail.Add(TransactionFactory.CreateDetail(header.Id, product, detail.Quantity));
}
TransactionHeader finalHeader = TransactionFactory.CreateHeader(header.Id, header.UserId, header.TransactionDate, finalDetail);
result.Add(finalHeader);
}
return(JsonHandler.Encode(result));
}
}
public async Task <UnreconciledResult> SaveAndGetUnreconciled(ReconciliationSavePayload payload, ReconciliationGetUnreconciledArguments args)
{
await Initialize();
// Start transaction
using var trx = TransactionFactory.ReadCommitted();
// Preprocess and Validate
await PermissionsPreprocessAndValidate(args.AccountId, args.AgentId, payload);
// Save
UnreconciledOutput output = await _behavior.Repository.Reconciliations__SaveAndLoad_Unreconciled(
accountId : args.AccountId,
agentId : args.AgentId,
externalEntriesForSave : payload.ExternalEntries,
reconciliations : payload.Reconciliations,
deletedExternalEntryIds : payload.DeletedExternalEntryIds,
deletedReconciliationIds : payload.DeletedReconciliationIds,
asOfDate : args.AsOfDate,
top : args.EntriesTop,
skip : args.EntriesSkip,
topExternal : args.ExternalEntriesTop,
skipExternal : args.ExternalEntriesSkip,
userId : UserId);
trx.Complete();
return(MapFromOutput(output));
}
protected override async Task ExecuteAsync(CancellationToken cancellation)
{
_logger.LogInformation(GetType().Name + " Started.");
while (!cancellation.IsCancellationRequested)
{
try
{
// Begin serializable transaction
using var trx = TransactionFactory.Serializable(TransactionScopeOption.RequiresNew);
// Signal that the current instance is still alive
await _repo.Heartbeat(_instanceInfo.Id, _options.InstanceKeepAliveInSeconds, cancellation);
trx.Complete();
}
catch (TaskCanceledException) { }
catch (OperationCanceledException) { }
catch (Exception ex)
{
_logger.LogError(ex, $"Error in {GetType().Name}.");
}
await Task.Delay(_options.InstanceHeartRateInSeconds * 1000, cancellation);
}
}
public async Task <IActionResult> Create([Bind(properties)] RequestTransactionView model)
{
bool senderExists = await checkIfSenderAccountExists(model.SenderAccountId);
if (senderExists)
{
var receiverObject = await accounts.GetObject(model.ReceiverAccountId);
var senderObject = await accounts.GetObject(model.SenderAccountId);
bool senderIsOk = validateReceiverAndSender(receiverObject, senderObject);
bool receiverIsOk = validateReceiver(receiverObject);
if (senderIsOk && receiverIsOk)
{
model.ID = Guid.NewGuid().ToString();
var request = TransactionFactory.CreateRequest(model.ID, model.Amount,
model.Explanation, model.SenderAccountId, model.ReceiverAccountId,
TransactionStatus.Pending, DateTime.Now, model.ValidTo);
await requests.AddObject(request);
await generateRequestNotification(request);
TempData["TransactionStatus"] =
"Request successfully done to " + model.ReceiverAccountId + " from " +
model.SenderAccountId +
" in the amount of " + model.Amount + ". ";
}
}
return(RedirectToAction("SentIndex", new { id = model.ReceiverAccountId }));
}
public void WhenAddStepAfterTransactionRun_ShouldThrowException()
{
// Arrange
ITransaction <string, object> target = new TransactionFactory().Create <string, object>(options =>
{
options.TransactionInfo.Name = "test transaction";
});
target.Add(new TransactionStep <string, object>()
{
Id = "1",
StepAction = (data, info) => { }
});
target.Run(settings =>
{
settings.Mode = RunMode.Run;
});
// Act
target.Add(new TransactionStep <string, object>()
{
Id = "1",
StepAction = (data, info) => { }
});
// Assert
Assert.Fail("An exception is expected.");
}
public override IContext CreateContext(string contextName, ContextSchema schema)
{
if (string.IsNullOrEmpty(contextName))
{
throw new ArgumentNullException("contextName");
}
if (schema == null)
{
throw new ArgumentNullException("schema");
}
IContext context;
lock (padlock) {
if (ContextsContains(contextName))
{
throw new ContextAlreadyExistsException("A context with the name [" + contextName + "] already exists.");
}
using (var transaction = TransactionFactory.BeginTransaction(CurrentDB)) {
CurrentDB.ExecuteNonQuery("dbo.USER_CreateContext",
transaction,
CurrentDB.CreateStringInputParameter("@chvContext", DbType.AnsiString, contextName));
foreach (var s in schema)
{
AddSchemaToContext(s, contextName, transaction);
}
context = new Context(contextName);
transaction.Commit();
}
contexts.Add(context);
}
return(context);
}
public object Get(TransactionsGetRequestTep request)
{
var context = TepWebContext.GetWebContext(PagePrivileges.UserView);
var result = new List <WebTransaction>();
try {
context.Open();
context.LogInfo(this, string.Format("/transaction GET, user='******'", request.User ?? context.Username));
var user = User.FromUsername(context, request.User ?? context.Username);
var TransactionFactory = new TransactionFactory(context);
var aggTransactions = TransactionFactory.GetUserAggregatedTransaction(user.Id);
foreach (var agg in aggTransactions)
{
result.Add(new WebTransaction(agg));
}
context.Close();
} catch (Exception e) {
context.LogError(this, e.Message, e);
context.Close();
throw e;
}
return(result);
}
public override void SaveProperties(IUser user, IPropertyCollection propertyCollection)
{
using (var transaction = TransactionFactory.BeginTransaction(CurrentDB)) {
SaveProperties(user, propertyCollection, transaction);
transaction.Commit();
}
}
public override void SaveUser(IUser user)
{
using (var transaction = TransactionFactory.BeginTransaction(CurrentDB)) {
SaveUser(user, transaction);
transaction.Commit();
}
}
private async Task <EntitiesResult <EntryType> > SetIsActive(List <int> ids, ActionArguments args, bool isActive)
{
await Initialize();
// Check user permissions
var action = "IsActive";
var actionFilter = await UserPermissionsFilter(action, cancellation : default);
ids = await CheckActionPermissionsBefore(actionFilter, ids);
// Execute and return
using var trx = TransactionFactory.ReadCommitted();
OperationOutput output = await _behavior.Repository.EntryTypes__Activate(
ids : ids,
isActive : isActive,
validateOnly : ModelState.IsError,
top : ModelState.RemainingErrors,
userId : UserId);
AddErrorsAndThrowIfInvalid(output.Errors);
var result = (args.ReturnEntities ?? false) ?
await GetByIds(ids, args, action, cancellation : default) :
EntitiesResult <EntryType> .Empty();
// Check user permissions again
await CheckActionPermissionsAfter(actionFilter, ids, result.Data);
trx.Complete();
return(result);
}
protected override async Task ExecuteAsync(CancellationToken cancellation)
{
_logger.LogInformation(GetType().Name + " Started.");
while (!cancellation.IsCancellationRequested)
{
try
{
// Begin serializable transaction
using var trx = TransactionFactory.Serializable(TransactionScopeOption.RequiresNew);
// Load a batch of orphans
int keepAliveSeconds = _options.InstanceKeepAliveInSeconds;
int batchCount = _options.OrphanAdoptionBatchCount;
var orphans = await _repo.AdoptOrphans(_instanceInfo.Id, keepAliveSeconds, batchCount, cancellation);
// Make them available for processing to all the various background Jobs
_instanceInfo.AddNewlyAdoptedOrphans(orphans);
trx.Complete();
}
catch (TaskCanceledException) { }
catch (OperationCanceledException) { }
catch (Exception ex)
{
_logger.LogError(ex, $"Error in {GetType().Name}.");
}
await Task.Delay(_options.OrphanAdoptionFrequencyInSeconds * 1000, cancellation);
}
}
// This is the main program.... I have filled out the shell of what should run....
// the rest is up to you.....
static void Main(string[] args)
{
IInputOutput io = new InputOutput();
ITransactionFactory transactionFactory = new TransactionFactory();
IAccountFactory accountFactory = new AccountFactory();
IBank localBank = new Bank(transactionFactory, accountFactory);
Console.WriteLine("Welcome to your local bank's ATM, how can I assist you today");
bool exit = false;
while (!exit)
{
Console.WriteLine("Options: (a)dd Account\n (d)eposit\n (w)ithdraw\n (b)alance\n (e)xit");
string option = Console.ReadLine();
switch (option)
{
case "a":
case "A":
AddAccount(localBank, io);
break;
case "d":
case "D":
Deposit(localBank, io, transactionFactory);
break;
case "w":
case "W":
Withdrawal(localBank, io, transactionFactory);
break;
case "b":
case "B":
Balance(localBank, io);
break;
case "e":
case "E":
exit = true;
break;
default:
Console.WriteLine("I'm sorry, but '{0}' is an invalid option, please try again.", option);
break;
}
}
Console.WriteLine("Thanks for stopping by");
}
private void InitTransactionClass(HttpContext context)
{
var transactionFactory = new TransactionFactory();
context.Items[NHibernateTransactionSessionKey] = transactionFactory;
}
