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; }