public ServiceResult <Category> AddCategory(Category category)
{
var errors = new List <string>();
if (string.IsNullOrEmpty(category.CategoryName))
{
errors.Add("Name is Null");
}
if (_context.Categories.Any(a => a.CategoryName == category.CategoryName))
{
errors.Add("Mobile is dupplicate");
}
if (errors.Any())
{
return(ServiceResult <Category> .Failed(errors));
}
category.CategoryCreateDate = DateTime.Now;
category.IsDelete = false;
_context.Categories.Add(category);
var result = _context.SaveChanges();
if (result > 0)
{
return(ServiceResult <Category> .Succeed(category));
}
return(ServiceResult <Category> .Failed(new List <string> {
"Data not inserted!!!"
}));
}
public ServiceResult <StoreInvoicingDetails> AddstoreInvoicingDetails(StoreInvoicingDetails storeInvoicingDetails)
{
var errors = new List <string>();
//if (string.IsNullOrEmpty(StoreInvoicingDetails.InvoicingId))
// errors.Add("Name is Null");
//if (_context.Customers.Any(a => a.Mobile == storeInvoicingDetails.Mobile))
// errors.Add("Mobile is dupplicate");
if (errors.Any())
{
return(ServiceResult <StoreInvoicingDetails> .Failed(errors));
}
storeInvoicingDetails.InvoicingDetailCreateDate = DateTime.Now;
storeInvoicingDetails.IsDelete = false;
_context.StoreInvoicingDetails.Add(storeInvoicingDetails);
var result = _context.SaveChanges();
if (result > 0)
{
return(ServiceResult <StoreInvoicingDetails> .Succeed(storeInvoicingDetails));
}
return(ServiceResult <StoreInvoicingDetails> .Failed(new List <string> {
"Data not inserted!!!"
}));
}
public IActionResult Create(CreateOrderInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
var order = mapper.Map <Order>(model);
order.DateTime = DateTime.Now;
OrderType orderType = Enum.Parse <OrderType>(model.OrderType);
order.Type = orderType;
context.Orders.Add(order);
context.SaveChanges();
order.OrderItems.Add(new OrderItem()
{
ItemId = model.ItemId,
OrderId = order.Id,
Quantity = model.Quantity
});
context.SaveChanges();
return(this.RedirectToAction("All", "Orders"));
}
public ServiceResult <Products> AddProduct(Products product)
{
var errors = new List <string>();
if (string.IsNullOrEmpty(product.ProductName))
{
errors.Add("Name is Null");
}
if (_context.Products.Any(a => a.ProductName == product.ProductName))
{
errors.Add("Name Food is dupplicate");
}
if (errors.Any())
{
return(ServiceResult <Products> .Failed(errors));
}
_context.Products.Add(product);
var result = _context.SaveChanges();
if (result > 0)
{
return(ServiceResult <Products> .Succeed(product));
}
return(ServiceResult <Products> .Failed(new List <string> {
"Data not inserted!!!"
}));
}
public ServiceResult <Customers> AddCustomer(Customers customers)
{
var errors = new List <string>();
if (string.IsNullOrEmpty(customers.FName))
{
errors.Add("Name is Null");
}
if (_context.Customers.Any(a => a.Mobile == customers.Mobile))
{
errors.Add("Mobile is dupplicate");
}
if (errors.Any())
{
return(ServiceResult <Customers> .Failed(errors));
}
customers.CustomerCreateDate = DateTime.Now;
customers.IsDelete = false;
_context.Customers.Add(customers);
var result = _context.SaveChanges();
if (result > 0)
{
return(ServiceResult <Customers> .Succeed(customers));
}
return(ServiceResult <Customers> .Failed(new List <string> {
"Data not inserted!!!"
}));
}
public OutletOut CreateOutlet(OutletIn outletIn)
{
var outlet = MapHelper.Map <OutletIn, Outlet>(outletIn);
var user = ffContext.Users.FirstOrDefault(usr => usr.Id == outletIn.UserId);
if (user == null || !user.Enabled)
{
throw new ArgumentException("userId");
}
outlet.User = user;
ffContext.Outlets.Add(outlet);
if (outlet.Image != null)
{
FileHelper.SaveFormFile(outletIn.Image, environment.WebRootPath + "\\Images", outlet.Id + ".png");
outlet.Image = outlet.Id + ".png";
}
var workingHours = MapHelper
.Map <List <WorkingHours>, WorkingHoursIn, WorkingHours>(outletIn.WorkingHours);
workingHours.ForEach(wh => { wh.Outlet = outlet; });
ffContext.AddRange(workingHours);
ffContext.SaveChanges();
return(GetOutlet(outlet.Id));
}
public ProductTypeOut Create(ProductTypeIn pTypeIn)
{
var pType = MapHelper.Map <ProductTypeIn, ProductType>(pTypeIn);
ffContext.ProductTypes.Add(pType);
ffContext.SaveChanges();
return(MapHelper.Map <ProductType, ProductTypeOut>(pType));
}
public ActionResult Create(Cliente cliente)
{
if (ModelState.IsValid)
{
db.Clientes.Add(cliente);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(cliente));
}
public void RemoveAllRoles()
{
var allEntities = ffContext.Roles;
ffContext.Roles.RemoveRange(allEntities);
ffContext.SaveChanges();
}
public ActionResult Create([Bind(Include = "IdPedido,Cliente, Refeicao, FormaPag, StatusPedido")] Pedido pedido)
{
if (ModelState.IsValid)
{
pedido.Cliente = db.Clientes.First(r => r.Cpf == pedido.Cliente.Cpf);
pedido.Cliente = db.Clientes.First(r => r.Nome == pedido.Cliente.Nome);
pedido.Refeicao = db.Refeicaos.FirstOrDefault(r => r.IdRefeicao == pedido.Refeicao.IdRefeicao);
pedido.StatusPedido = db.StatusPedidos.FirstOrDefault(r => r.IdStatus == pedido.StatusPedido.IdStatus);
db.Pedidos.Add(pedido);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(pedido));
}
public IActionResult Create(CreateOrderInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
var order = mapper.Map <Order>(model);
order.DateTime = DateTime.Now;
Enum.TryParse(model.OrderType, out OrderType orderType);
order.Type = orderType;
var item = context.Items.FirstOrDefault(i => i.Name == model.ItemName);
var employee = context.Employees.FirstOrDefault(e => e.Name == model.EmployeeName);
order.Employee = employee;
order.OrderItems.Add(new OrderItem {
Order = order,
ItemId = item.Id,
Quantity = model.Quantity
});
context.Orders.Add(order);
context.SaveChanges();
return(this.RedirectToAction("All", "Orders"));
}
public IActionResult Create(CreateOrderInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
var order = mapper.Map <Order>(model);
var employee = this.context.Employees.FirstOrDefault(x => x.Name == model.Employee);
order.EmployeeId = employee.Id;
var item = this.context.Items.FirstOrDefault(x => x.Name == model.Item);
order.Type = Enum.Parse <OrderType>(model.Type);
order.OrderItems.Add(new OrderItem
{
ItemId = item.Id,
Order = order,
Quantity = model.Quantity
});
context.Orders.Add(order);
context.SaveChanges();
return(this.RedirectToAction("All", "Orders"));
}
public IActionResult Create(CreateOrderInputModel model)
{
//customer, empId, ItemId, Qty
Item item = context.Items.FirstOrDefault(x => x.Name == model.ItemName);
var test = model.EmployeeName;
var empId = model.EmployeeName.Split('-', StringSplitOptions.RemoveEmptyEntries).TakeLast(1)
.Select(int.Parse).FirstOrDefault();
var order = new Order()
{
Customer = model.Customer,
DateTime = DateTime.Now,
Type = Enum.Parse <OrderType>(model.OrderType),
TotalPrice = model.Quantity * item.Price,
EmployeeId = empId
};
var orderItem = new OrderItem()
{
ItemId = item.Id,
Item = item,
Order = order
};
context.OrderItems.Add(orderItem);
context.Orders.Add(order);
context.SaveChanges();
return(this.RedirectToAction("All", "Orders"));
}
public IActionResult Create(CreateCategoryInputModel model)
{
var cat = mapper.Map <Category>(model);
context.Categories.Add(cat);
context.SaveChanges();
return(RedirectToAction("All", "Categories"));
}
public IActionResult Create(CreateOrderInputModel model)
{
var order = mapper.Map <Order>(model);
context.Orders.Add(order);
context.SaveChanges();
var orderItem = mapper.Map <OrderItem>(model);
orderItem.OrderId = order.Id;
context.OrderItems.Add(orderItem);
context.SaveChanges();
return(this.RedirectToAction("All", "Orders"));
}
public ActionResult Create(Refeicao refeicao)
{
if (ModelState.IsValid)
{
db.Refeicaos.Add(refeicao);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(refeicao));
}
public IActionResult Create(CreateItemInputModel model)
{
var item = mapper.Map <Item>(model);
context.Items.Add(item);
context.SaveChanges();
return(RedirectToAction("All", "Items"));
}
public ActionResult Create(StatusPedido statuspedido)
{
if (ModelState.IsValid)
{
db.StatusPedidos.Add(statuspedido);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(statuspedido));
}
public IActionResult Register(RegisterEmployeeInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
context.Employees.Add(mapper.Map <Employee>(model));
context.SaveChanges();
return(RedirectToAction("All", "Employees"));
}
public UserOut Register(UserRegisterIn dtoUser)
{
var existedUser = ffContext.Users.FirstOrDefault(usr => usr.Email == dtoUser.Email);
if (existedUser != null)
{
throw new ArgumentException("email");
}
UserRole role;
if (string.IsNullOrWhiteSpace(dtoUser.RoleId))
{
role = ffContext.Roles.FirstOrDefault(r => r.Name == "Клиент");
}
else
{
role = ffContext.Roles.FirstOrDefault(r => r.Id == dtoUser.RoleId);
}
if (role == null)
{
throw new ArgumentException("roleId");
}
var config = new MapperConfiguration(cfg => cfg.CreateMap <UserRegisterIn, User>());
var mapper = config.CreateMapper();
var user = mapper.Map <User>(dtoUser);
user.PasswordHash = PasswordCryptHelper.GetPasswordHash(dtoUser.Password);
user.Role = role;
ffContext.Users.Add(user);
ffContext.SaveChanges();
user = ffContext.Users.FirstOrDefault(u => u.Id == user.Id);
var userOut = mapper.Map <UserOut>(user);
return(userOut);
}
public IActionResult Create(CreateOrderInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
Order newOrder = mapper.Map <Order>(model);
context.Orders.Add(newOrder);
context.SaveChanges();
return(RedirectToAction("All", "Orders"));
}
public ProductOut Create(ProductIn productIn)
{
var product = MapHelper.Map <ProductIn, Product>(productIn);
var pType = ffContext.ProductTypes
.FirstOrDefault(p => p.Enabled && p.Id == productIn.ProductTypeId);
product.ProductType = pType ?? throw new ArgumentException("productTypeId");
ffContext.Products.Add(product);
ffContext.SaveChanges();
if (product.Image != null)
{
FileHelper.SaveFormFile(productIn.Image, environment.WebRootPath + "\\Images", product.Id + ".png");
product.Image = product.Id + ".png";
ffContext.SaveChanges();
}
return(Get(product.Id));
}
public IActionResult Create(CreateCategoryInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
Category newCategory = mapper.Map <Category>(model);
context.Categories.Add(newCategory);
context.SaveChanges();
return(RedirectToAction("All", "Categories"));
}
public IActionResult Create(CreateItemInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
Item item = mapper.Map <Item>(model);
context.Items.Add(item);
context.SaveChanges();
return(RedirectToAction("All", "Items"));
}
public IActionResult Register(RegisterEmployeeInputModel model)
{
var emp = mapper.Map <Employee>(model);
var test = context.Positions.Where(x => x.Name == model.PositionName).Select(x => x.Id).FirstOrDefault();
emp.PositionId = test;
context.Employees.Add(emp);
context.SaveChanges();
return(RedirectToAction("All", "Employees"));
}
public IActionResult Create(CreateCategoryInputModel model)
{
if (!ModelState.IsValid)
{
return(this.RedirectToAction("Error", "Home"));
}
var categoryToAdd = this.mapper.Map <Category>(model);
context.Categories.Add(categoryToAdd);
context.SaveChanges();
return(this.Redirect("/Categories/All"));
}
public void InitRoles()
{
ffContext.Roles.Add(new UserRole {
Name = "Клиент"
});
ffContext.Roles.Add(new UserRole {
Name = "Торговая точка"
});
ffContext.Roles.Add(new UserRole {
Name = "Администратор"
});
ffContext.Roles.Add(new UserRole {
Name = "Продавец"
});
ffContext.SaveChanges(true);
}
public IActionResult Create(CreateOrderInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
var order = mapper.Map <Order>(model);
order.OrderItems.Add(new OrderItem {
ItemId = model.ItemId, Quantity = model.Quantity
});
context.Orders.Add(order);
context.SaveChanges();
return(this.RedirectToAction("All", "Orders"));
}
public IActionResult Register(RegisterEmployeeInputModel model)
{
if (!ModelState.IsValid)
{
return(this.RedirectToAction("Error", "Home"));
}
var employee = this.mapper.Map <Employee>(model);
context.Add(employee);
context.SaveChanges();
return(this.Redirect("/Employees/All"));
}
public IActionResult Create(CreateItemInputModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Error", "Home"));
}
var item = mapper.Map <Item>(model);
var category = context.Categories.FirstOrDefault(c => c.Name == model.CategoryName);
item.Category = category;
context.Items.Add(item);
context.SaveChanges();
return(RedirectToAction("All", "Items"));
}