/// <summary>
/// Sets the default.
/// 设为默认地址
/// </summary>
/// <param name="userId">会员Id</param>
/// <param name="addressId">The address identifier.</param>
public ServiceResult SetDefault(long userId, ObjectId addressId)
{
var userAddress = GetList(r => r.UserId == userId);
if (userAddress != null && userAddress.Count > 0)
{
var address = userAddress.FirstOrDefault(r => r.Id == addressId);
if (address == null)
{
return(ServiceResult.FailedWithMessage("地址未找到，或已删除"));
}
address.IsDefault = true;
if (Update(address))
{
userAddress.Remove(address);
userAddress.Foreach(u => {
u.IsDefault = false;
Update(u);
});
return(ServiceResult.Success);
}
//// 修改当前的默认地址为true
//if (temp) {
// // 修改其他的地址为false
// if (Update(r => r.IsDefault = false, r => r.Id != addressId && r.UserId == userId)) {
// return ServiceResult.Success;
// }
//}
}
return(ServiceResult.FailedWithMessage("默认地址修改失败"));
}
/// <summary>
/// </summary>
/// <param name="httpContext"></param>
public ServiceResult Message(DefaultHttpContext httpContext)
{
var orderMessage = AutoMapping.SetValue <OrderMessage>(httpContext);
var orderId = httpContext.Request.Form["OrderId"].ConvertToLong();
var order = Resolve <IOrderService>().GetSingle(r => r.Id == orderId);
if (order == null)
{
return(ServiceResult.FailedWithMessage("订单不存在"));
}
if (order.OrderExtension.OrderRemark == null)
{
order.OrderExtension.OrderRemark = new OrderRemark();
}
order.OrderExtension.Message.PlatplatformMessage = orderMessage.PlatplatformMessage;
order.Extension = ObjectExtension.ToJson(order.OrderExtension);
var result = Resolve <IOrderService>().Update(order);
if (result)
{
return(ServiceResult.Success);
}
return(ServiceResult.FailedWithMessage("失败"));
}
public ServiceResult Save(object model, AutoBaseModel autoModel)
{
var view = model.MapTo <TestShareOrderView>();
var user = Resolve <IUserService>().GetSingle(view.UserName);
if (user == null)
{
return(ServiceResult.FailedWithMessage("用户不存在"));
}
if (view.Amount <= 0)
{
return(ServiceResult.FailedWithMessage("分润金额不能小于0"));
}
var shareOrder = new ShareOrder
{
UserId = user.Id,
EntityId = user.Id,
Amount = view.Amount,
TriggerType = TriggerType.Other
};
if (!Resolve <IShareOrderService>().Add(shareOrder))
{
return(ServiceResult.FailedWithMessage("添加失败"));
}
return(ServiceResult.Success);
}
/// <summary>
/// 卖家评价
/// </summary>
/// <param name="httpContext"></param>
public ServiceResult Rate(DefaultHttpContext httpContext)
{
var orderRate = AutoMapping.SetValue <OrderRateInfo>(httpContext);
var orderId = httpContext.Request.Form["OrderId"].ConvertToLong();
var order = Resolve <IOrderService>().GetSingle(r => r.Id == orderId);
if (orderRate.Intro.IsNullOrEmpty())
{
return(ServiceResult.FailedWithMessage("详情不能为空"));
}
if (order == null)
{
return(ServiceResult.FailedWithMessage("订单不存在"));
}
order.OrderExtension.OrderRate.SellerRate = orderRate;
order.Extension = ObjectExtension.ToJson(order.OrderExtension);
var result = Resolve <IOrderService>().Update(order);
if (result)
{
return(ServiceResult.Success);
}
return(ServiceResult.FailedWithMessage("失败"));
}
/// <summary>
/// 卖家评价 (2019.03.31 新作用)
/// </summary>
/// <param name="orderRate"></param>
public ServiceResult Rate(OrderRateInfo orderRate)
{
var order = Resolve <IOrderService>().GetSingle(r => r.Id == orderRate.OrderId);
if (orderRate.Intro.IsNullOrEmpty())
{
return(ServiceResult.FailedWithMessage("详情不能为空"));
}
if (order == null)
{
return(ServiceResult.FailedWithMessage("订单不存在"));
}
order.OrderExtension.OrderRate.SellerRate = orderRate;
order.Extension = ObjectExtension.ToJson(order.OrderExtension);
var result = Resolve <IOrderService>().Update(order);
if (result)
{
return(ServiceResult.Success);
}
return(ServiceResult.FailedWithMessage("失败"));
}
/// <summary>
/// 锁定
/// </summary>
/// <param name="context">当前上下文</param>
/// <param name="id">主键ID</param>
/// <param name="configValue"></param>
public async Task <ServiceResult> LockShareModuleAsync(HttpContext context, long id, object configValue)
{
TaskModuleConfigBaseService(context);
try {
var shareModule = GetSingle(context, id);
if (shareModule == null)
{
return(ServiceResult.FailedWithMessage("配置未找到"));
}
shareModule.ConfigValue = configValue.ToJson();
var resultToken =
await _shareApiClient.UpdateShareModule(_serverAuthenticationManager.Token.Token, shareModule);
if (!resultToken)
{
return(ServiceResult.FailedWithMessage("锁定/解锁失败"));
}
DeleteCache();
} catch {
return(ServiceResult.FailedWithMessage("服务异常，请稍后再试"));
}
return(ServiceResult.Success);
}
/// <summary>
/// Changes the mobile.
/// 修改手机号码
/// </summary>
/// <param name="view">The 视图.</param>
public ServiceResult ChangeMobile(ViewChangMobile view)
{
var user = Resolve <IUserService>().GetSingle(r => r.Mobile == view.Mobile && r.UserName == view.UserName);
if (user == null)
{
return(ServiceResult.FailedWithMessage("手机号码和用户名不匹配"));
}
var newUser = Resolve <IUserService>().GetSingleByMobile(view.NewMobile);
if (newUser != null)
{
return(ServiceResult.FailedWithMessage("手机号码已被占用"));
}
var result = Resolve <IUserService>().Update(r => { r.Mobile = view.NewMobile; }, r => r.Id == user.Id);
if (result)
{
return(ServiceResult.Success);
}
return(ServiceResult.FailedWithMessage("手机号码修改失败"));
}
private ServiceResult Save(Type type, dynamic model)
{
var find = DynamicService.ResolveMethod(type.Name, "GetSingle", model.Id);
if (!find.Item1.Succeeded)
{
return(ServiceResult.FailedWithMessage("参数值为空"));
}
var entity = find.Item2;
if (entity == null)
{
var result = DynamicService.ResolveMethod(type.Name, "Add", model);
if (!result.Item1.Succeeded)
{
return(ServiceResult.FailedWithMessage($"{type.Name},添加失败"));
}
}
else
{
entity = (object)model;
var result = DynamicService.ResolveMethod(type.Name, "Update", entity);
if (!result.Item1.Succeeded)
{
return(ServiceResult.FailedWithMessage($"{type.Name},更新失败"));
}
}
return(ServiceResult.Success);
}
/// <summary>
/// 获取活动视图
/// </summary>
/// <param name="viewInput"></param>
/// <returns></returns>
public Tuple <ServiceResult, Hudong> GetView(HuDongViewInput viewInput)
{
var view = GetSingle(viewInput.Id, viewInput.Key);
if (viewInput.Key.IsNullOrEmpty())
{
return(new Tuple <ServiceResult, Hudong>(ServiceResult.FailedWithMessage("互动类型不能为空"), view));
}
var findType = viewInput.Key.GetInstanceByName();
if (findType == null)
{
return(new Tuple <ServiceResult, Hudong>(ServiceResult.FailedWithMessage("互动类型不存在"), view));
}
if (view == null)
{
view = new Hudong
{
Key = findType.GetType().FullName
};
if (findType is IHuDong set)
{
view.Setting = set.Setting();
view.Awards = set.DefaultAwards();
}
}
view.Name = $"{findType?.GetType()?.FullName?.GetClassDescription()?.ClassPropertyAttribute?.Name}设置";
return(new Tuple <ServiceResult, Hudong>(ServiceResult.Success, view));
}
/// <summary>
/// 添加订单
/// </summary>
/// <param name="shareOrder">The share order.</param>
public ServiceResult AddSingle(ShareOrder shareOrder)
{
if (shareOrder.UserName.IsNullOrEmpty())
{
return(ServiceResult.FailedWithMessage("用户名不能为空"));
}
var user = Resolve <IUserService>().GetSingle(shareOrder.UserName);
if (user == null)
{
return(ServiceResult.FailedWithMessage("用户不存在"));
}
if (user.Status != Status.Normal)
{
return(ServiceResult.FailedWithMessage("用户状态不正常"));
}
shareOrder.UserId = user.Id;
if (Add(shareOrder))
{
return(ServiceResult.Success);
}
return(ServiceResult.FailedWithMessage("添加失败"));
}
public ServiceResult Save(AutoFormInput autoFormInput, AutoBaseModel autoModel)
{
//config
if (autoFormInput.TypeInstance is IAutoConfig)
{
Ioc.Resolve <IApIAlaboAutoConfigService>().Save(autoFormInput.TypeFind, autoFormInput.ModelFind);
}
else if (autoFormInput.TypeInstance is IAutoForm set)
{
var result = set.Save(autoFormInput.ModelFind, autoModel);
if (!result.Succeeded)
{
return(ServiceResult.FailedWithMessage(result.ErrorMessages?.FirstOrDefault()));
}
}
else if (autoFormInput.TypeInstance is IEntity)
{
var result = Save(autoFormInput.TypeFind, autoFormInput.ModelFind);
if (!result.Succeeded)
{
return(result);
}
}
return(ServiceResult.Success);
}
/// <summary>
/// Api 接口请求，只针对Zkcloud中的Api接口有效，返回类型为ApiResult
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url"></param>
/// <param name="para"></param>
/// <returns></returns>
public static Tuple <ServiceResult, T> Post <T>(string url, object para,
Dictionary <string, string> dicHeader = null) where T : new()
{
string response;
try {
response = url.Post(para.ToJsons(), dicHeader);
} catch {
return(new Tuple <ServiceResult, T>(ServiceResult.FailedWithMessage($"网络请求失败,apiUrl:{url}"), default));
}
if (response.IsNullOrEmpty())
{
return(new Tuple <ServiceResult, T>(ServiceResult.FailedWithMessage($"网络请求为空,apiUrl:{url}"), default));
}
try {
var result = response.ToObject <ApiResult <T> >();
if (result.Status != ResultStatus.Success)
{
return(new Tuple <ServiceResult, T>(ServiceResult.FailedWithMessage(result.Message), default));
}
return(new Tuple <ServiceResult, T>(ServiceResult.Success, result.Result));
} catch {
return(new Tuple <ServiceResult, T>(ServiceResult.FailedWithMessage($"请求成功，序列化出错,apiUrl:{url}"),
default));
}
}
/// <summary>
/// Api 接口请求，只针对Zkcloud中的Api接口有效，返回类型为ApiResult
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url"></param>
/// <param name="para"></param>
/// <returns></returns>
public static Tuple <ServiceResult, T> Get <T>(string url, string para = null) where T : new()
{
string response;
try {
response = url.HttpGet();
} catch {
return(new Tuple <ServiceResult, T>(ServiceResult.FailedWithMessage($"网络请求失败,apiUrl:{url}"), default));
}
if (response.IsNullOrEmpty())
{
return(new Tuple <ServiceResult, T>(ServiceResult.FailedWithMessage($"网络请求为空,apiUrl:{url}"), default));
}
try {
var result = response.ToObject <ApiResult <T> >();
if (result.Status != ResultStatus.Success)
{
return(new Tuple <ServiceResult, T>(ServiceResult.FailedWithMessage(result.Message), default));
}
return(new Tuple <ServiceResult, T>(ServiceResult.Success, result.Result));
} catch {
return(new Tuple <ServiceResult, T>(ServiceResult.FailedWithMessage($"请求成功，序列化出错,apiUrl:{url}"),
default));
}
}
public ServiceResult Save(object model, AutoBaseModel autoModel)
{
var find = AutoMapping.SetValue <UserCardOpen>(model);
if (find.GradeId.IsGuidNullOrEmpty())
{
return(ServiceResult.FailedWithMessage("会员卡等级不能为空"));
}
var userGrade = Resolve <IGradeService>().GetGrade(find.GradeId);
if (userGrade == null)
{
return(ServiceResult.FailedWithMessage("会员等级不存在"));
}
var user = Resolve <IUserService>().GetSingle(r => r.UserName == find.UserName);
if (user == null)
{
return(ServiceResult.FailedWithMessage("用户不存在"));
}
user.GradeId = userGrade.Id;
if (!Resolve <IUserService>().UpdateUser(user))
{
return(ServiceResult.FailedWithMessage("开卡失败"));
}
return(ServiceResult.Success);
}
public ServiceResult Save(object model, AutoBaseModel autoModel)
{
var condition = (StoreOrdersToExcel)model;
var store = Resolve <IStoreService>().GetSingle(u => u.UserId == autoModel.BasicUser.Id);
if (store == null)
{
return(ServiceResult.FailedWithMessage("非法操作"));
}
var query = new ExpressionQuery <Order> {
PageIndex = 1,
PageSize = 15
};
//query.And(u => u.StoreId == store.Id);
query.And(u => u.OrderStatus == condition.Status);
var view = Resolve <IOrderService>().GetPagedList(query);
var orders = new List <Order>();
foreach (var item in view)
{
TimeSpan ts = DateTime.Now.Subtract(item.CreateTime);
if (ts.Days < condition.Days)
{
orders.Add(item);
}
}
view.Result = orders;
var modelType = "Order".GetTypeByName();
var result = Resolve <IAdminTableService>().ToExcel(modelType, view);
return(ServiceResult.Success);
}
/// <summary>
/// 互动编辑
/// </summary>
/// <param name="huDong"></param>
/// <returns></returns>
public ServiceResult Edit(Hudong huDong)
{
var findType = huDong.Key.GetInstanceByName();
if (findType == null)
{
return(ServiceResult.FailedWithMessage("互动类型不存在"));
}
var find = GetSingle(huDong.Id, huDong.Key);
if (find != null)
{
if (!Update(huDong))
{
return(ServiceResult.FailedWithMessage("活动更新失败"));
}
}
else
{
// 赋值操作
if (!Add(huDong))
{
return(ServiceResult.FailedWithMessage("活动添加失败"));
}
}
return(ServiceResult.Success);
}
public ServiceResult UserSign(BookingSignupOrderContact view)
{
var orders = Resolve <IBookingSignupOrderService>().GetList(u => u.IsPay);
var list = new List <BookingSignupOrderContact>();
foreach (var item in orders)
{
foreach (var temp in item.Contacts)
{
if (temp.Name == view.Name && temp.Mobile == view.Mobile)
{
if (temp.IsSign == false)
{
temp.IsSign = true;
var result = Resolve <IBookingSignupOrderService>().Update(item);
if (!result)
{
return(ServiceResult.FailedWithMessage("签到失败，请再次尝试"));
}
return(ServiceResult.Success);
}
return(ServiceResult.FailedWithMessage("您已经签到过了，请勿重复签到"));
}
}
}
return(ServiceResult.FailedWithMessage("未找到您的信息，请确认输入信息是否正确"));
}
/// <summary>
/// Builder order info and calculator price
/// </summary>
/// <param name="buyInfoInput"></param>
public Tuple <ServiceResult, MerchantCartOutput> BuyInfo(MerchantBuyInfoInput buyInfo)
{
//user
var result = new MerchantCartOutput();
var user = Resolve <IUserService>().GetSingle(buyInfo.UserId);
if (user == null || user.Status != Status.Normal)
{
return(Tuple.Create(ServiceResult.FailedWithMessage("您的输入的账户不存在，或者状态不正常"), result));
}
//get merchant store
//var merchantStore = Resolve<IMerchantStoreService>().GetSingle(s => s.Id == buyInfo.MerchantStoreId.ToObjectId());
//if (merchantStore == null)
//{
// return Tuple.Create(ServiceResult.FailedWithMessage("当前店铺不存在"), result);
//}
//get cart from database
var cartIds = buyInfo.ProductItems.Select(c => c.Id.ToObjectId()).ToList();
var carts = Resolve <IMerchantCartService>().GetCart(cartIds);
if (carts.Count <= 0)
{
return(Tuple.Create(ServiceResult.FailedWithMessage("购物车为空"), result));
}
return(CountPrice(carts));
}
/// <summary>
/// 获取用户的购物车 快递模板费用未处理
/// </summary>
/// <param name="UserId">用户Id</param>
public Tuple <ServiceResult, StoreProductSku> GetCart(long UserId)
{
var storeItems = Resolve <IShopStoreService>().GetStoreItemListFromCache();
var temp = storeItems.Select(r => r.StoreId);
var viewCarts = Resolve <ICartService>().GetList(e =>
e.UserId == UserId && e.Status == Status.Normal && temp.Contains(e.StoreId)); // 读取购物车数据，是正常店铺的
var orderProductInputList = new List <OrderProductInput>();
foreach (var item in viewCarts)
{
var orderProductInput = new OrderProductInput
{
Count = item.Count,
LoginUserId = UserId,
StoreId = item.StoreId,
ProductId = item.ProductId,
ProductSkuId = item.ProductSkuId
};
orderProductInputList.Add(orderProductInput);
}
if (orderProductInputList.Count == 0)
{
return(Tuple.Create(ServiceResult.FailedWithMessage("商品数量为0"), new StoreProductSku()));
}
var buyInput = new BuyInfoInput
{
LoginUserId = UserId,
ProductJson = orderProductInputList.ToJsons()
};
return(Resolve <IOrderBuyServcie>().BuyInfo(buyInput));
}
/// <summary>
/// 添加购物车
/// </summary>
/// <param name="orderProductInput"></param>
public ServiceResult AddCart(OrderProductInput orderProductInput)
{
var serviceResult = ServiceResult.Success;
var product = Resolve <IProductService>().GetSingle(r => r.Id == orderProductInput.ProductId);
var productSku = Resolve <IProductSkuService>().GetSingle(r => r.Id == orderProductInput.ProductSkuId);
var storeId = _productSkuRepository.GetStoreIdByProductSkuId(orderProductInput.ProductSkuId);
if (product == null)
{
return(ServiceResult.FailedWithMessage("商品不存在"));
}
if (productSku == null)
{
return(ServiceResult.FailedWithMessage("商品SKU错误"));
}
if (storeId.IsObjectIdNullOrEmpty())
{
return(ServiceResult.FailedWithMessage("storeId错误"));
}
var cartSingle = Resolve <ICartService>().GetSingle(u =>
u.ProductId == orderProductInput.ProductId && u.ProductSkuId == orderProductInput.ProductSkuId &&
u.UserId == orderProductInput.LoginUserId &&
u.Status == Status.Normal);
if (cartSingle == null)
{
var cart = new Cart
{
StoreId = storeId,
UserId = orderProductInput.LoginUserId,
Count = orderProductInput.Count,
ProductName = product.Name,
ProductId = product.Id,
Price = product.Price,
ProductSkuId = productSku.Id,
PropertyValueDesc = productSku.PropertyValueDesc
};
Add(cart);
return(serviceResult);
}
//TODO:修改商品数量在这里操作
//var count = cartSingle.Count + orderProductInput.Count;
//TODO:判断商品最大购买和最小购买
//var key = ProductActivityType.BuyPermission.GetDisplayResourceTypeName();
//var buy = Resolve<IActivityService>().GetSingle(s => s.ProductId == orderProductInput.ProductId && s.Key == key);
//if (count > buy?.MaxStock)
// return ServiceResult.FailedWithMessage("商品数量不能高于最大购买数量!");
//else if (count < buy?.MaxStock)
// return ServiceResult.FailedWithMessage("商品数量不能低于最低购买数量!");
// 数量递增
cartSingle.Count += orderProductInput.Count;
Update(cartSingle);
return(ServiceResult.Success);
}
/// <summary>
/// 减少账户金额
/// </summary>
/// <param name="user">用户</param>
/// <param name="typeConfig"></param>
/// <param name="amount"></param>
/// <param name="Intro"></param>
public ServiceResult Reduce(User user, MoneyTypeConfig typeConfig, decimal amount,
string Intro)
{
var result = ServiceResult.Success;
if (user == null)
{
return(ServiceResult.FailedWithMessage("操作用户不存在"));
}
if (amount <= 0)
{
return(ServiceResult.FailedWithMessage("金额不能为0"));
}
var userAcount = Resolve <IAccountService>().GetAccount(user.Id, typeConfig.Id);
var account = Resolve <IAccountService>().GetAccount(user.Id, typeConfig.Id);
if (account == null)
{
return(ServiceResult.FailedWithMessage("操作账户不存在"));
}
if (typeConfig.Status != Status.Normal)
{
return(ServiceResult.FailedWithMessage("操作币种状态不正常"));
}
if (userAcount.Amount < amount)
{
return(ServiceResult.FailedWithMessage("账户余额不足，扣除失败"));
}
userAcount.Amount = userAcount.Amount - amount;
var userBill = CreateBill(userAcount, -amount, BillActionType.SystemReduce, Intro);
var context = Repository <IBillRepository>().RepositoryContext;
context.BeginTransaction();
try
{
Resolve <IAccountService>().Update(userAcount);
Add(userBill);
context.SaveChanges();
context.CommitTransaction();
}
catch (Exception ex)
{
context.RollbackTransaction();
return(ServiceResult.FailedWithMessage("更新失败:" + ex.Message));
}
finally
{
context.DisposeTransaction();
}
return(result);
}
/// <summary>
/// 创建用户资产账户
/// </summary>
/// <param name="userId">会员Id</param>
/// <param name="config">The configuration.</param>
public ServiceResult CreateAccount(long userId, MoneyTypeConfig config)
{
var result = ServiceResult.Success;
if (config == null)
{
return(ServiceResult.FailedWithMessage("货币类型不存在"));
}
if (config.Id.IsNull())
{
return(ServiceResult.FailedWithMessage("货币类型不合法"));
}
if (config.Status != Status.Normal)
{
return(ServiceResult.FailedWithMessage("货币类型状态不正常，不能添加"));
}
var account = new Account
{
UserId = userId,
MoneyTypeId = config.Id
};
account.Token = GetToken(userId, config);
Add(account);
return(result);
}
/// <summary>
/// 更新配置的值
/// </summary>
/// <param name="value"></param>
public ServiceResult AddOrUpdate <T>(object value) where T : class, IReport
{
var report = Resolve <IReportService>().GetReport(typeof(T).FullName);
var typeclassProperty = typeof(T).GetTypeInfo().GetAttribute <ClassPropertyAttribute>();
if (typeclassProperty == null)
{
return(ServiceResult.FailedWithMessage("未设置ClassPropertyAttribute特性"));
}
if (report == null)
{
report = new Report {
// AppName = typeclassProperty.AppName,
Type = typeof(T).FullName,
Summary = typeclassProperty.Description.IsNullOrEmpty()
? typeclassProperty.Name
: typeclassProperty.Description
};
}
report.Value = value.ToJson();
report.LastUpdated = DateTime.Now;
AddOrUpdate(report);
return(ServiceResult.Success);
}
public ServiceResult InitTenantDatabase(string tenant)
{
if (!TenantContext.IsTenant)
{
return(ServiceResult.FailedWithMessage($"非租户模式不能创建租户 :isTenant:{HttpWeb.IsTenant} {HttpWeb.Host} fullName: {HttpWeb.FullDomain} host:{RuntimeContext.Current.WebsiteConfig.ClientHost}"));
}
if (string.IsNullOrWhiteSpace(tenant))
{
return(ServiceResult.FailedWithMessage("租户不能为空"));
}
var tenantName = RuntimeContext.GetTenantMongodbDataBase(tenant);
var isExists = _tenantCreateRepository.IsExistsDatabase(tenantName);
if (!isExists)
{
_tenantCreateRepository.CreateDatabase(tenantName);
}
isExists = _tenantCreateRepository.IsExistsDatabase(tenantName);
if (isExists == false)
{
return(ServiceResult.FailedWithMessage($"数据库创建失败，用户{RuntimeContext.Current.WebsiteConfig.MsSqlDbConnection.UserName}没有 CREATE DATABASE 权限，请手动添加数据库用户的 CREATE DATABASE 权限"));
}
return(ServiceResult.Success);
}
public ServiceResult InitTenantDefaultData(TenantInit tenantInit)
{
var result = Check(tenantInit);
if (!result.Succeeded)
{
return(result);
}
// 初始化站点信息
Resolve <ITenantService>().InitSite();
if (HttpWeb.Site == null)
{
return(ServiceResult.FailedWithMessage("站点信息初始化错误"));
}
//初始化默认数据
Resolve <IAdminService>().DefaultInit(tenantInit.IsTenant);
// 修改管理员的账号
var user = Resolve <IAlaboUserService>().GetSingle(r => r.UserName == "admin");
if (user != null)
{
user.Mobile = tenantInit.Mobile;
Resolve <IAlaboUserService>().Update(user);
}
return(ServiceResult.Success);
}
public ServiceResult Save(object model, AutoBaseModel autoModel)
{
var shareHolderView = (ShareHolderView)model;
var user = Resolve <IUserService>().GetSingle(u => u.UserName == shareHolderView.UserName);
var view = shareHolderView.MapTo <ShareHolder>();
if (user == null)
{
return(ServiceResult.FailedWithMessage("所属用户名不存在"));
}
var shareHolder = Resolve <IShareHolderService>().GetSingle(u => u.UserName == view.UserName);
if (shareHolder != null && shareHolderView.Id.IsNullOrEmpty())
{
return(ServiceResult.FailedWithMessage("该用户已是股东了"));
}
view.Id = shareHolderView.Id.ToObjectId();
view.UserId = user.Id;
var result = Resolve <IShareHolderService>().AddOrUpdate(view);
if (result)
{
return(ServiceResult.Success);
}
return(ServiceResult.FailedWithMessage("操作失败，请重试"));
}
/// <summary>
/// 发货 旧版 ,只支持一个快递号
/// 只更改订单状态
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ServiceResult Deliver(Deliver model)
{
var order = Resolve <IOrderService>().GetSingle(u => u.Id == model.OrderId);
if (order == null)
{
return(ServiceResult.FailedMessage("订单有误"));
}
if (order.OrderStatus != OrderStatus.WaitingSellerSendGoods)
{
return(ServiceResult.FailedWithMessage("只有待发货的商品可以发货"));
}
try
{
order.OrderStatus = OrderStatus.WaitingReceiptProduct;
Resolve <IOrderService>().Update(order);
Resolve <IDeliverService>().Add(model);
}
catch (Exception e)
{
return(ServiceResult.FailedWithMessage(e.ToString()));
}
return(ServiceResult.Success);
}
/// <summary>
/// Sets the value.
/// 根据前端页面表单HttpContext设置内容
/// </summary>
/// <param name="httpContext">The HTTP context.</param>
public ServiceResult SetValue(HttpContext httpContext)
{
var activityModule = AutoMapping.SetValue <GroupBuyActivity>(httpContext); // 活动模块
activityModule = JsonMapping.HttpContextToExtension <GroupBuyActivity>(activityModule, httpContext);
var priceSytles =
Resolve <IAutoConfigService>()
.GetList <PriceStyleConfig>(r => r.Status == Status.Normal); // 状态不正常的商品，可能不支持价格类型
var moneyTypes = Resolve <IAutoConfigService>().MoneyTypes(); // 所有货币类型
var productId = httpContext.Request.Form["ProductId"].ConvertToLong();
var product = Resolve <IProductService>().GetSingle(r => r.Id == productId);
if (product == null)
{
return(ServiceResult.FailedWithMessage("商品不存在"));
}
var priceStyleConfig = Resolve <IAutoConfigService>().GetList <PriceStyleConfig>()
.FirstOrDefault(r => r.Id == product.PriceStyleId);
if (product.MinCashRate == 0)
{
product.MinCashRate = priceStyleConfig.MinCashRate;
}
activityModule.SkuProducts.Foreach(r =>
{
r.GroupBuyDisplayPrice = Resolve <IProductAdminService>().Resolve <IProductService>()
.GetDisplayPrice(r.Price, priceStyleConfig.Id, priceStyleConfig.MinCashRate);
// 如果商品中有价格参数，则使员商品中的最小抵现价格
if (priceStyleConfig != null)
{
var moneyConfig = moneyTypes.FirstOrDefault(e => e.Id == priceStyleConfig.MoneyTypeId);
if (moneyConfig?.RateFee == 0)
{
moneyConfig.RateFee = 1;
}
// 如果不是现金商品
if (priceStyleConfig.PriceStyle != PriceStyle.CashProduct)
{
r.MinPayCash = Math.Round(r.Price * priceStyleConfig.MinCashRate, 2); // 最低可使用的现金资产
r.MaxPayPrice = Math.Round(r.Price * (1 - priceStyleConfig.MinCashRate) / moneyConfig.RateFee,
2); // 最高可使用的现金资产
}
else
{
r.MaxPayPrice = 0; // 现金商品，最高可使用的虚拟资产为0
r.MinPayCash = r.Price; //现金商品，最低使用的现金为价格
}
}
});
var result = ServiceResult.Success;
result.ReturnObject = activityModule;
return(result);
}
/// <summary>
/// 站点发布
/// </summary>
/// <param name="themePublish"></param>
/// <returns></returns>
public ServiceResult Publish(ThemePublish themePublish)
{
if (themePublish.Theme == null)
{
return(ServiceResult.FailedWithMessage("模板不能为空"));
}
//if (!themePublish.Tenant.Equals(HttpWeb.Tenant, StringComparison.CurrentCultureIgnoreCase)) {
// return ServiceResult.FailedWithMessage("租户设置错误");
//}
// 模板不存在则添加模板
var theme = Resolve <IThemeService>().GetSingle(r => r.Id == themePublish.Theme.Id);
if (theme == null)
{
// 和服务器ID模板一样
theme = new Theme();
theme.Id = themePublish.Theme.Id;
Resolve <IThemeService>().Add(theme);
}
theme = themePublish.Theme;
theme.UpdateTime = DateTime.Now;
if (!Resolve <IThemeService>().Update(theme))
{
return(ServiceResult.FailedWithMessage("模板更新失败"));
}
//修改默认模板
Resolve <IThemeService>().SetDefaultTheme(theme.Id);
var addList = new List <ThemePage>();
foreach (var themePage in themePublish.PageList)
{
addList.Add(themePage);
}
if (addList.Count > 0)
{
Resolve <IThemePageService>().DeleteMany(r => r.ThemeId == themePublish.Theme.Id);
Resolve <IThemePageService>().AddMany(addList);
}
// 清除缓存
var cacheKey = $"AllThemePageInfo_{themePublish.Theme.ClientType.ToString()}";
ObjectCache.Remove(cacheKey);
cacheKey = $"AllThemePageInfo_{theme.Type.ToStr()}_{theme.ClientType.ToStr()}";
ObjectCache.Remove(cacheKey);
cacheKey = $"AllThemePageInfo_{themePublish.Theme.Id.ToString()}";
ObjectCache.Remove(cacheKey);
return(ServiceResult.Success);
}
/// <summary>
/// check buy permission activity
/// </summary>
/// <param name="storeOrders"></param>
/// <param name="user"></param>
public ServiceResult CheckBuyPermissionActivity(IList <StoreOrderItem> storeOrders, User user)
{
var result = ServiceResult.Success;
//get order products
var orderProductCounts = GetOrderProducts(storeOrders);
var orderProductIds = orderProductCounts.Select(o => o.ProductId).ToList();
//get all activities
var currentOrderActivities = Resolve <IActivityApiService>()
.GetList(ProductActivityType.BuyPermission, orderProductIds).ToList();
if (currentOrderActivities.Count <= 0)
{
return(result);
}
var userProductCounts = Repository <IOrderProductRepository>().GetUserProductCount(user.Id, orderProductIds);
//loop proccess acitity
foreach (var item in currentOrderActivities)
{
//rule
var rules = item.Value.ToObject <BuyPermisionActivity>();
if (rules == null)
{
continue;
}
//order product count
var order = orderProductCounts.Find(p => p.ProductId == item.ProductId);
if (order == null)
{
continue;
}
//buy count
if (rules.SingleBuyCountMin > 0 && order.Count < rules.SingleBuyCountMin ||
rules.SingleBuyCountMax > 0 && order.Count > rules.SingleBuyCountMax)
{
return(ServiceResult.FailedWithMessage(
$"商品{order.ProductId}，最小购买数量为{rules.SingleBuyCountMin}件，最大购买数量为{rules.SingleBuyCountMax}件"));
}
//get current product buy count
var userProductCount = userProductCounts.Find(u => u.ProductId == order.ProductId);
var buyCount = userProductCount == null ? order.Count : order.Count + userProductCount.Count;
if (rules.TotalBuyCountMax > 0 && buyCount > rules.TotalBuyCountMax)
{
return(ServiceResult.FailedWithMessage($"您购买的数量超过了活动限购的数量，该商品限购{rules.TotalBuyCountMax}件"));
}
//member level permission
if (rules.MemberLeverBuyPermissions?.Count > 0 &&
!rules.MemberLeverBuyPermissions.Contains(user.GradeId))
{
return(ServiceResult.FailedWithMessage("您的会员等级不可以购买此等级限购商品，请升级后再试"));
}
}
return(result);
}
