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