public void LoadChildren(ITransactionController transactionController, TreeNodeData<ActionKey> node) { ClaimHeaderDto headerDto = ((ClaimModel)transactionController.Model).HeaderDto; List<DtoBase> invToLoad = headerDto.ClaimVehicleInvolvements.Where(x => x.ClaimInsuredObject.ClaimIOVehicles == null).ToList<DtoBase>(); this.LoadInvolvements(transactionController, node, headerDto.ClaimVehicleInvolvements, invToLoad, Xiap.Metadata.Data.Enums.StaticValues.InternalIOType.Vehicle); }
private IPaymentProcessor CreatePaymentProcessor(DateTime creditCardExpiryDate) { var creditCard = FacadeTestData.CreateMockCreditCard(creditCardExpiryDate); var txnReq = FacadeTestData.CreateMockTransactionRequest(_billingAddress, creditCard); _transactionController = FacadeTestData.CreateMockTransactionController(txnReq, creditCard); return(new PaymentProcessor(_environment, _merchantAuthenticationType, _transactionController)); }
public EntryPoint( ITransactionController transaction, IDataStoreDataCacheProvider dataStoreDataCacheProvider, ILogger logger) { _transaction = transaction; _dataStoreDataCacheProvider = dataStoreDataCacheProvider; _logger = logger; }
public PaymentProcessor( IEnvironment environment, IMerchantAuthenticationType merchAuthType, ITransactionController txnCtrl) { // TODO: Add data invariance. Use contracts? _environment = environment; _merchAuthType = merchAuthType; _txnCtrl = txnCtrl; }
public bool AreEquivalentSharedControllers(ITransactionController transactionController) { var queryTransactionController = transactionController as QueryTransactionController; if (queryTransactionController == null) { return(false); } return(ReferenceEquals(_dataProvider, queryTransactionController._dataProvider)); }
protected void LoadInvolvements(ITransactionController transactionController, TreeNodeData<ActionKey> node, List<ClaimInvolvementDto> claimInvolvements, List<DtoBase> invToLoad, StaticValues.InternalIOType type) { ClaimHeaderDto headerDto = ((ClaimModel)transactionController.Model).HeaderDto; if (headerDto.ClaimInvolvementLinks != null) { claimInvolvements.ForEach(CI => { var involvementLinkFrom = headerDto.ClaimInvolvementLinks.Where(CIL => ((ClaimInvolvementLinkData)CIL.Data).ClaimInvolvementFromDataId == CI.Data.DataId); involvementLinkFrom.ForEach(y => { var involvement = headerDto.ClaimInvolvements.Where(z => z.Data.DataId == ((ClaimInvolvementLinkData)y.Data).ClaimInvolvementToDataId); invToLoad.AddRange(involvement); }); var involvementLinkTo = headerDto.ClaimInvolvementLinks.Where(CIL => ((ClaimInvolvementLinkData)CIL.Data).ClaimInvolvementToDataId == CI.Data.DataId); involvementLinkTo.ForEach(y => { var involvement = headerDto.ClaimInvolvements.Where(z => z.Data.DataId == ((ClaimInvolvementLinkData)y.Data).ClaimInvolvementFromDataId); invToLoad.AddRange(involvement); }); }); } int invToLoadCount = invToLoad.Distinct().Count(); int count = 0; if (invToLoad.Distinct().Any()) { transactionController.LoadLiteData( Guid.Empty, RetrievalType.WithChildHierarchy, invToLoad.Distinct(), NavigationType.None, null, r => { if (++count == invToLoadCount) { var model = (ClaimModel)transactionController.Model; model.CreateAllInsuredObjectCollection(type); node.IsLoaded = true; } }, true, BusinessDataVariant.Full); } else { node.IsLoaded = true; } }
/// <summary> /// Method to check whether the node will be available on screen or not. /// </summary> /// <param name="transactionController">Object of ITransactionController</param> /// <param name="definition">Tree Structure Store</param> /// <param name="parentDto">Dto base</param> /// <returns>bool value</returns> public bool IsAvailable(ITransactionController transactionController, TreeStructureStore definition, DtoBase parentDto) { bool result = true; if (this._appModel.ShellConfiguration.ConfigurationSettings["NameFinancialAccountMaintenancePermissionToken"] != null && !this._appModel.ShellConfiguration.ConfigurationSettings["NameFinancialAccountMaintenancePermissionToken"].SettingParmeters.IsNullOrEmpty()) { string tokenName = this._appModel.ShellConfiguration.ConfigurationSettings["NameFinancialAccountMaintenancePermissionToken"].SettingParmeters[0].SettingValue; if (!string.IsNullOrEmpty(tokenName) && !this._appModel.UserProfile.HasPermission(tokenName)) { result = false; } } return result; }
private ObservableCollection<TreeNodeData<ActionKey>> CreateNodesForDefinition(ITransactionController transactionController, TreeStructureStore definition, DtoBase dto) { AXAClaimModel model = (AXAClaimModel)transactionController.Model; ObservableCollection<TreeNodeData<ActionKey>> nodes = new ObservableCollection<TreeNodeData<ActionKey>>(); INodeAvailabilityBehaviour nodeAvailabilityBehavior = transactionController.Container.Resolve<INodeAvailabilityBehaviour>(definition.AvailabilityBehaviour); if (nodeAvailabilityBehavior.IsAvailable(transactionController, definition, dto)) { var groupDefinition = definition.Clone(); groupDefinition.Parent = definition.Parent; var groupingNode = transactionController.CreateNavigationData(groupDefinition, dto); groupingNode.Context = transactionController.Model; model.RefreshProperty(); nodes.Add(groupingNode); } return nodes; }
public void Flush(ITransactionController controller) { if (insertModels.Count > 0) { var insert = insertModels.Values.Select(x => x.ToEntityModel()).ToArray(); controller.Insert(insert); } if (updateModels.Count > 0) { var update = updateModels.Values.Select(x => x.ToEntityModel()).ToArray(); controller.Update(update); } if (deleteModels.Count > 0) { var delete = deleteModels.Values.Select(x => x.ToEntityModel()).ToArray(); controller.Delete(delete); } this.Clear(); }
public void LoadChildren(ITransactionController transactionController, TreeNodeData<ActionKey> node) { node.IsLoaded = true; }
public IEnumerable<TreeNodeData<ActionKey>> CreateNodes(ITransactionController transactionController, TreeStructureStore definition, DtoBase parentDto) { return this.CreateNodesForDefinition(transactionController, definition, parentDto); }
public void SetSharedTransactionController(ITransactionController transactionController) { _transactionController = transactionController as QueryTransactionController; }
static void Main(string[] args) { DataAccess data = new DataAccess(); //clean up the table data.ClearupTable(); //--------------Sample 1--------------------------------// ITransactionController transaction_A = TransactionManager.GetRequireTransactionController(); try { transaction_A.ExecuteMethod(data, "AddNewRecord", new object[2] { "xin", "111111111" }); transaction_A.ExecuteMethod(data, "AddNewRecord", new object[2] { "mike", "222222222" }); //this call will fail due to duplicate key error. transaction_A.ExecuteMethod(data, "AddNewRecord", new object[2] { "john", "111111111" }); TransactionManager.Commit(transaction_A); } catch (Exception ex) { TransactionManager.Rollback(transaction_A); //additional error handling code.... } finally { //release the resource used by the serviced component TransactionManager.DisposeAll(transaction_A); } //--------------Sample 1 result --------------------------// //None of three record is inserted to the employee table. // //--------------------------------------------------------// //clean up the table data.ClearupTable(); //--------------Sample 2----------------------------------// ITransactionController transaction_C = TransactionManager.GetRequireNewTransactionController(); ITransactionController transaction_B = TransactionManager.GetRequireTransactionController(); try { transaction_B.ExecuteMethod(data, "AddNewRecord", "xin", "111111111"); transaction_B.ExecuteMethod(data, "AddNewRecord", "mike ", "222222222"); try { //add an important employee. Add him regardless whether other //employees are added to table successfully transaction_C.ExecuteMethod(data, "AddNewRecord", "bill", "333333333"); TransactionManager.Commit(transaction_C); } catch (Exception ex) { TransactionManager.Rollback(transaction_C); } //this call will fail due to duplicate key error. transaction_B.ExecuteMethod(data, "AddNewRecord", new object[2] { "john", "111111111" }); TransactionManager.Commit(transaction_B); } catch (Exception ex) { TransactionManager.Rollback(transaction_B); //additional error handling code.... } finally { //release the resource used by the serviced component TransactionManager.DisposeAll(transaction_B, transaction_C); } //--------------Sample 2 result ---------------------------// //----------Only bill is added to the employee table.------// //---------------------------------------------------------// //clean up the table data.ClearupTable(); //--------------Sample 3-----------------------------------// ITransactionController transaction_D = TransactionManager.GetNoTransactionController(); ITransactionController transaction_E = TransactionManager.GetSupportTransactionController(); ITransactionController transaction_F = TransactionManager.GetRequireTransactionController(); try { data.AddNewRecord("xin", "111111111"); transaction_D.ExecuteMethod(data, "AddNewRecord", "mike", "222222222"); transaction_E.ExecuteMethod(data, "AddNewRecord", "bill", "333333333"); //this call will fail due to duplicate key error. transaction_F.ExecuteMethod(data, "AddNewRecord", "john", "111111111"); TransactionManager.Commit(transaction_D, transaction_E, transaction_F); } catch (Exception ex) { TransactionManager.Rollback(transaction_D, transaction_E, transaction_F); //additional error handling code.... } finally { //release the resource used by the serviced component TransactionManager.DisposeAll(transaction_D, transaction_E, transaction_F); } //--------------Sample 3 result --------------------------------------------// //only xin, mike, bill are added to the employee table. John is not added.--// //--------------------------------------------------------------------------// }
public HomeController() { _transactionsController = new TransactionsController(new BizfitechHttpClient()); }