public ServiceResponse <Data.Model.Customer> CreateCustomer(Data.Model.Customer customer)
{
try
{
solarDb.Customers.Add(customer);
solarDb.SaveChanges();
return(new ServiceResponse <Data.Model.Customer>
{
isSuccess = true,
Message = "New customer added",
Time = DateTime.UtcNow,
Data = customer,
});
}
catch (System.Exception e)
{
return(new ServiceResponse <Data.Model.Customer>
{
isSuccess = false,
Message = e.StackTrace,
Time = DateTime.UtcNow,
Data = customer,
});
}
}
/// <summary>
/// Adds a new Customer record
/// </summary>
/// <param name="customer">Customer instance</param>
/// <returns>ServiceResponse<Customer></returns>
ServiceResponse <Data.Models.Customer> ICustomerService.CreateCustomer(Data.Models.Customer customer)
{
try
{
_db.Customers.Add(customer);
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Customer> {
IsSuccess = true,
Data = customer,
Message = "Customer was added",
Time = DateTime.UtcNow
});
}
catch (Exception ex)
{
return(new ServiceResponse <Data.Models.Customer>
{
IsSuccess = false,
Data = customer,
Message = ex.StackTrace,
Time = DateTime.UtcNow
});
}
}
/// <summary>
/// Create an open SalesOrder
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
public ServiceResponse <bool> GenerateOpenOrder(SalesOrder order)
{
_logger.LogInformation("Generatating new order");
foreach (var item in order.SalesOrderItem)
{
item.Product = _productService
.GetProductById(item.Product.Id);
var inventoryId = _inventoryService
.GetByProductId(item.Product.Id).Id;
_inventoryService
.UpdateUnitsAvailable(inventoryId, -item.Quantity);
}
try {
_db.SalesOrders.Add(order);
_db.SaveChanges();
return(new ServiceResponse <bool> {
IsSucces = true,
Data = true,
Message = "Open order created",
Time = DateTime.UtcNow
});
}
catch (Exception e) {
return(new ServiceResponse <bool> {
IsSucces = false,
Data = false,
Message = e.StackTrace,
Time = DateTime.UtcNow
});
}
}
/// <summary>
/// Add a new Customer
/// </summary>
/// <param name="customer"></param>
public ServiceResponse <Customer> CreateCustomer(Customer customer)
{
try
{
_solarDbContext.Customers.Add(customer);
_solarDbContext.SaveChanges();
return(new ServiceResponse <Customer>
{
IsSuccess = true,
Message = "New Customer added",
Time = DateTime.UtcNow,
Data = customer
});
}
catch (Exception e)
{
return(new ServiceResponse <Customer>
{
IsSuccess = false,
Message = "Error while adding Customer",
Time = DateTime.UtcNow,
Data = null
});
}
}
/// <summary>
/// Add a new record
/// </summary>
/// <returns>Service response <Customer></Customer></returns>
public ServiceResponse <Data.Models.Customer> CreateCustomer(Data.Models.Customer customer)
{
try
{
_db.Customers.Add(customer);
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Customer>
{
IsSuccess = true,
Message = "New customer added",
Time = DateTime.UtcNow,
Data = customer
});
}catch (Exception)
{
return(new ServiceResponse <Data.Models.Customer>
{
IsSuccess = false,
Message = "Failed to add customer",
Time = DateTime.UtcNow,
Data = customer
});
}
}
/// <summary>
/// Adds a new customer record
/// </summary>
/// <param name="customer"></param>
/// <returns>ServiceResponse<Customer></returns>
public ServiceResponse <Customer> CreateCustomer(Customer customer)
{
try
{
_db.Customers.Add(customer);
_db.SaveChanges();
return(new ServiceResponse <Customer>
{
IsSuccess = true,
Message = "New customer added",
Time = DateTime.UtcNow,
Data = customer
});
}
catch (Exception e)
{
return(new ServiceResponse <Customer>
{
IsSuccess = false,
Message = e.StackTrace,
Time = DateTime.UtcNow,
Data = customer
});
}
}
public ServiceResponse <Data.Models.Customer> CreateCustomer(Data.Models.Customer customer)
{
try
{
customer.CreatedDate = DateTime.Now;
customer.UpdatedDate = DateTime.Now;
customer.PrimaryAddress.CreatedDate = DateTime.Now;
customer.PrimaryAddress.UpdatedDate = DateTime.Now;
_db.Customers.Add(customer);
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Customer>
{
Data = customer,
IsSuccess = true,
Message = "created Successfully",
Time = DateTime.UtcNow
});
}
catch (Exception ex)
{
return(new ServiceResponse <Data.Models.Customer>
{
Data = null,
IsSuccess = false,
Message = ex.StackTrace,
Time = DateTime.UtcNow
});
}
}
/// <summary>
/// Archives a product by setting boolean IsArchived to true
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ServiceResponse <Product> ArchiveProduct(int id)
{
try
{
var product = GetProduct(id);
product.IsArchived = true;
_solarDb.SaveChanges();
return(new ServiceResponse <Product>
{
Data = product,
Time = DateTime.UtcNow,
IsSuccess = true,
Message = "Archived product"
});
}
catch (Exception ex)
{
return(new ServiceResponse <Product>
{
Data = null,
Time = DateTime.UtcNow,
IsSuccess = false,
Message = ex.StackTrace
});
}
}
/// <summary>
/// Generates a new Invoice for an order
/// </summary>
/// <param name="salesOrder"></param>
public ServiceResponse <bool> GenerateInvoiceForOrder(SalesOrder salesOrder)
{
foreach (var item in salesOrder.SalesOrderItems)
{
item.Product = _productService.GetProductById(item.Product.Id);
item.Quantity = item.Quantity;
var inventoryId = _inventoryService.GetProductInventoryById(item.Product.Id).Id;
_inventoryService.UpdateUnitsAvailable(inventoryId, -item.Quantity);
}
try
{
_solarDbContext.SalesOrders.Add(salesOrder);
_solarDbContext.SaveChanges();
return(new ServiceResponse <bool>
{
Time = DateTime.UtcNow,
IsSuccess = true,
Data = true,
Message = "Created Invoice"
});
}
catch (Exception e)
{
return(new ServiceResponse <bool>
{
Time = DateTime.UtcNow,
IsSuccess = false,
Data = false,
Message = "Error while creating Invoice"
});
}
}
public ServiceResponse <Data.Models.Product> CreateProduct(Data.Models.Product product)
{
try
{
_db.Products.Add(product);
_db.SaveChanges();
var newInventory = new ProductInventory
{
Product = product,
QuantityOnHand = 0,
IdealQuantity = 10
};
_db.ProductInventories.Add(newInventory);
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Product>
{
Data = product,
Time = DateTime.UtcNow,
Message = "Add Product Success",
IsSuccess = true,
});
}
catch (Exception e)
{
return(new ServiceResponse <Data.Models.Product>
{
Data = product,
Time = DateTime.UtcNow,
Message = $"Getting Error: {e.Message}",
IsSuccess = false,
});
}
}
public ServiceResponse <bool> GenerateOpenOrderAndReturnResponse(data.models.SalesOrder orders)
{
foreach (data.models.SalesOrderItem order in orders.SalesOrderItems)
{
data.models.Product product = _productService.GetproductById(order.productId);
if (product == null)
{
return(ServiceResponse <bool> .Failed(false, $"Product represented as index {order.productId} was not found"));
}
data.models.ProductInventory inventory = _inventoryService.GetByProductId(product.id);
int inventoryId = inventory.id;
if (_inventoryService.UpdateUnitsAvailableAndReturnResponse(inventoryId, -(order.quantity)).IsSuccess == false)
{
return(ServiceResponse <bool> .Failed(false, "Updating inventory was fail"));
}
}
try {
_db.SalesOrders.Add(orders);
_db.SaveChanges();
return(ServiceResponse <bool> .Successed(true, "Open order created"));
} catch (Exception e) {
return(ServiceResponse <bool> .Failed(false, e.StackTrace));
}
}
/// <summary>
/// Add new products to database
/// </summary>
/// <param name="product"></param>
/// <returns></returns>
public ServiceResponse <Data.Models.Product> CreateProduct(Data.Models.Product product)
{
try
{
_db.Products.Add(product);
var newInventory = new ProductInventory
{
Product = product,
QuantityOnHand = 0,
IdealQuantity = 10
};
_db.ProductInventories.Add(newInventory);
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Product>
{
Data = product,
IsSuccess = true,
Message = "Saved new product",
Time = DateTime.Now
});
}
catch (Exception e)
{
return(new ServiceResponse <Data.Models.Product>
{
Data = product,
IsSuccess = false,
Message = "Error saving new product",
Time = DateTime.Now
});
}
}
/// <summary>
/// Add Customer record
/// </summary>
/// <param name="customer"></param>
/// <returns>ServiceResponse<Customer></returns>
public ServiceResponse <Customer> CreateCustomer(Customer customer)
{
try
{
db.Add(customer);
var response = db.SaveChanges();
if (response >= 1)
{
return(new ServiceResponse <Customer>
{
IsSuccess = true,
Message = "New Customer Added",
Time = DateTime.UtcNow,
Data = customer
});
}
return(new ServiceResponse <Customer>
{
IsSuccess = false,
Message = "Customer not Added",
Time = DateTime.UtcNow,
Data = customer
});
}
catch (Exception ex)
{
return(new ServiceResponse <Customer>
{
IsSuccess = false,
Message = ex.StackTrace,
Time = DateTime.UtcNow,
Data = null
});
}
}
/// <summary>
/// Archives a Product by setting boolean IsArchived to true
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ServiceResponse <Data.Models.Product> ArciveProduct(int id)
{
try
{
var product = _db.Products.Find(id);
product.IsArchived = true;
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Product>
{
Data = product,
Time = DateTime.UtcNow,
Message = "Poduct archived",
IsSuccess = true
});
}
catch (Exception e)
{
return(new ServiceResponse <Data.Models.Product>
{
Data = null,
Time = DateTime.UtcNow,
Message = e.StackTrace,
IsSuccess = false
});
}
}
//Adds a new product to the database
public ServiceResponse <Data.Models.Product> CreateProduct(Data.Models.Product product)
{
try{
_db.Products.Add(product);
ProductInventory newInventory = new ProductInventory()
{
Product = product,
QuantityOnHand = 0,
IdealQuantity = 10
};
_db.ProductInventorys.Add(newInventory);
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Product> {
Data = product,
IsSuccess = true,
Time = DateTime.UtcNow,
Message = "Saved new products"
});
}catch (Exception e)
{
return(new ServiceResponse <Data.Models.Product> {
Data = product,
IsSuccess = false,
Time = DateTime.UtcNow,
Message = e.StackTrace
});
}
}
/// <summary>
/// Create a new customer
/// </summary>
/// <param name="customer"></param>
/// <returns></returns>
public ServiceResponse <Data.Models.Customer> CreateCustomer(Data.Models.Customer customer)
{
try
{
_db.Customers.Add(customer);
_db.SaveChanges();
return(new ServiceResponse <Data.Models.Customer>
{
IsSuccess = true,
Message = "Add New Customer",
Data = customer,
Time = DateTime.UtcNow,
});
}
catch (Exception e)
{
return(new ServiceResponse <Data.Models.Customer>
{
IsSuccess = false,
Message = e.Message,
Data = null,
Time = DateTime.UtcNow,
});
}
}
/// <summary>
/// Adds new product to database
/// </summary>
/// <param name="product"></param>
/// <returns></returns>
public ServiceResponse <Product> CreateProduct(Product product)
{
try
{
_db.Products.Add(product);
//Inventory
var newInventory = new ProductInventory
{
Product = product,
QuantityOnHand = 0,
IdealQuantity = 10,
};
_db.ProductInventories.Add(newInventory);
_db.SaveChanges();
return(new ServiceResponse <Product>
{
Data = product,
Time = DateTime.UtcNow,
Message = "Saved new product",
IsSuccess = true
});
}
catch (Exception e)
{
return(new ServiceResponse <Product>
{
Data = product,
Time = DateTime.UtcNow,
Message = e.StackTrace,
IsSuccess = false
});
}
}
public ServiceResponse <data.models.Customer> CreateCustomerAndReturnResponse(data.models.Customer customer)
{
try {
_db.Customers.Add(customer);
_db.SaveChanges();
return(ServiceResponse <data.models.Customer> .Successed(customer, "Customer created"));
} catch (Exception e) {
return(ServiceResponse <data.models.Customer> .Failed(customer, e.Message));
}
}
public void CreateSnapshot(ProductInventory inventory)
{
var snapshot = new ProductInventorySnapshot {
SnapshotTime = DateTime.UtcNow,
Product = inventory.Product,
QuantityOnHand = inventory.QuantityOnHand
};
// z automatu doda do dobrej tabeli poniewaz zna typ
_db.Add(snapshot);
_db.SaveChanges(); // komentarz
}
private void CreateSnapshot(ProductInventory inventory)
{
var now = DateTime.UtcNow;
var snapshot = new ProductInventorySnapshot
{
SnapshotTime = now,
Product = inventory.Product,
QuantityOnHand = inventory.QuantityOnHand,
};
context.Add(snapshot);
context.SaveChanges();
}
public ServiceResponse <Data.Model.Product> ArchiveProduct(int id)
{
try
{
var product = dbContext.Products.Find(id);
product.IsArchived = true;
dbContext.SaveChanges();
return(new ServiceResponse <Data.Model.Product>
{
Data = product,
Time = DateTime.UtcNow,
Message = "Archiver Product",
isSuccess = true,
});
}
catch (System.Exception e)
{
return(new ServiceResponse <Data.Model.Product>
{
Data = null,
Time = DateTime.UtcNow,
Message = e.StackTrace,
isSuccess = false,
});
}
}
public ServiceResponse <ProductInventory> UpdateUnitsAvailable(int id, int adjustment)
{
try
{
var inventory = _db.ProductInventories
.Include(inv => inv.Product)
.First(inv => inv.Product.Id == id);
inventory.QuantityOnHand += adjustment;
try
{
CreateSnapshot(inventory);
}
catch (Exception e)
{
_logger.LogError("Error create Snapshot");
_logger.LogError(e.StackTrace);
}
_db.SaveChanges();
return(new ServiceResponse <ProductInventory> {
IsSuccess = true,
Message = $"Poduct {id} inventory adjusted",
Time = DateTime.UtcNow,
Data = inventory
});
}catch (Exception e)
{
return(new ServiceResponse <ProductInventory>
{
IsSuccess = false,
Message = $"error updating Product Inventory Quantity On Hand ",
Time = DateTime.UtcNow,
Data = null
});
}
}
public ServiceResponse <bool> CreateProductAndReturnResponseAsBool(data.models.Product product)
{
try {
_db.Products.Add(product);
data.models.ProductInventory NewInventory = new data.models.ProductInventory {
Product = product,
quantityOnHand = 0,
idealQuantity = 10
};
_db.ProductInventories.Add(NewInventory);
_db.SaveChanges();
return(ServiceResponse <bool> .Successed(true, "Product created"));
} catch (Exception e) {
return(ServiceResponse <bool> .Failed(false, e.StackTrace));
}
}
/// <summary>
/// Adjust product inventory by product id
/// </summary>
/// <param name="id"></param>
/// <param name="adjustment"></param>
/// <returns></returns>
public ServiceResponse <ProductInventory> UpdateUnitsAvailable(int id, int adjustment)
{
var now = DateTime.UtcNow;
try
{
var inventory = _db.ProductInventories
.Include(inv => inv.Product)
.First(inv => inv.Product.Id == id);
inventory.QuantityOnHand += adjustment;
try
{
CreateSnapshot(inventory);
}
catch (Exception e)
{
_logger.LogError($"Error {e.Message}");
}
_db.SaveChanges();
return(new ServiceResponse <ProductInventory>
{
IsSuccess = true,
Data = inventory,
Message = $"Product {id} inventory adjusted",
Time = now,
});
}
catch (Exception e)
{
return(new ServiceResponse <ProductInventory>
{
IsSuccess = true,
Data = null,
Message = e.Message,
Time = now,
});
}
}
public ServiceResponse <bool> GenerateOpenOrder(SalesOrder order)
{
logger.LogInformation("Generating new order");
Parallel.ForEach(order.SalesOrderItems.ToArray(), item =>
{
item.Product = productService.GetProductById(item.Product.Id);
var inventoryId = inventoryService.GetByProductId(item.Product.Id).Id;
inventoryService.UpdateUnitsAvailable(inventoryId, -item.Quantity);
});
try
{
db.SalesOrders.Add(order);
var response = db.SaveChanges();
if (response >= 1)
{
return(new ServiceResponse <bool>
{
IsSuccess = true,
Message = "Open order created.",
Time = now,
Data = true
});
}
return(new ServiceResponse <bool>
{
IsSuccess = false,
Message = "Error in saving open order record created.",
Time = now,
Data = false
});
}
catch (Exception ex)
{
return(new ServiceResponse <bool>
{
IsSuccess = false,
Message = ex.StackTrace,
Time = now,
Data = false
});
}
}
/// <summary>
/// Creates an open SalesOrder
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
public ServiceResponse <bool> GenerateOpenOrder(SalesOrder order)
{
var now = DateTime.UtcNow;
_logger.LogInformation("Generating new order");
foreach (var item in order.SalesOrderItems)
{
item.Product = _productService.GetProductById(item.Product.Id);
var inventoryId = _inventoryService.GetByProductId(item.Product.Id).Id;
_inventoryService.UpdateUnitsAvailable(inventoryId, -item.Quantity);
}
// why assign values to Product/InvID properties of order if order is passed?
//it its uncomplete vm, it would make sense.
try
{
_db.SalesOrders.Add(order);
_db.SaveChanges();
return(new ServiceResponse <bool>
{
IsSuccess = true,
Data = true,
Message = "Open order created",
Time = now
});
}
catch (Exception e)
{
return(new ServiceResponse <bool>
{
IsSuccess = false,
Data = false,
Message = e.StackTrace,
Time = now
});
}
}
/// <summary>
/// Archives a product by setting a flag on product IsArchived to true.
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ServiceResponse <Product> ArchiveProduct(int id)
{
var productToArchive = _db.Products.Find(id);
try
{
if (productToArchive == null)
{
return(new ServiceResponse <Product>
{
Data = null,
IsSuccess = false,
Message = "Product not found on database",
Time = DateTime.UtcNow
});
}
productToArchive.IsArchived = true;
_db.SaveChanges();
return(new ServiceResponse <Product>
{
Data = productToArchive,
IsSuccess = true,
Message = "Product Archived successfully",
Time = DateTime.UtcNow
});
}
catch (Exception ex)
{
return(new ServiceResponse <Product>
{
Data = productToArchive,
IsSuccess = true,
Message = ex.StackTrace.ToString(),
Time = DateTime.UtcNow
});
}
}
public ServiceResponse <bool> GenerateInvoiceForOrder(SalesOrder order)
{
logger.LogInformation($"generating new order");
foreach (var item in order.SalesOrderItem)
{
item.Product = productService.GetProductById(item.Product.Id);
item.Quantity = item.Quantity;
var inventoryId = inventoryService.GetByProductId(item.Product.Id);
inventoryService.UpdateUnitsAvalible(inventoryId.Id, -item.Quantity);
}
try
{
context.SalesOrders.Add(order);
context.SaveChanges();
return(new ServiceResponse <bool>
{
isSuccess = true,
Data = true,
Message = "Open order created",
Time = DateTime.UtcNow,
});
}
catch (System.Exception e)
{
return(new ServiceResponse <bool>
{
isSuccess = false,
Data = false,
Message = e.StackTrace,
Time = DateTime.UtcNow,
});
}
}
/// <summary>
/// Updates number of units available of the provided product id
/// </summary>
/// <param name="id"></param>
/// <param name="adjustment"></param>
/// <returns></returns>
public ServiceResponse <ProductInventory> UpdateUnitsAvailable(int id, int adjustment)
{
try
{
var inventory = db.ProductInventories
.Include(p => p.Product)
.First(inv => inv.Product.Id == id);
inventory.QuantityOnHand += adjustment;
try
{
CreateSnapshot(inventory);
}
catch (Exception ex)
{
logger.LogError("Error creating inventory snapshots");
logger.LogError(ex.StackTrace);
}
var response = db.SaveChanges();
if (response >= 1)
{
return(new ServiceResponse <ProductInventory>
{
IsSuccess = true,
Message = $"Product {id} Updated",
Time = now,
Data = inventory
});
}
return(new ServiceResponse <ProductInventory>
{
IsSuccess = false,
Message = $"There is an issue in updating product with id = {id}",
Time = now,
Data = null
});
}
catch (Exception ex)
{
return(new ServiceResponse <ProductInventory>
{
IsSuccess = false,
Message = ex.StackTrace,
Time = now,
Data = null
});
}
}
public ServiceResponse <bool> GenerateOpenOrder(SalesOrder order)
{
var now = DateTime.UtcNow;
try
{
foreach (var item in order.SalesOrderItems)
{
item.Product = _productService.GetProductById(item.Product.Id);
var inventoryId = _inventoryService.GetProductById(item.Product.Id).Id;
_inventoryService.UpdateUnitsAvailable(inventoryId, -item.Quantity);
}
_db.SalesOrders.Add(order);
_db.SaveChanges();
return(new ServiceResponse <bool>
{
IsSuccess = true,
Data = true,
Message = "Generated Invoice",
Time = now
});
}
catch (Exception ex)
{
return(new ServiceResponse <bool>
{
IsSuccess = true,
Data = true,
Message = $"Invoice generation failed {ex.InnerException.Message}",
Time = now
});
}
}
