public ServiceResult <bool> UpdateProduct(int productId, ProductBase product)
{
if (productId < 1)
{
return(ServiceResult <bool> .CreateErrorResult($"{nameof(productId)} must be more than 0"));
}
bool isProductValid;
try
{
isProductValid = ValidateProductBase(product);
}
catch (ArgumentException aex)
{
return(ServiceResult <bool> .CreateErrorResult(aex.Message));
}
if (!isProductValid)
{
return(ServiceResult <bool> .CreateErrorResult("Model is not valid"));
}
try
{
var result = _productProvider.UpdateBaseProduct(productId, product);
return(ServiceResult <bool> .CreateSuccessResult(result));
}
catch (Exception ex)
{
return(ServiceResult <bool> .CreateErrorResult(ex.Message));
}
}
public ServiceResult UpdateSystemConfig(SystemInformationDto[] systemInformations)
{
var entities = Mapper.Map <SystemInformation[]>(systemInformations);
Repository.UpdateSystemConfig(entities);
return(ServiceResult.CreateSuccessResult());
}
public ServiceResult <TDto> AddProductToOrderTable <TDto>(long orderTableID, long productID, decimal quantity)
{
var product = ProductRepository.GetByID(productID);
if (product == null)
{
return(ServiceResult <TDto> .CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Business_DataNotExist), ErrorType.Business)));
}
var order = Repository.Get(x => x.OrderTables.Any(y => y.ID == orderTableID));
if (order == null)
{
return(ServiceResult <TDto> .CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Business_DataNotExist), ErrorType.Business)));
}
var orderTable = order.OrderTables.First(y => y.ID == orderTableID);
orderTable.OrderDetails.Add(new OrderDetail
{
Quantity = quantity,
Product = product,
OrderStatus = SmsCache.BranchConfigs.Current.UseKitchenFunction ? OrderStatus.Ordered : OrderStatus.Done
});
Repository.Save(order);
return(ServiceResult <TDto> .CreateSuccessResult(Mapper.Map <TDto>(orderTable)));
}
public ServiceResult <IList <TModel> > GetAccessiblePagesForUser <TModel>(long userID)
{
if (userID == 0)
{
return(GetPagesByTypes <TModel>(PageType.Public));
}
var user = UserRepository.GetByID(userID);
if (user.IsSystemAdmin)
{
return(GetPagesByTypes <TModel>(PageType.Public, PageType.Protected, PageType.System));
}
var accessiblePageIds = new List <long>();
foreach (var role in user.Roles.Where(x => x.Enable))
{
accessiblePageIds.AddRange(role.Pages.Where(x => !ExcludedPages.Contains(x.ID)).Select(x => x.ID));
}
accessiblePageIds = accessiblePageIds.Distinct().ToList();
var result = Repository.List(x => x.Enable && (accessiblePageIds.Contains(x.ID) ||
x.Type == PageType.Public ||
(user.UseSystemConfig && x.Type == PageType.System))).ToList();
return(ServiceResult <IList <TModel> > .CreateSuccessResult(Mapper.Map <IList <TModel> >(result)));
}
public ServiceResult UpdateUserBranch(UserInfoDto user, UserConfigDto userConfig)
{
Repository.SaveUserBranch(Mapper.Map <User>(user));
UserConfigRepository.SaveUserProfile(userConfig.UserID, userConfig.BranchID, IsSuspended: userConfig.IsSuspended);
return(ServiceResult.CreateSuccessResult());
}
public ServiceResult <TDto> UpdateOrderedProductStatus <TDto>(long orderDetailID, OrderStatus value)
{
var order = Repository.Get(x => x.OrderTables.Any(y => y.OrderDetails.Any(z => z.ID == orderDetailID)));
if (order == null)
{
return(ServiceResult <TDto> .CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Business_DataNotExist), ErrorType.Business)));
}
var orderTable = order.OrderTables.First(y => y.OrderDetails.Any(z => z.ID == orderDetailID));
var orderDetail = orderTable.OrderDetails.First(z => z.ID == orderDetailID);
orderDetail.OrderStatus = value;
Repository.Save(order);
if (orderDetail.OrderStatus == OrderStatus.KitchenRejected)
{
RejectRepository.Save(new Reject
{
BranchID = SmsCache.UserContext.CurrentBranchId,
ProductCode = orderDetail.Product.ProductCode,
ProductVNName = orderDetail.Product.VNName,
ProductENName = orderDetail.Product.ENName,
Quantity = orderDetail.Quantity,
UnitVNName = orderDetail.Product.Unit.VNName,
UnitENName = orderDetail.Product.Unit.ENName,
OrderComment = orderDetail.Comment,
KitchenComment = orderDetail.KitchenComment,
CreatedDate = DateTime.Now,
CreatedUser = SmsCache.UserContext.UserName
});
}
return(ServiceResult <TDto> .CreateSuccessResult(Mapper.Map <TDto>(orderDetail)));
}
public ServiceResult <IList <PageMenuDto> > GetMenuByPageIds(IList <long> pageList)
{
var menus = Mapper.Map <IList <PageMenuDto> >(Repository.ListAll());
var result = menus.Where(x => pageList.Contains(x.PageID)).ToList();
for (var i = 0; i < result.Count; i++)
{
if (result[i].ParentID == 0)
{
continue;
}
if (result.Any(x => x.ID == result[i].ParentID))
{
continue;
}
var menu = menus.FirstOrDefault(x => x.ID == result[i].ParentID);
if (menu != null)
{
result.Add(menu);
}
}
return(ServiceResult <IList <PageMenuDto> > .CreateSuccessResult(result));
}
public ServiceResult <ProductBase> CreateProduct(ProductBase product)
{
bool isProductValid;
try
{
isProductValid = ValidateProductBase(product);
}
catch (ArgumentException aex)
{
return(ServiceResult <ProductBase> .CreateErrorResult(aex.Message));
}
if (!isProductValid)
{
return(ServiceResult <ProductBase> .CreateErrorResult("Model is not valid"));
}
try
{
var result = _productProvider.CreateBaseProduct(product);
return(ServiceResult <ProductBase> .CreateSuccessResult(result));
}
catch (Exception ex)
{
return(ServiceResult <ProductBase> .CreateErrorResult(ex.Message));
}
}
public virtual ServiceResult <TDto> Save(TDto dto)
{
var entity = Mapper.Map <TEntity>(dto);
Repository.Save(entity);
return(ServiceResult <TDto> .CreateSuccessResult(Mapper.Map <TDto>(entity)));
}
public virtual ServiceResult DeleteInCurrentBranch(long primaryKey)
{
var result = Repository.DeleteInCurrentBranch(primaryKey);
return(result
? ServiceResult.CreateSuccessResult()
: ServiceResult.CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Business_DataNotExist), ErrorType.Business)));
}
public virtual ServiceResult <TModel> GetByIDInCurrentBranch <TModel>(long primaryKey)
{
var result = Repository.GetByIDInCurrentBranch(primaryKey);
return(result == null
? ServiceResult <TModel> .CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Business_DataNotExist), ErrorType.Business))
: ServiceResult <TModel> .CreateSuccessResult(Mapper.Map <TModel>(result)));
}
public ServiceResult <UploadedFileDto> GetByPhysicalPath(string physicalPath)
{
var result = Repository.Get(x => x.PhysicalPath.ToLower() == physicalPath.ToLower());
return(result == null
? ServiceResult <UploadedFileDto> .CreateFailResult()
: ServiceResult <UploadedFileDto> .CreateSuccessResult(Mapper.Map <UploadedFileDto>(result)));
}
public ServiceResult SaveOrderDiscount(long orderID, OrderDiscountDto[] orderDiscounts)
{
var discounts = Mapper.Map <OrderDiscount[]>(orderDiscounts);
discounts.Apply(x => x.OrderID = orderID);
Repository.SaveDiscounts(orderID, discounts);
return(ServiceResult.CreateSuccessResult());
}
public ServiceResult <UserConfigDto> SaveCashierInfo(long defaultAreaID, decimal listTableHeight)
{
var result = Repository.SaveUserProfile(SmsCache.UserContext.UserID, SmsCache.UserContext.CurrentBranchId, defaultAreaID, listTableHeight);
SmsCache.UserContext.DefaultAreaID = defaultAreaID;
SmsCache.UserContext.ListTableHeight = listTableHeight;
return(ServiceResult <UserConfigDto> .CreateSuccessResult(Mapper.Map <UserConfigDto>(result)));
}
public void ServiceResult_CreateSuccessResult()
{
ServiceResult <object> result = null;
Assert.DoesNotThrow(() => result = ServiceResult <object> .CreateSuccessResult(new object()));
Assert.IsNotNull(result);
Assert.IsFalse(result.IsErrored);
Assert.IsInstanceOf(typeof(object), result.Result);
Assert.IsNull(result.ErrorMessage);
}
public ServiceResult <IList <RoleDto> > GetByUserID(long userID)
{
if (userID == 0)
{
return(ServiceResult <IList <RoleDto> > .CreateSuccessResult(new List <RoleDto>()));
}
var result = Repository.List(x => x.UsersInRole.Select(y => y.ID).Contains(userID)).ToList();
return(ServiceResult <IList <RoleDto> > .CreateSuccessResult(Mapper.Map <IList <RoleDto> >(result)));
}
public ServiceResult UpdateUserSystem(UserDto user)
{
if (Repository.Exists(x => x.Username == user.Username))
{
return(ServiceResult.CreateFailResult());
}
Repository.SaveUserSystem(Mapper.Map <User>(user));
return(ServiceResult.CreateSuccessResult());
}
private ServiceResult <IList <TModel> > GetPagesByTypes <TModel>(params PageType[] types)
{
if (types == null || !types.Any())
{
return(ServiceResult <IList <TModel> > .CreateSuccessResult(Mapper.Map <IList <TModel> >(new List <Page>())));
}
var result = Repository.List(x => types.Contains(x.Type) && x.Enable).ToList();
return(ServiceResult <IList <TModel> > .CreateSuccessResult(Mapper.Map <IList <TModel> >(result)));
}
public ServiceResult <IList <Company> > GetCompaniesForProduct(int baseProductId)
{
if (baseProductId <= 0)
{
return(ServiceResult <IList <Company> > .CreateErrorResult("BaseProductId must be more than 0"));
}
var result = _companyProvider.GetCompaniesFor(baseProductId);
return(ServiceResult <IList <Company> > .CreateSuccessResult(result));
}
public ServiceResult <Company> Get(int id)
{
if (id <= 0)
{
return(ServiceResult <Company> .CreateErrorResult("Id must be great than 0"));
}
var result = _companyProvider.GetCompany(id);
return(ServiceResult <Company> .CreateSuccessResult(result));
}
public ServiceResult <bool> DeleteCompany(int id)
{
if (id <= 0)
{
return(ServiceResult <bool> .CreateErrorResult($"{nameof(id)} can not be less than 1"));
}
var result = _companyProvider.DeleteCompany(id);
return(ServiceResult <bool> .CreateSuccessResult(result));
}
public ServiceResult UpdateUserProfile(string password, string firstName, string lastName, string cellPhone, string email, string address, string theme, int pageSize)
{
Repository.UpdateProfile(SmsCache.UserContext.UserID, password, firstName, lastName, cellPhone, email, address);
UserConfigRepository.SaveThemeAndPageSize(SmsCache.UserContext.UserID, SmsCache.UserContext.CurrentBranchId, theme, pageSize);
SmsCache.UserContext.Theme = theme;
SmsCache.UserContext.PageSize = pageSize;
SmsCache.UserContext.FirstName = firstName;
SmsCache.UserContext.LastName = lastName;
return(ServiceResult.CreateSuccessResult());
}
public void ServiceResult_AppendErrorMessage_InitialSuccessResult_NewResult()
{
ServiceResult <object> initialResult = ServiceResult <object> .CreateSuccessResult(new object());
ServiceResult <object> result = null;
string errorMessage = "error";
Assert.DoesNotThrow(() => result = initialResult.AppendErrorMessage(errorMessage));
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(object), result.Result);
Assert.IsTrue(result.IsErrored);
Assert.IsNotNull(result.Result);
Assert.AreEqual(errorMessage, result.ErrorMessage);
}
public ServiceResult <IList <Company> > GetCompanies(PageRequest pageInfo)
{
string errorMessage;
var isValid = ValidatePageRequest(pageInfo, out errorMessage);
if (!isValid)
{
return(ServiceResult <IList <Company> > .CreateErrorResult(errorMessage));
}
var result = _companyProvider.GetCompanies(pageInfo);
return(ServiceResult <IList <Company> > .CreateSuccessResult(result));
}
public ServiceResult <IList <TDto> > GetByPageID <TDto>(long pageID, bool includeGlobalLabels = false)
{
var ids = new List <long> {
pageID
};
if (includeGlobalLabels)
{
ids.Add(ConstPage.Global);
}
var labels = Repository.List(x => ids.Contains(x.Page.ID) && x.BranchID == (SmsCache.UserContext == null ? ConstConfig.NoBranchID : SmsCache.UserContext.CurrentBranchId)).ToList();
return(ServiceResult <IList <TDto> > .CreateSuccessResult(Mapper.Map <IList <TDto> >(labels)));
}
public ServiceResult Payment(long orderID, string taxInfo, decimal tax, decimal serviceFee, PaymentMethod paymentMethod)
{
var order = Repository.GetByID(orderID);
if (order == null)
{
return(ServiceResult.CreateFailResult());
}
InvoiceRepository.CreateInvoice(order, SmsCache.UserContext.UserID, SmsCache.BranchConfigs.Current.Currency, tax, serviceFee, taxInfo, paymentMethod);
order.OrderProgressStatus = OrderProgressStatus.Done;
Repository.Save(order);
return(ServiceResult.CreateSuccessResult());
}
public ServiceResult <TModel> Get <TModel>(string username, string password)
{
var user = Repository.Get(x => x.Username == username && x.Password == EncryptionHelper.SHA256Hash(password));
if (user == null)
{
return(ServiceResult <TModel> .CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Login_UsernamePasswordInvalid), ErrorType.Business)));
}
if (user.IsLockedOut)
{
return(ServiceResult <TModel> .CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Login_UserLocked), ErrorType.Business)));
}
return(ServiceResult <TModel> .CreateSuccessResult(Mapper.Map <TModel>(user)));
}
public ServiceResult DeleteOrderDetail(long orderDetailID)
{
var order = Repository.Get(x => x.OrderTables.Any(y => y.OrderDetails.Any(z => z.ID == orderDetailID)));
if (order == null)
{
return(ServiceResult.CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Business_DataNotExist), ErrorType.Business)));
}
var orderTable = order.OrderTables.First(y => y.OrderDetails.Any(z => z.ID == orderDetailID));
var orderDetail = orderTable.OrderDetails.First(z => z.ID == orderDetailID);
orderTable.OrderDetails.Remove(orderDetail);
return(ServiceResult.CreateSuccessResult());
}
public ServiceResult MoveTable(long orderTableID, long tableID)
{
var order = Repository.Get(x => x.OrderTables.Select(y => y.ID).Contains(orderTableID));
if (order == null)
{
return(ServiceResult.CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Business_DataNotExist), ErrorType.Business)));
}
order.OrderTables.First(x => x.ID == orderTableID).Table = new Table {
ID = tableID
};
Repository.Save(order);
return(ServiceResult.CreateSuccessResult());
}
public ServiceResult UpdateProductToOrderTable(long orderDetailID, string columnName, string value)
{
var order = Repository.Get(x => x.OrderTables.Any(y => y.OrderDetails.Any(z => z.ID == orderDetailID)));
if (order == null)
{
return(ServiceResult.CreateFailResult(new Error(SmsCache.Message.Get(ConstMessageIds.Business_DataNotExist), ErrorType.Business)));
}
var orderTable = order.OrderTables.First(y => y.OrderDetails.Any(z => z.ID == orderDetailID));
var orderDetail = orderTable.OrderDetails.First(z => z.ID == orderDetailID);
if (orderDetail == null)
{
return(ServiceResult.CreateFailResult());
}
switch (columnName)
{
case "qty":
if (orderDetail.OrderStatus != OrderStatus.KitchenAccepted)
{
orderDetail.Quantity = decimal.Parse(value);
}
break;
case "cmt":
orderDetail.Comment = value;
break;
case "discount":
{
orderDetail.Discount = decimal.Parse(value);
orderDetail.DiscountCode = "";
orderDetail.DiscountType = DiscountType.Number;
orderDetail.DiscountComment = "";
break;
}
case "kitchenComment":
orderDetail.KitchenComment = value;
break;
}
Repository.Save(order);
return(ServiceResult.CreateSuccessResult());
}
