/// <summary>
/// <see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/>
/// </summary>
/// <param name="customerCode"><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></param>
/// <returns><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></returns>
public Customer GetCustomerByCode(string customerCode)
{
try
{
ICustomerManagementService customerService = IoCFactory.Instance.CurrentContainer.Resolve<ICustomerManagementService>();
return customerService.FindCustomerByCode(customerCode);
}
catch (ArgumentNullException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
}
/// <summary>
/// Enables the creation of a custom System.ServiceModel.FaultException{TDetail}
/// that is returned from an exception in the course of a service method.
/// </summary>
/// <param name="error">The System.Exception object thrown in the course of the service operation.</param>
/// <param name="version">The SOAP version of the message.</param>
/// <param name="fault">The System.ServiceModel.Channels.Message object that is returned to the client, or service in duplex case</param>
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault)
{
if (error is FaultException<ServiceError>)
{
MessageFault messageFault = ((FaultException<ServiceError>)error).CreateMessageFault();
//propagate FaultException
fault = Message.CreateMessage(version, messageFault, ((FaultException<ServiceError>)error).Action);
}
else
{
//create service error
ServiceError defaultError = new ServiceError()
{
ErrorMessage = Resources.Messages.message_DefaultErrorMessage
};
//Create fault exception and message fault
FaultException<ServiceError> defaultFaultException = new FaultException<ServiceError>(defaultError);
MessageFault defaultMessageFault = defaultFaultException.CreateMessageFault();
//propagate FaultException
fault = Message.CreateMessage(version, defaultMessageFault, defaultFaultException.Action);
}
}
/// <summary>
/// <see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/>
/// </summary>
/// <param name="orderInformation"><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></param>
/// <returns><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></returns>
public List<Order> GetOrdersByOrderInformation(OrderInformation orderInformation)
{
try
{
//Resolve root dependencies and perform operations
ISalesManagementService salesManagement = IoCFactory.Instance.CurrentContainer.Resolve<ISalesManagementService>();
return salesManagement.FindOrdersByOrderInformation(orderInformation.CustomerId, orderInformation.DateTimeFrom, orderInformation.DateTimeTo);
}
catch (ArgumentException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
}
/// <summary>
/// <see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/>
/// </summary>
///<param name="pagedCriteria"><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></param>
/// <returns><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></returns>
public List<BankAccount> GetPagedBankAccounts(PagedCriteria pagedCriteria)
{
try
{
//Resolve root dependency and perform operation
using (IBankingManagementService bankingManagement = IoCFactory.Instance.CurrentContainer.Resolve<IBankingManagementService>())
{
List<BankAccount> bankAccounts = null;
//perform work!
bankAccounts = bankingManagement.FindPagedBankAccounts(pagedCriteria.PageIndex, pagedCriteria.PageCount);
return bankAccounts;
}
}
catch (ArgumentException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
catch (NullReferenceException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
}
/// <summary>
/// <see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/>
/// </summary>
/// <param name="countryName"><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></param>
/// <returns><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></returns>
public List<Country> GetCountriesByName(string countryName)
{
try
{
//Resolve root dependencies and perform operations
ICustomerManagementService countryService = IoCFactory.Instance.CurrentContainer.Resolve<ICustomerManagementService>();
return countryService.FindCountriesByName(countryName);
}
catch (ArgumentException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
}
/// <summary>
/// <see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/>
/// </summary>
/// <param name="pagedCriteria"><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></param>
/// <returns><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></returns>
public List<Customer> GetPagedCustomer(PagedCriteria pagedCriteria)
{
try
{
//resolve root dependencies and perform query
ICustomerManagementService customerService = IoCFactory.Instance.CurrentContainer.Resolve<ICustomerManagementService>();
return customerService.FindPagedCustomers(pagedCriteria.PageIndex, pagedCriteria.PageCount);
}
catch (ArgumentException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
catch (NullReferenceException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
}
/// <summary>
/// <see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/>
/// </summary>
/// <param name="transferInformation"><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></param>
public void PerformBankTransfer(TransferInformation transferInformation)
{
try
{
using (IBankingManagementService bankingManagement = IoCFactory.Instance.CurrentContainer.Resolve<IBankingManagementService>())
{
bankingManagement.PerformTransfer(transferInformation.OriginAccountNumber,
transferInformation.DestinationAccountNumber,
transferInformation.Amount);
}
}
catch (InvalidOperationException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate bussines exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidBankAccountForTransfer
};
throw new FaultException<ServiceError>(detailedError);
}
catch (ArgumentException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate bussines exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
}
/// <summary>
/// <see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/>
/// </summary>
/// <param name="bankAccount"><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></param>
public void AddBankAccount(Domain.MainModule.Entities.BankAccount bankAccount)
{
try
{
//Resolve root dependency and perform operation
using (IBankingManagementService bankingManagement = IoCFactory.Instance.CurrentContainer.Resolve<IBankingManagementService>())
{
bankingManagement.AddBankAccount(bankAccount);
}
}
catch (ArgumentNullException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
}
/// <summary>
/// <see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/>
/// </summary>
/// <param name="bankAccountNumber"><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></param>
/// <returns><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></returns>
public BankAccount GetBankAccountByNumber(string bankAccountNumber)
{
try
{
//Resolve root dependency and perform operation
IBankingManagementService bankingManagement = IoCFactory.Instance.CurrentContainer.Resolve<IBankingManagementService>();
BankAccount bankAccount = null;
//perform work!
bankAccount = bankingManagement.FindBankAccountByNumber(bankAccountNumber);
return bankAccount;
}
catch (ArgumentNullException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
}
/// <summary>
/// <see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/>
/// </summary>
/// <param name="product"><see cref="Microsoft.Samples.NLayerApp.DistributedServices.MainModule.IMainModuleService"/></param>
public void ChangeProduct(Product product)
{
try
{
//Resolve root dependencies and perform query
ISalesManagementService salesManagement = IoCFactory.Instance.CurrentContainer.Resolve<ISalesManagementService>();
salesManagement.ChangeProduct(product);
}
catch (ArgumentNullException ex)
{
//trace data for internal health system and return specific FaultException here!
//Log and throw is a knowed anti-pattern but in this point ( entry point for clients this is admited!)
//log exception for manage health system
ITraceManager traceManager = IoCFactory.Instance.CurrentContainer.Resolve<ITraceManager>();
traceManager.TraceError(ex.Message);
//propagate exception to client
ServiceError detailedError = new ServiceError()
{
ErrorMessage = Resources.Messages.exception_InvalidArguments
};
throw new FaultException<ServiceError>(detailedError);
}
}
