public HttpResponseMessage GetCustomer([FromUri] Guid customerID)
{
CustomersApiModel customersWebApiModel = new CustomersApiModel();
TransactionalInformation transaction = new TransactionalInformation();
CustomersBusinessService customersBusinessService;
customersWebApiModel = new CustomersApiModel();
customersBusinessService = new CustomersBusinessService(customersDataService);
Customer customer = customersBusinessService.GetCustomer(customerID, out transaction);
customersWebApiModel.Customer = customer;
customersWebApiModel.IsAuthenicated = true;
customersWebApiModel.ReturnStatus = transaction.ReturnStatus;
customersWebApiModel.ReturnMessage = transaction.ReturnMessage;
if (transaction.ReturnStatus == true)
{
var response = Request.CreateResponse<CustomersApiModel>(HttpStatusCode.OK, customersWebApiModel);
return response;
}
var badResponse = Request.CreateResponse<CustomersApiModel>(HttpStatusCode.BadRequest, customersWebApiModel);
return badResponse;
}
public HttpResponseMessage GetProduct(Guid productID)
{
ProductsApiModel productsWebApiModel = new ProductsApiModel();
TransactionalInformation transaction = new TransactionalInformation();
ProductsBusinessService productsBusinessService;
productsWebApiModel = new ProductsApiModel();
productsWebApiModel.IsAuthenicated = true;
productsBusinessService = new ProductsBusinessService(productsDataService);
Product product = productsBusinessService.GetProduct(productID, out transaction);
productsWebApiModel.Product = product;
productsWebApiModel.IsAuthenicated = true;
productsWebApiModel.ReturnStatus = transaction.ReturnStatus;
productsWebApiModel.ReturnMessage = transaction.ReturnMessage;
if (transaction.ReturnStatus == true)
{
var response = Request.CreateResponse<ProductsApiModel>(HttpStatusCode.OK, productsWebApiModel);
return response;
}
var badResponse = Request.CreateResponse<ProductsApiModel>(HttpStatusCode.BadRequest, productsWebApiModel);
return badResponse;
}
/// <summary>
/// Initialize Application
/// </summary>
/// <param name="transaction"></param>
public List<ApplicationMenu> GetMenuItems(Boolean isAuthenicated, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
List<ApplicationMenu> menuItems = new List<ApplicationMenu>();
try
{
applicationDataService.CreateSession();
menuItems = applicationDataService.GetMenuItems(isAuthenicated);
transaction.ReturnStatus = true;
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
applicationDataService.CloseSession();
}
return menuItems;
}
/// <summary>
/// Get Product
/// </summary>
/// <param name="productID"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public Product GetProduct(Guid productID, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
Product product = new Product();
try
{
productsDataService.CreateSession();
product = productsDataService.GetProduct(productID);
transaction.ReturnStatus = true;
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
productsDataService.CloseSession();
}
return product;
}
public override void OnActionExecuting(System.Web.Http.Controllers.HttpActionContext actionContext)
{
var request = actionContext.Request;
var headers = request.Headers;
if (!headers.Contains("X-Requested-With") || headers.GetValues("X-Requested-With").FirstOrDefault() != "XMLHttpRequest")
{
TransactionalInformation transactionInformation = new TransactionalInformation();
transactionInformation.ReturnMessage.Add("Access has been denied.");
transactionInformation.ReturnStatus = false;
actionContext.Response = request.CreateResponse<TransactionalInformation>(HttpStatusCode.BadRequest, transactionInformation);
}
else
{
HttpContext ctx = default(HttpContext);
ctx = HttpContext.Current;
if (ctx.User.Identity.IsAuthenticated == false)
{
TransactionalInformation transactionInformation = new TransactionalInformation();
transactionInformation.ReturnMessage.Add("Your session has expired.");
transactionInformation.ReturnStatus = false;
actionContext.Response = request.CreateResponse<TransactionalInformation>(HttpStatusCode.BadRequest, transactionInformation);
}
}
}
/// <summary>
/// customer Inquiry
/// </summary>
/// <param name="customerCode"></param>
/// <param name="companyName"></param>
/// <param name="paging"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public List<Customer> CustomerInquiry(string customerCode, string companyName, DataGridPagingInformation paging, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
List<Customer> customers = new List<Customer>();
try
{
customersDataService.CreateSession();
customers = customersDataService.CustomerInquiry(customerCode, companyName, paging, out transaction);
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
customersDataService.CloseSession();
}
return customers;
}
/// <summary>
/// product Inquiry
/// </summary>
/// <param name="productCode"></param>
/// <param name="companyName"></param>
/// <param name="paging"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public List<Product> ProductInquiry(string productCode, string description, DataGridPagingInformation paging, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
List<Product> products = new List<Product>();
try
{
productsDataService.CreateSession();
products = productsDataService.ProductInquiry(productCode, description, paging, out transaction);
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
productsDataService.CloseSession();
}
return products;
}
/// <summary>
/// Get Customer
/// </summary>
/// <param name="customerID"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public Customer GetCustomer(Guid customerID, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
Customer customer = new Customer();
try
{
customersDataService.CreateSession();
customer = customersDataService.GetCustomer(customerID);
transaction.ReturnStatus = true;
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
customersDataService.CloseSession();
}
return customer;
}
/// <summary>
/// Initialize Application
/// </summary>
/// <param name="transaction"></param>
public void InitializeApplication(out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
try
{
applicationDataService.CreateSession();
applicationDataService.InitializeApplication();
applicationDataService.CommitTransaction(true);
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Application has been initialized.");
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
applicationDataService.CloseSession();
}
}
public HttpResponseMessage AuthenicateUser([FromUri] string route)
{
TransactionalInformation transaction = new TransactionalInformation();
transaction.IsAuthenicated = User.Identity.IsAuthenticated;
var response = Request.CreateResponse<TransactionalInformation>(HttpStatusCode.OK, transaction);
return response;
}
public HttpResponseMessage RegisterUser(HttpRequestMessage request, [FromBody] UserDTO registerUserDTO)
{
AccountsApiModel accountsWebApiModel = new AccountsApiModel();
TransactionalInformation transaction = new TransactionalInformation();
AccountsBusinessService accountsBusinessService;
if (registerUserDTO.FirstName == null) registerUserDTO.FirstName = "";
if (registerUserDTO.LastName == null) registerUserDTO.LastName = "";
if (registerUserDTO.EmailAddress == null) registerUserDTO.EmailAddress = "";
if (registerUserDTO.UserName == null) registerUserDTO.UserName = "";
if (registerUserDTO.Password == null) registerUserDTO.Password = "";
if (registerUserDTO.PasswordConfirmation == null) registerUserDTO.PasswordConfirmation = "";
accountsBusinessService = new AccountsBusinessService(accountsDataService);
User user = accountsBusinessService.RegisterUser(
registerUserDTO.FirstName,
registerUserDTO.LastName,
registerUserDTO.UserName,
registerUserDTO.EmailAddress,
registerUserDTO.Password,
registerUserDTO.PasswordConfirmation,
out transaction);
if (transaction.ReturnStatus == false)
{
accountsWebApiModel.ReturnMessage = transaction.ReturnMessage;
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
accountsWebApiModel.ValidationErrors = transaction.ValidationErrors;
var badResponse = Request.CreateResponse<AccountsApiModel>(HttpStatusCode.BadRequest, accountsWebApiModel);
return badResponse;
}
ApplicationInitializationBusinessService initializationBusinessService;
initializationBusinessService = new ApplicationInitializationBusinessService(applicationDataService);
List<ApplicationMenu> menuItems = initializationBusinessService.GetMenuItems(true, out transaction);
if (transaction.ReturnStatus == false)
{
accountsWebApiModel.ReturnMessage = transaction.ReturnMessage;
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
var badResponse = Request.CreateResponse<AccountsApiModel>(HttpStatusCode.BadRequest, accountsWebApiModel);
return badResponse;
}
accountsWebApiModel.IsAuthenicated = true;
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
accountsWebApiModel.ReturnMessage.Add("Register User successful.");
accountsWebApiModel.MenuItems = menuItems;
accountsWebApiModel.User = user;
FormsAuthentication.SetAuthCookie(user.UserId.ToString(), createPersistentCookie: false);
var response = Request.CreateResponse<AccountsApiModel>(HttpStatusCode.OK, accountsWebApiModel);
return response;
}
public HttpResponseMessage Logout()
{
TransactionalInformation transaction = new TransactionalInformation();
FormsAuthentication.SignOut();
transaction.IsAuthenicated = false;
var response = Request.CreateResponse<TransactionalInformation>(HttpStatusCode.OK, transaction);
return response;
}
/// <summary>
/// Register User
/// </summary>
/// <param name="firstName"></param>
/// <param name="lastName"></param>
/// <param name="userName"></param>
/// <param name="emailAddress"></param>
/// <param name="password"></param>
/// <param name="passwordConfirmation"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public User RegisterUser(string firstName, string lastName, string userName, string emailAddress, string password, string passwordConfirmation, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
AccountsBusinessRules accountsBusinessRules = new AccountsBusinessRules();
User user = new User();
try
{
user.FirstName = Utilities.UppercaseFirstLetter(firstName.Trim());
user.LastName = Utilities.UppercaseFirstLetter(lastName.Trim());
user.EmailAddress = emailAddress.Trim();
user.Password = password.Trim();
user.UserName = userName.Trim();
accountsDataService.CreateSession();
accountsBusinessRules.ValidateUser(user, accountsDataService);
accountsBusinessRules.ValidatePassword(password, passwordConfirmation);
if (accountsBusinessRules.ValidationStatus == true)
{
accountsDataService.BeginTransaction();
accountsDataService.RegisterUser(user);
accountsDataService.CommitTransaction(true);
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("User registered successfully.");
}
else
{
transaction.ReturnStatus = accountsBusinessRules.ValidationStatus;
transaction.ReturnMessage = accountsBusinessRules.ValidationMessage;
transaction.ValidationErrors = accountsBusinessRules.ValidationErrors;
}
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
accountsDataService.CloseSession();
}
return user;
}
public override void OnActionExecuting(System.Web.Http.Controllers.HttpActionContext actionContext)
{
HttpContext ctx = default(HttpContext);
ctx = HttpContext.Current;
var request = actionContext.Request;
if (!actionContext.ModelState.IsValid)
{
TransactionalInformation transactionInformation = new TransactionalInformation();
transactionInformation.ReturnMessage = ModelStateHelper.ReturnErrorMessages(actionContext.ModelState.Values);
transactionInformation.ValidationErrors = ModelStateHelper.ReturnValidationErrors(actionContext.ModelState.Values);
transactionInformation.ReturnStatus = false;
transactionInformation.IsAuthenicated = ctx.User.Identity.IsAuthenticated;
actionContext.Response = request.CreateResponse<TransactionalInformation>(HttpStatusCode.BadRequest, transactionInformation);
}
}
public HttpResponseMessage InitializeOrder(HttpRequestMessage request, [FromBody] OrderDTO orderDTO)
{
OrdersApiModel ordersWebApiModel = new OrdersApiModel();
TransactionalInformation transaction = new TransactionalInformation();
OrdersBusinessService ordersBusinessService;
CustomersBusinessService customersBusinessService;
ordersWebApiModel.IsAuthenicated = true;
customersBusinessService = new CustomersBusinessService(customersDataService);
Customer customer = customersBusinessService.GetCustomer(orderDTO.CustomerID, out transaction);
if (transaction.ReturnStatus == false)
{
ordersWebApiModel.ReturnMessage = transaction.ReturnMessage;
ordersWebApiModel.ReturnStatus = transaction.ReturnStatus;
ordersWebApiModel.ValidationErrors = transaction.ValidationErrors;
var badResponse = Request.CreateResponse<OrdersApiModel>(HttpStatusCode.BadRequest, ordersWebApiModel);
return badResponse;
}
ordersBusinessService = new OrdersBusinessService(ordersDataService);
List<Shipper> shippers = ordersBusinessService.GetShippers(out transaction);
if (transaction.ReturnStatus == false)
{
ordersWebApiModel.ReturnMessage = transaction.ReturnMessage;
ordersWebApiModel.ReturnStatus = transaction.ReturnStatus;
ordersWebApiModel.ValidationErrors = transaction.ValidationErrors;
var badResponse = Request.CreateResponse<OrdersApiModel>(HttpStatusCode.BadRequest, ordersWebApiModel);
return badResponse;
}
ordersWebApiModel.ReturnStatus = transaction.ReturnStatus;
ordersWebApiModel.ReturnMessage = transaction.ReturnMessage;
ordersWebApiModel.Customer = customer;
ordersWebApiModel.Shippers = shippers;
var response = Request.CreateResponse<OrdersApiModel>(HttpStatusCode.OK, ordersWebApiModel);
return response;
}
public HttpResponseMessage InitializeApplication()
{
ApplicationApiModel applicationWebApiModel = new ApplicationApiModel();
TransactionalInformation transaction = new TransactionalInformation();
ApplicationInitializationBusinessService initializationBusinessService;
initializationBusinessService = new ApplicationInitializationBusinessService(applicationDataService);
initializationBusinessService.InitializeApplication(out transaction);
if (transaction.ReturnStatus == false)
{
applicationWebApiModel.ReturnMessage = transaction.ReturnMessage;
applicationWebApiModel.ReturnStatus = transaction.ReturnStatus;
var badResponse = Request.CreateResponse<ApplicationApiModel>(HttpStatusCode.BadRequest, applicationWebApiModel);
return badResponse;
}
initializationBusinessService = new ApplicationInitializationBusinessService(applicationDataService);
List<ApplicationMenu> menuItems = initializationBusinessService.GetMenuItems(User.Identity.IsAuthenticated, out transaction);
if (transaction.ReturnStatus == false)
{
applicationWebApiModel.ReturnMessage = transaction.ReturnMessage;
applicationWebApiModel.ReturnStatus = transaction.ReturnStatus;
var badResponse = Request.CreateResponse<ApplicationApiModel>(HttpStatusCode.BadRequest, applicationWebApiModel);
return badResponse;
}
applicationWebApiModel.ReturnMessage.Add("Application has been initialized.");
applicationWebApiModel.ReturnStatus = transaction.ReturnStatus;
applicationWebApiModel.MenuItems = menuItems;
applicationWebApiModel.IsAuthenicated = User.Identity.IsAuthenticated;
var response = Request.CreateResponse<ApplicationApiModel>(HttpStatusCode.OK, applicationWebApiModel);
return response;
}
public HttpResponseMessage UpdateUser(HttpRequestMessage request, [FromBody] UserDTO updateUserDTO)
{
Guid userID = new Guid(User.Identity.Name);
AccountsApiModel accountsWebApiModel = new AccountsApiModel();
TransactionalInformation transaction = new TransactionalInformation();
AccountsBusinessService accountsBusinessService;
accountsWebApiModel.IsAuthenicated = true;
if (updateUserDTO.FirstName == null) updateUserDTO.FirstName = "";
if (updateUserDTO.LastName == null) updateUserDTO.LastName = "";
if (updateUserDTO.EmailAddress == null) updateUserDTO.EmailAddress = "";
if (updateUserDTO.UserName == null) updateUserDTO.UserName = "";
if (updateUserDTO.Password == null) updateUserDTO.Password = "";
if (updateUserDTO.PasswordConfirmation == null) updateUserDTO.PasswordConfirmation = "";
accountsBusinessService = new AccountsBusinessService(accountsDataService);
User user = accountsBusinessService.UpdateUser(
userID,
updateUserDTO.FirstName,
updateUserDTO.LastName,
updateUserDTO.UserName,
updateUserDTO.EmailAddress,
updateUserDTO.Password,
updateUserDTO.PasswordConfirmation,
out transaction);
if (transaction.ReturnStatus == false)
{
accountsWebApiModel.ReturnMessage = transaction.ReturnMessage;
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
accountsWebApiModel.ValidationErrors = transaction.ValidationErrors;
var badResponse = Request.CreateResponse<AccountsApiModel>(HttpStatusCode.BadRequest, accountsWebApiModel);
return badResponse;
}
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
accountsWebApiModel.ReturnMessage.Add("User successful updated.");
var response = Request.CreateResponse<AccountsApiModel>(HttpStatusCode.OK, accountsWebApiModel);
return response;
}
/// <summary>
/// Product Inquiry
/// </summary>
/// <param name="productCode"></param>
/// <param name="description"></param>
/// <param name="paging"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public List<Product> ProductInquiry(string productCode, string description, DataGridPagingInformation paging, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
string sortExpression = paging.SortExpression;
if (paging.SortDirection != string.Empty)
sortExpression = sortExpression + " " + paging.SortDirection;
List<Product> productInquiry = new List<Product>();
int numberOfRows = 0;
var productQuery = dbConnection.Products.AsQueryable();
if (productCode != null && productCode.Trim().Length > 0)
{
productQuery = productQuery.Where(c => c.ProductCode.StartsWith(productCode));
}
if (description != null && description.Trim().Length > 0)
{
productQuery = productQuery.Where(c => c.Description.StartsWith(description));
}
var products = from p in productQuery
select new { p.ProductID, p.ProductCode, p.Description, p.UnitPrice, p.UnitOfMeasure };
numberOfRows = products.Count();
products = products.OrderBy(sortExpression);
var productList = products.Skip((paging.CurrentPageNumber - 1) * paging.PageSize).Take(paging.PageSize);
paging.TotalRows = numberOfRows;
paging.TotalPages = AngularJSUtilities.Utilities.CalculateTotalPages(numberOfRows, paging.PageSize);
foreach (var product in productList)
{
Product productData = new Product();
productData.ProductID = product.ProductID;
productData.ProductCode = product.ProductCode;
productData.Description = product.Description;
productData.UnitOfMeasure = product.UnitOfMeasure;
productData.UnitPrice = product.UnitPrice;
productInquiry.Add(productData);
}
transaction.TotalPages = paging.TotalPages;
transaction.TotalRows = paging.TotalRows;
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add(numberOfRows.ToString() + " product records found.");
return productInquiry;
}
/// <summary>
/// Import Customers
/// </summary>
/// <param name="transaction"></param>
public void ImportCustomers(out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
try
{
string importFileName = ConfigurationManager.AppSettings["CustomerImportData"];
System.IO.StreamReader csv_file = File.OpenText(importFileName);
customersDataService.CreateSession();
Boolean firstLine = true;
int customerRecordsAdded = 0;
while (csv_file.Peek() >= 0)
{
// read and add a line
string line = csv_file.ReadLine();
string[] columns = line.Split('\t');
if (firstLine == false) {
if (ImportCustomer(columns)==true)
customerRecordsAdded++;
}
firstLine = false;
}
customersDataService.CommitTransaction(true);
csv_file.Close();
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add(customerRecordsAdded.ToString() + " customer successfully imported.");
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
customersDataService.CloseSession();
}
}
/// <summary>
/// Update Customer
/// </summary>
/// <param name="customerID"></param>
/// <param name="customerCode"></param>
/// <param name="companyName"></param>
/// <param name="address"></param>
/// <param name="city"></param>
/// <param name="region"></param>
/// <param name="postalCode"></param>
/// <param name="country"></param>
/// <param name="phoneNumber"></param>
/// <param name="webSiteUrl"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public Customer UpdateCustomer(Guid customerID, string customerCode, string companyName, string address, string city, string region, string postalCode, string country, string phoneNumber, string webSiteUrl, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
CustomersBusinessRules customersBusinessRules = new CustomersBusinessRules();
Customer customer = new Customer();
try
{
customersDataService.CreateSession();
customer = customersDataService.GetCustomer(customerID);
customer.CustomerCode = customerCode;
customer.CompanyName = companyName;
customer.Address = address;
customer.City = city;
customer.Region = region;
customer.PostalCode = postalCode;
customer.Country = country;
customer.PhoneNumber = phoneNumber;
customer.WebSiteUrl = webSiteUrl;
customersBusinessRules.ValidateCustomerUpdate(customer, customersDataService);
if (customersBusinessRules.ValidationStatus == true)
{
customersDataService.BeginTransaction();
customersDataService.UpdateCustomer(customer);
customersDataService.CommitTransaction(true);
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Customer successfully updated at " + customer.DateUpdated.ToString());
}
else
{
transaction.ReturnStatus = customersBusinessRules.ValidationStatus;
transaction.ReturnMessage = customersBusinessRules.ValidationMessage;
transaction.ValidationErrors = customersBusinessRules.ValidationErrors;
}
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
customersDataService.CloseSession();
}
return customer;
}
public HttpResponseMessage ImportCustomers(HttpRequestMessage request)
{
CustomersApiModel customersWebApiModel = new CustomersApiModel();
TransactionalInformation transaction = new TransactionalInformation();
CustomersBusinessService customersBusinessService;
customersWebApiModel.IsAuthenicated = true;
customersBusinessService = new CustomersBusinessService(customersDataService);
customersBusinessService.ImportCustomers(out transaction);
if (transaction.ReturnStatus == false)
{
customersWebApiModel.ReturnMessage = transaction.ReturnMessage;
customersWebApiModel.ReturnStatus = transaction.ReturnStatus;
customersWebApiModel.ValidationErrors = transaction.ValidationErrors;
var badResponse = Request.CreateResponse<CustomersApiModel>(HttpStatusCode.BadRequest, customersWebApiModel);
return badResponse;
}
customersWebApiModel.ReturnStatus = transaction.ReturnStatus;
customersWebApiModel.ReturnMessage = transaction.ReturnMessage;
var response = Request.CreateResponse<CustomersApiModel>(HttpStatusCode.OK, customersWebApiModel);
return response;
}
/// <summary>
/// Create Order
/// </summary>
/// <param name="customerID"></param>
/// <param name="requiredDate"></param>
/// <param name="shipName"></param>
/// <param name="shipAddress"></param>
/// <param name="shipCity"></param>
/// <param name="shipRegion"></param>
/// <param name="shipPostalCode"></param>
/// <param name="shipCountry"></param>
/// <param name="shipperID"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public Order CreateOrder(Guid customerID, DateTime requiredDate, string shipName,
string shipAddress, string shipCity, string shipRegion,
string shipPostalCode, string shipCountry, int shipperID,
out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
OrdersBusinessRules ordersBusinessRules = new OrdersBusinessRules();
Order order = new Order();
order.CustomerID = customerID;
order.OrderDate = DateTime.Now;
order.RequiredDate = requiredDate;
order.ShipAddress = shipAddress;
order.ShipName = shipName;
order.ShipCity = shipCity;
order.ShipPostalCode = shipPostalCode;
order.ShipRegion = shipRegion;
order.ShipCountry = shipCountry;
order.ShipVia = shipperID;
order.OrderTotal = 0.00m;
try
{
ordersDataService.CreateSession();
ordersBusinessRules.ValidateOrder(order, ordersDataService);
if (ordersBusinessRules.ValidationStatus == true)
{
ordersDataService.BeginTransaction();
ordersDataService.CreateOrder(order);
ordersDataService.CommitTransaction(true);
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Order successfully created.");
}
else
{
transaction.ReturnStatus = ordersBusinessRules.ValidationStatus;
transaction.ReturnMessage = ordersBusinessRules.ValidationMessage;
transaction.ValidationErrors = ordersBusinessRules.ValidationErrors;
}
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
ordersDataService.CloseSession();
}
return order;
}
/// <summary>
/// Delete Order Detail Line Item
/// </summary>
/// <param name="orderDetailID"></param>
/// <param name="transaction"></param>
public void DeleteOrderDetailLineItem(Guid orderDetailID, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
OrdersBusinessRules ordersBusinessRules = new OrdersBusinessRules();
try
{
ordersDataService.CreateSession();
ordersDataService.BeginTransaction();
ordersDataService.DeleteOrderDetailLineItem(orderDetailID);
ordersDataService.CommitTransaction(true);
transaction.ReturnStatus = true;
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
ordersDataService.CloseSession();
}
}
/// <summary>
/// Update Order Detail Line Item
/// </summary>
/// <param name="orderID"></param>
/// <param name="orderDetailID"></param>
/// <param name="quantity"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public OrderDetail UpdateOrderDetailLineItem(long orderID, Guid orderDetailID, int quantity, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
OrdersBusinessRules ordersBusinessRules = new OrdersBusinessRules();
OrderDetail order = new OrderDetail();
order.Quantity = quantity;
order.OrderDetailID = orderDetailID;
order.OrderID = orderID;
try
{
ordersDataService.CreateSession();
ordersBusinessRules.ValidateOrderDetailLineItem(order, ordersDataService);
if (ordersBusinessRules.ValidationStatus == true)
{
ordersDataService.BeginTransaction();
ordersDataService.UpdateOrderDetailLineItem(order);
ordersDataService.CommitTransaction(true);
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Order line item successfully updated.");
}
else
{
transaction.ReturnStatus = ordersBusinessRules.ValidationStatus;
transaction.ReturnMessage = ordersBusinessRules.ValidationMessage;
transaction.ValidationErrors = ordersBusinessRules.ValidationErrors;
}
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
ordersDataService.CloseSession();
}
return order;
}
/// <summary>
/// Get Order Details
/// </summary>
/// <param name="orderID"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public List<OrderDetails> GetOrderDetails(long orderID, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
List<OrderDetails> orderDetail = new List<OrderDetails>();
try
{
ordersDataService.CreateSession();
orderDetail = ordersDataService.GetOrderDetails(orderID);
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
ordersDataService.CloseSession();
}
return orderDetail;
}
/// <summary>
/// Get Shippers
/// </summary>
/// <param name="transaction"></param>
/// <returns></returns>
public List<Shipper> GetShippers(out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
List<Shipper> shippers = new List<Shipper>();
try
{
ordersDataService.CreateSession();
shippers = ordersDataService.GetShippers();
transaction.ReturnStatus = true;
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
ordersDataService.CloseSession();
}
return shippers;
}
public HttpResponseMessage UpdateCustomer(HttpRequestMessage request, [FromBody] CustomerDTO customerDTO)
{
CustomersApiModel customersWebApiModel = new CustomersApiModel();
TransactionalInformation transaction = new TransactionalInformation();
CustomersBusinessService customersBusinessService;
customersWebApiModel.IsAuthenicated = true;
if (customerDTO.CustomerCode == null) customerDTO.CustomerCode = string.Empty;
if (customerDTO.CompanyName == null) customerDTO.CompanyName = string.Empty;
if (customerDTO.Address == null) customerDTO.Address = string.Empty;
if (customerDTO.City == null) customerDTO.City = string.Empty;
if (customerDTO.Region == null) customerDTO.Region = string.Empty;
if (customerDTO.PostalCode == null) customerDTO.PostalCode = string.Empty;
if (customerDTO.Country == null) customerDTO.Country = string.Empty;
if (customerDTO.PhoneNumber == null) customerDTO.PhoneNumber = string.Empty;
if (customerDTO.WebSiteUrl == null) customerDTO.WebSiteUrl = string.Empty;
customersBusinessService = new CustomersBusinessService(customersDataService);
Customer customer = customersBusinessService.UpdateCustomer(
customerDTO.CustomerID,
customerDTO.CustomerCode,
customerDTO.CompanyName,
customerDTO.Address,
customerDTO.City,
customerDTO.Region,
customerDTO.PostalCode,
customerDTO.Country,
customerDTO.PhoneNumber,
customerDTO.WebSiteUrl,
out transaction);
if (transaction.ReturnStatus == false)
{
customersWebApiModel.ReturnMessage = transaction.ReturnMessage;
customersWebApiModel.ReturnStatus = transaction.ReturnStatus;
customersWebApiModel.ValidationErrors = transaction.ValidationErrors;
var badResponse = Request.CreateResponse<CustomersApiModel>(HttpStatusCode.BadRequest, customersWebApiModel);
return badResponse;
}
customersWebApiModel.ReturnStatus = transaction.ReturnStatus;
customersWebApiModel.ReturnMessage = transaction.ReturnMessage;
customersWebApiModel.Customer = customer;
var response = Request.CreateResponse<CustomersApiModel>(HttpStatusCode.OK, customersWebApiModel);
return response;
}
public HttpResponseMessage GetUser()
{
Guid userID = new Guid(User.Identity.Name);
AccountsApiModel accountsWebApiModel = new AccountsApiModel();
TransactionalInformation transaction = new TransactionalInformation();
AccountsBusinessService accountsBusinessService;
accountsWebApiModel.IsAuthenicated = true;
accountsBusinessService = new AccountsBusinessService(accountsDataService);
User user = accountsBusinessService.GetUser(userID, out transaction);
transaction.ReturnStatus = true;
if (transaction.ReturnStatus == false)
{
accountsWebApiModel.ReturnMessage = transaction.ReturnMessage;
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
accountsWebApiModel.ValidationErrors = transaction.ValidationErrors;
var badResponse = Request.CreateResponse<AccountsApiModel>(HttpStatusCode.BadRequest, accountsWebApiModel);
return badResponse;
}
accountsWebApiModel.ReturnStatus = transaction.ReturnStatus;
accountsWebApiModel.User = user;
var response = Request.CreateResponse<AccountsApiModel>(HttpStatusCode.OK, accountsWebApiModel);
return response;
}
/// <summary>
/// Get Order
/// </summary>
/// <param name="orderID"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public Order GetOrder(int orderID, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
Order order = new Order();
try
{
ordersDataService.CreateSession();
order = ordersDataService.GetOrder(orderID);
transaction.ReturnStatus = true;
}
catch (Exception ex)
{
transaction.ReturnMessage = new List<string>();
string errorMessage = ex.Message;
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(errorMessage);
}
finally
{
ordersDataService.CloseSession();
}
return order;
}
public HttpResponseMessage CustomerInquiry([FromUri] CustomerInquiryDTO customerInquiryDTO)
{
if (customerInquiryDTO.CustomerCode == null) customerInquiryDTO.CustomerCode = string.Empty;
if (customerInquiryDTO.CompanyName == null) customerInquiryDTO.CompanyName = string.Empty;
if (customerInquiryDTO.SortDirection == null) customerInquiryDTO.SortDirection = string.Empty;
if (customerInquiryDTO.SortExpression == null) customerInquiryDTO.SortExpression = string.Empty;
CustomersApiModel customersWebApiModel = new CustomersApiModel();
TransactionalInformation transaction = new TransactionalInformation();
CustomersBusinessService customersBusinessService;
customersWebApiModel = new CustomersApiModel();
DataGridPagingInformation paging = new DataGridPagingInformation();
paging.CurrentPageNumber = customerInquiryDTO.CurrentPageNumber;
paging.PageSize = customerInquiryDTO.PageSize;
paging.SortExpression = customerInquiryDTO.SortExpression;
paging.SortDirection = customerInquiryDTO.SortDirection;
if (paging.SortDirection == "") paging.SortDirection = "ASC";
if (paging.SortExpression == "") paging.SortExpression = "CompanyName";
customersBusinessService = new CustomersBusinessService(customersDataService);
List<Customer> customers = customersBusinessService.CustomerInquiry(customerInquiryDTO.CustomerCode, customerInquiryDTO.CompanyName, paging, out transaction);
customersWebApiModel.Customers = customers;
customersWebApiModel.IsAuthenicated = true;
customersWebApiModel.ReturnStatus = transaction.ReturnStatus;
customersWebApiModel.ReturnMessage = transaction.ReturnMessage;
customersWebApiModel.TotalPages = transaction.TotalPages;
customersWebApiModel.TotalRows = transaction.TotalRows;
customersWebApiModel.PageSize = paging.PageSize;
customersWebApiModel.IsAuthenicated = true;
if (transaction.ReturnStatus == true)
{
var response = Request.CreateResponse<CustomersApiModel>(HttpStatusCode.OK, customersWebApiModel);
return response;
}
var badResponse = Request.CreateResponse<CustomersApiModel>(HttpStatusCode.BadRequest, customersWebApiModel);
return badResponse;
}
