public SupplyResponse Put(string id, [FromBody] VirtualItem item)
{
if (string.IsNullOrWhiteSpace(id) || string.IsNullOrWhiteSpace(item.VirtualItemName) ||
string.IsNullOrWhiteSpace(item.VirtualItemId))
{
return(SupplyResponse.RequiredFieldEmpty());
}
var entity = _dbContext.VirtualItem.AsNoTracking().SingleOrDefault(p => p.VirtualItemId.Equals(id));
if (entity == null)
{
return(Post(item));
}
if (entity.VirtualItemId != item.VirtualItemId &&
_dbContext.VirtualItem.SingleOrDefault(p => p.VirtualItemId == item.VirtualItemId) != null)
{
return(SupplyResponse.DuplicateEntry("virtual item", item.VirtualItemId));
}
item.Id = entity.Id;
var entry = _dbContext.Attach(item);
//var entry = _dbContext.Entry(entity);
//entry.CurrentValues.SetValues(item);
entry.State = EntityState.Modified;
_dbContext.SaveChanges();
return(Get(item.VirtualItemId));
}
public SupplyResponse Put(int id)
{
var order = _dbContext.DespatchInstruction.Include(p => p.Request)
.ThenInclude(p => p.RequestItem).ThenInclude(p => p.VirtualItem).Include(p => p.Request)
.ThenInclude(p => p.Restaurant)
.SingleOrDefault(p => p.DespatchInstructionId == id);
if (order == null)
{
return(SupplyResponse.NotFound("Purchase Order", id + ""));
}
order.Request.RequestStatus = RequestStatus.Delivering;
_dbContext.SaveChanges();
order.DespatchInstructionStatus = 1;
_dbContext.SaveChanges();
_dbContext.DeliveryNote.Add(new DeliveryNote
{
CreateTime = DateTime.Now,
RequestId = order.RequestId
});
_dbContext.SaveChanges();
return(Get(id));
}
public SupplyResponse Put(int id, [FromBody] ICollection <ItemRequest> itemRequest)
{
var request = _dbContext.Request.Include(p => p.RequestItem).SingleOrDefault(p => p.RequestId == id);
if (request == null)
{
return(SupplyResponse.NotFound("Request", id + ""));
}
if (itemRequest == null || !itemRequest.Any())
{
return(SupplyResponse.BadRequest("Request Item cannot be empty."));
}
ICollection <RequestItem> requestItems;
if ((requestItems = request.RequestItem) != null)
{
foreach (var items in requestItems)
{
_dbContext.Remove(items);
}
}
_dbContext.SaveChanges();
var itemMap = new Dictionary <int, int>();
foreach (var item in itemRequest)
{
var virtualItem =
_dbContext.VirtualItem.SingleOrDefault(p => p.VirtualItemId.Equals(item.VirtualItemId));
if (virtualItem == null)
{
return(SupplyResponse.NotFound("virtual item", item.VirtualItemId));
}
if (itemMap.ContainsKey(virtualItem.Id))
{
itemMap[virtualItem.Id] += item.Quantity;
}
else
{
itemMap.Add(virtualItem.Id, item.Quantity);
}
}
foreach (var(itemId, qty) in itemMap)
{
var requestItem = new RequestItem
{
RequestId = request.RequestId,
VirtualItemId = itemId,
Quantity = qty
};
_dbContext.RequestItem.Add(requestItem);
_dbContext.SaveChanges();
}
return(Get(request.RequestId));
}
public SupplyResponse CreateToken([FromBody] LoginRequest login)
{
var response = SupplyResponse.Fail("Unauthorize", "Your are not the user in the system.");
var user = Authenticate(login);
if (user != null)
{
var expiry = DateTime.Now.AddDays(1);
var tokenString = BuildToken(expiry, user);
var restaurantManager = user.RestaurantManager;
dynamic workplace = null;
if (restaurantManager != null)
{
workplace = new
{
restaurantId = restaurantManager.RestaurantId,
stockId = restaurantManager.Restaurant.StockId
};
}
response = SupplyResponse.Ok(new
{
token = tokenString,
userType = user.UserType,
expiry,
user,
workplace
});
}
return(response);
}
public SupplyResponse Get(int id)
{
var category = _dbContext.Category.Include(a => a.CategoryItems).ThenInclude(a => a.VirtualItem).SingleOrDefault(p => p.CategoryId == id);
if (category == null)
{
return(SupplyResponse.NotFound("category", id + ""));
}
var categoryItemResponse = new CategoryItemResponse
{
Category = category,
VirtualItemId = new List <string>()
};
if (category.CategoryItems != null)
{
foreach (var categoryItem in category.CategoryItems)
{
categoryItemResponse.VirtualItemId.Add(categoryItem.VirtualItem.VirtualItemId);
}
category.CategoryItems = null;
}
return(SupplyResponse.Ok(categoryItemResponse));
}
public SupplyResponse AddToCategory(int id, [FromBody] IdRequest idRequest)
{
var category = _dbContext.Category.SingleOrDefault(p => p.CategoryId == id);
var vItm = _dbContext.VirtualItem.SingleOrDefault(p => p.VirtualItemId == idRequest.Id);
if (category == null)
{
return(SupplyResponse.NotFound("category", id + ""));
}
if (vItm == null)
{
return(SupplyResponse.NotFound("virtual item", idRequest.Id + ""));
}
var cItem = _dbContext.CategoryItem.SingleOrDefault(p =>
p.CategoryId == category.CategoryId && p.VirtualItem.VirtualItemId == vItm.VirtualItemId);
if (cItem != null)
{
return(SupplyResponse.DuplicateEntry("category item",
$"\"{cItem.VirtualItemId} in {cItem.CategoryId}\""));
}
var cateItm = new CategoryItem
{
CategoryId = category.CategoryId,
VirtualItemId = vItm.Id
};
_dbContext.CategoryItem.Add(cateItm);
_dbContext.SaveChanges();
return(Get(category.CategoryId));
}
public SupplyResponse Get()
{
var currentUser = HttpContext.User;
var dbUser =
_dbContext.User.Include(p => p.RestaurantManager).ThenInclude(p => p.Restaurant)
.SingleOrDefault(p => currentUser.FindFirst(ClaimTypes.Name).Value.Equals(p.UserName));
if (dbUser == null)
{
return(SupplyResponse.Fail("Unauthorize", "Your are not the user in the system."));
}
var restaurantManager = dbUser.RestaurantManager;
if (restaurantManager == null)
{
return(SupplyResponse.Fail("Unauthorize", "Your are not the restaurant manager."));
}
var restaurantId = restaurantManager.Restaurant.RestaurantId;
var requests = _dbContext.Request.Include(p => p.User).Include(p => p.RequestItem)
.ThenInclude(p => p.VirtualItem).Include(p => p.RequestMap)
.Where(p => p.RestaurantId == restaurantId)
.Select(p => p);
foreach (var request in requests)
{
foreach (var requestItem in request.RequestItem)
{
requestItem.VirtualItemName = requestItem.VirtualItem.VirtualItemName;
requestItem.RequestVirtualItemId = requestItem.VirtualItem.VirtualItemId;
}
}
return(SupplyResponse.Ok(requests));
}
public SupplyResponse Get()
{
var categories = _dbContext.Category.Include(a => a.CategoryItems).ThenInclude(a => a.VirtualItem).Select(p => p);
var categoryItemResponses = new List <CategoryItemResponse>();
foreach (var category in categories)
{
var categoryItemResponse = new CategoryItemResponse
{
Category = category,
VirtualItemId = new List <string>()
};
if (category.CategoryItems != null)
{
foreach (var categoryItem in category.CategoryItems)
{
categoryItemResponse.VirtualItemId.Add(categoryItem.VirtualItem.VirtualItemId);
}
category.CategoryItems = null;
}
categoryItemResponses.Add(categoryItemResponse);
}
return(SupplyResponse.Ok(categoryItemResponses));
}
public SupplyResponse Post(string id, [FromBody] IdRequest idRequest)
{
if (idRequest == null || string.IsNullOrWhiteSpace(idRequest.Id))
{
return(SupplyResponse.RequiredFieldEmpty());
}
var vItem = _dbContext.VirtualItem.SingleOrDefault(p => p.VirtualItemId == idRequest.Id);
var item = _dbContext.Item.SingleOrDefault(p => p.SupplierItemId == id);
if (item == null)
{
return(SupplyResponse.NotFound("item", id));
}
if (vItem == null)
{
return(SupplyResponse.NotFound("virtual item", idRequest.Id));
}
if (_dbContext.VirtualIdMap.SingleOrDefault(p =>
p.ItemId == item.Id && p.VirtualItemId == vItem.Id) != null)
{
return(SupplyResponse.DuplicateEntry("virtual map", $"{id}<->{idRequest.Id}"));
}
_dbContext.VirtualIdMap.Add(new VirtualIdMap {
ItemId = item.Id, VirtualItemId = vItem.Id
});
_dbContext.SaveChanges();
return(SupplyResponse.Ok());
}
public SupplyResponse Get(int id)
{
var restaurant = _dbContext.Restaurant.Include(p => p.RestaurantManager)
.SingleOrDefault(p => p.RestaurantId == id);
return(SupplyResponse.Ok(restaurant));
}
public SupplyResponse Post([FromBody] UserRequest user)
{
if (string.IsNullOrWhiteSpace(user.Name) || string.IsNullOrWhiteSpace(user.UserName) ||
string.IsNullOrWhiteSpace(user.Password))
{
return(SupplyResponse.RequiredFieldEmpty());
}
var entity = _dbContext.User.AsNoTracking().SingleOrDefault(p => p.UserName == user.UserName);
if (entity != null)
{
return(SupplyResponse.DuplicateEntry("user", user.UserName));
}
var dbUser = new User
{
Name = user.Name,
UserName = user.UserName,
Password = HashUtilities.HashPassword(user.Password),
UserType = user.UserType
};
_dbContext.User.Add(dbUser);
_dbContext.SaveChanges();
return(Get(dbUser.UserId));
}
public SupplyResponse Get()
{
var currentUser = HttpContext.User;
var dbUser =
_dbContext.User.Include(p => p.RestaurantManager).ThenInclude(p => p.Restaurant)
.SingleOrDefault(p => currentUser.FindFirst(ClaimTypes.Name).Value.Equals(p.UserName));
if (dbUser == null)
{
return(SupplyResponse.Fail("Unauthorize", "Your are not the user in the system."));
}
if (dbUser.UserType == UserType.RestaurantManager)
{
var restaurantManager = dbUser.RestaurantManager;
if (restaurantManager == null)
{
return(SupplyResponse.Fail("Unauthorize", "Your are not the restaurant manager of any restaurant."));
}
return(SupplyResponse.Ok(new { stock = restaurantManager.Restaurant.StockId }));
}
var id = _dbContext.Stock.FirstOrDefault(p => p.StockType == StockType.WarehouseStock).StockId;
return(SupplyResponse.Ok(new { stock = id }));
}
public SupplyResponse Put(int id, [FromBody] UserRequest user)
{
var dbUser = _dbContext.User.SingleOrDefault(p => p.UserId == id);
if (dbUser == null)
{
return(SupplyResponse.NotFound("user", id + ""));
}
if (string.IsNullOrWhiteSpace(user.UserName))
{
return(SupplyResponse.BadRequest("Required Field is Empty"));
}
dbUser.Name = user.Name;
dbUser.UserName = user.UserName;
dbUser.UserType = user.UserType;
var oldPw = dbUser.Password;
user.Password = string.IsNullOrWhiteSpace(user.Password)
? oldPw
: HashUtilities.HashPassword(user.Password);
_dbContext.SaveChanges();
return(Get(id));
}
public SupplyResponse Get(int id)
{
var stock = _dbContext.Stock.Include(a => a.StockItem).ThenInclude(a => a.VirtualItem)
.SingleOrDefault(p => p.StockId == id);
return(SupplyResponse.Ok(stock));
}
public SupplyResponse Post([FromBody] Announcement data)
{
if (string.IsNullOrWhiteSpace(data.Message) || string.IsNullOrWhiteSpace(data.Title) ||
data.Target == null || !data.Target.Any())
{
return(SupplyResponse.RequiredFieldEmpty());
}
if (data.RemovalTime < DateTime.Now)
{
return(SupplyResponse.BadRequest("Removal Time should be a future date"));
}
_dbContext.DataCache.Add(new DataCache
{
CacheType = "Announcement",
CacheTime = DateTime.Now,
Content = JsonConvert.SerializeObject(data, new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new CamelCasePropertyNamesContractResolver()
}),
RemovalTime = data.RemovalTime
});
_dbContext.SaveChanges();
_hubContext.Clients.All.SendAsync("ReceiveAnnouncement", data.Target, "A new announcement broadcasted");
return(Get());
}
public SupplyResponse Delete(int id)
{
var entity = _dbContext.Restaurant.SingleOrDefault(p => p.RestaurantId == id);
if (entity == null) return SupplyResponse.NotFound("restaurant", id + "");
_dbContext.Remove(entity);
_dbContext.SaveChanges();
return SupplyResponse.Ok();
}
public SupplyResponse Get()
{
var orders = _dbContext.DeliveryNote.Include(p => p.Request)
.ThenInclude(p => p.RequestItem).ThenInclude(p => p.VirtualItem).Include(p => p.Request)
.ThenInclude(p => p.Restaurant).Select(p => p);
return(SupplyResponse.Ok(orders));
}
public SupplyResponse Delete(int id)
{
var datas = _dbContext.DataCache.SingleOrDefault(p => p.DataCacheId == id);
_dbContext.DataCache.Remove(datas);
_dbContext.SaveChanges();
return(SupplyResponse.Ok());
}
public SupplyResponse Get()
{
var orders = _dbContext.BlanketRelease.Include(p => p.Agreement).ThenInclude(p => p.Supplier).Include(p => p.Request)
.ThenInclude(p => p.RequestItem).Include(p => p.BlanketReleaseLine).ThenInclude(p => p.Item).Include(p => p.Request)
.ThenInclude(p => p.Restaurant)
.Select(p => p);
return(SupplyResponse.Ok(orders));
}
public SupplyResponse Get()
{
var orders = _dbContext.ScheduleRelease.Include(p => p.Agreement)
.ThenInclude(p => p.PlannedPurchaseAgreementDetails).Include(p => p.Agreement)
.ThenInclude(p => p.Supplier).Include(p => p.Agreement)
.ThenInclude(p => p.PlannedPurchaseAgreementLines).ThenInclude(p => p.Item).Select(p => p);
return(SupplyResponse.Ok(orders));
}
public SupplyResponse Get(int id)
{
var order = _dbContext.DeliveryNote.Include(p => p.Request)
.ThenInclude(p => p.RequestItem).ThenInclude(p => p.VirtualItem).Include(p => p.Request)
.ThenInclude(p => p.Restaurant)
.SingleOrDefault(p => p.RequestId == id);
return(order == null?SupplyResponse.NotFound("Delivery Note", id + "") : SupplyResponse.Ok(order));
}
public SupplyResponse Get(int id)
{
var order = _dbContext.BlanketRelease.Include(p => p.Agreement).ThenInclude(p => p.Supplier).Include(p => p.Request)
.ThenInclude(p => p.RequestItem).Include(p => p.BlanketReleaseLine).ThenInclude(p => p.Item).Include(p => p.Request)
.ThenInclude(p => p.Restaurant)
.SingleOrDefault(p => p.OrderId == id);
return(order == null?SupplyResponse.NotFound("Purchase Order", id + "") : SupplyResponse.Ok(order));
}
public SupplyResponse Get(string id)
{
var item = _dbContext.Item.SingleOrDefault(p => p.SupplierItemId.Equals(id));
if (item == null)
{
return(SupplyResponse.NotFound("item", id));
}
return(SupplyResponse.Ok(item));
}
public SupplyResponse Get()
{
var agreements = _dbContext.Agreement.Select(p => p).Include(p => p.BlanketPurchaseAgreementDetails)
.Include(p => p.BlanketPurchaseAgreementLines).ThenInclude(p => p.Item)
.Include(p => p.ContractPurchaseAgreementDetails).Include(p => p.ContractPurchaseAgreementLines)
.ThenInclude(p => p.Item).Include(p => p.PlannedPurchaseAgreementDetails)
.Include(p => p.PlannedPurchaseAgreementLines).ThenInclude(p => p.Item);
return(SupplyResponse.Ok(agreements));
}
public SupplyResponse Get()
{
var orders = _dbContext.StandardPurchaseOrder.Include(p => p.Agreement).ThenInclude(p => p.Supplier)
.Include(p => p.Request)
.ThenInclude(p => p.RequestItem).Include(p => p.StandardPurchaseOrderLine).ThenInclude(p => p.Item)
.Include(p => p.Request)
.ThenInclude(p => p.Restaurant).Select(p => p);
return(SupplyResponse.Ok(orders));
}
public SupplyResponse Get(int id)
{
var order = _dbContext.ScheduleRelease.Include(p => p.Agreement)
.ThenInclude(p => p.PlannedPurchaseAgreementDetails).Include(p => p.Agreement)
.ThenInclude(p => p.Supplier).Include(p => p.Agreement)
.ThenInclude(p => p.PlannedPurchaseAgreementLines).ThenInclude(p => p.Item)
.SingleOrDefault(p => p.OrderId == id);
return(order == null?SupplyResponse.NotFound("Schedule Release", id + "") : SupplyResponse.Ok(order));
}
public SupplyResponse Get(int id)
{
var supplier = _dbContext.Supplier.SingleOrDefault(p => p.SupplierId == id);
if (supplier == null)
{
return(SupplyResponse.NotFound("supplier", id + ""));
}
return(SupplyResponse.Ok(supplier));
}
public SupplyResponse Post([FromBody] Supplier supplier)
{
if (string.IsNullOrWhiteSpace(supplier.SupplierName) || string.IsNullOrWhiteSpace(supplier.SupplierContactPerson) || string.IsNullOrWhiteSpace(supplier.SupplierAddress))
{
return(SupplyResponse.BadRequest("Required Field is Empty"));
}
_dbContext.Supplier.Add(supplier);
_dbContext.SaveChanges();
return(Get(supplier.SupplierId));
}
public SupplyResponse Get(int id)
{
var item = _dbContext.Category.SingleOrDefault(p => p.CategoryId == id);
if (item == null)
{
return(SupplyResponse.NotFound("categorty", id + ""));
}
return(SupplyResponse.Ok(item));
}
public SupplyResponse Post([FromBody] Category category)
{
if (string.IsNullOrWhiteSpace(category.CategoryName))
{
return(SupplyResponse.RequiredFieldEmpty());
}
_dbContext.Category.Add(category);
_dbContext.SaveChanges();
return(Get(category.CategoryId));
}
