public async Task <Result> Create([FromBody] CustomerAddressCreateRequest request)
{
var address = new AdminAddress
{
AreaCode = request.AreaCode,
CityCode = request.CityCode,
Createat = DateTime.Now,
DetailInfo = request.DetailInfo,
IsDefault = request.IsDefault,
PostalCode = request.PostalCode,
ProvinceCode = request.ProvinceCode,
TelNumber = request.TelNumber,
UserName = request.UserName
};
if (request.IsDefault)
{
var defaultAddress = await _addressRepository.Query().FirstOrDefaultAsync(e => e.IsDefault);
if (defaultAddress != null)
{
defaultAddress.IsDefault = false;
await _addressRepository.UpdateProperyAsync(defaultAddress, nameof(defaultAddress.IsDefault));
}
}
await _addressRepository.InsertAsync(address);
return(Result.Ok());
}
/// <summary>
/// 异常
/// </summary>
/// <param name="context"></param>
public async Task OnExceptionAsync(ExceptionContext context)
{
try
{
var exception = context.Exception;
var request = context.HttpContext.Request;
string ip = context.HttpContext.Connection.RemoteIpAddress.ToString();
string body = string.Empty;
string queryString = request.QueryString.Value;
if (request.Method.Equals("post", StringComparison.InvariantCultureIgnoreCase) ||
request.Method.Equals("put", StringComparison.InvariantCultureIgnoreCase))
{
if (request.ContentType.Equals("application/json", StringComparison.InvariantCultureIgnoreCase))
{
using (var mem = new MemoryStream())
{
using (var reader = new StreamReader(mem))
{
request.Body.Seek(0, SeekOrigin.Begin);
request.Body.CopyTo(mem);
mem.Seek(0, SeekOrigin.Begin);
body = reader.ReadToEnd();
}
}
}
}
var log = new ErrorLog()
{
Url = request.Path + request.QueryString,
Body = body,
Method = request.Method,
Message = exception.Message,
Detail = exception.StackTrace,
IpAddress = ip,
Createat = DateTime.Now
};
await _errorLogRepository.InsertAsync(log);
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex.StackTrace);
}
finally
{
await _adminUserManager.DevelopmentNotify();
//异常已处理
context.ExceptionHandled = true;
var result = new Result(ResultCodes.SysError);
#if DEBUG
result.ErrorMsg = context.Exception.Message;
#endif
// 返回异常的内容
context.Result = new ObjectResult(result);
}
}
public async Task <Result> Create(AdminCategoryCreateRequest request)
{
var category = new Category(request.Name, request.Sort);
await _categoryRepository.InsertAsync(category);
return(Result.Ok());
}
public async Task <Result> Create([FromBody] AdminGoodsOptionDataCreateRequest request)
{
var goodsOptionData = new GoodsOptionData(request.OptionId, request.Value, request.Description);
await _goodsOptionDataRepository.InsertAsync(goodsOptionData);
return(Result.Ok());
}
public async Task <Result> Create([FromBody] AdminGoodsOptionCreateRequest request)
{
var goodsOption = new GoodsOption(request.Name);
await _goodsOptionRepository.InsertAsync(goodsOption);
return(Result.Ok());
}
public async Task <Result> ConfirmApply([FromBody] AdminRefundConfirmApplyRequest request)
{
var returnApply = await _returnApplyRepository.Query()
.Include(e => e.OrderItem)
.FirstOrDefaultAsync(e => e.Id == request.Id);
if (returnApply == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (returnApply.Status != ReturnAuditStatus.NotAudit)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前申请不允许修改状态"));
}
var address = await _addressRepository.Query()
.Include(e => e.Province)
.Include(e => e.City)
.Include(e => e.Area)
.FirstOrDefaultAsync(e => e.Id == request.RefundAddressId);
if (address == null)
{
return(Result.Fail(ResultCodes.RequestParamError, "无效地址"));
}
var returnAddress = new ReturnAddress
{
ReturnApplyId = returnApply.Id,
AreaName = address.Area.Name,
CityName = address.City.Name,
Createat = DateTime.Now,
DetailInfo = address.DetailInfo,
PostalCode = address.PostalCode.ToString(),
ProvinceName = address.Province.Name,
Remarks = request.Remarks,
TelNumber = address.TelNumber,
UserName = address.UserName,
};
returnApply.Status = ReturnAuditStatus.Agree;
returnApply.AuditMessage = request.Remarks;
returnApply.AuditTime = DateTime.Now;
returnApply.OrderItem.Status = OrderItemStatus.ConfirmApply;
_returnApplyRepository.Update(returnApply, false);
using (var transaction = _returnApplyRepository.BeginTransaction())
{
await _returnApplyRepository.SaveAsync();
await _refundAddressRepository.InsertAsync(returnAddress);
transaction.Commit();
}
return(Result.Ok());
}
/// <summary>
/// 短信发送
/// </summary>
/// <returns></returns>
public async Task SendAsync(string tel, INotify notify)
{
if (string.IsNullOrEmpty(tel))
{
return;
}
var httpClient = _httpFactory.CreateClient();
var msg = notify.Execute();
var request = new Cloud253SmsRequest()
{
Account = _config.Account,
Password = _config.Password,
Phone = tel,
Msg = msg,
Report = true
};
var log = new SmsLog
{
Tel = tel,
Message = msg,
Createat = DateTime.Now
};
try
{
var context = new StringContent(JsonConvert.SerializeObject(request), Encoding.UTF8, "application/json");
using (var response = await httpClient.PostAsync(_config.Url, context))
{
if (response.IsSuccessStatusCode)
{
string jsonBody = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <Cloud243SmsResponse>(jsonBody);
log.Code = result.Code;
log.ErrorMsg = result.ErrorMsg;
log.Time = result.Time;
log.MsgId = result.MsgId;
}
await _smsLogRepository.InsertAsync(log);
}
}
catch (Exception ex)
{
_logger.LogError(ex.Message, ex);
}
}
public async Task <Result> Register([FromBody] AdminUserRegisterRequest request)
{
var user = await _adminUserRepository.Query().FirstOrDefaultAsync(e => e.Name == request.Name);
if (user != null)
{
return(Result.Fail(ResultCodes.UserExists));
}
var enctryPwd = request.Pwd.ToMD5Base64();
var adminUser = new AdminUser(request.Name, request.Name, enctryPwd, true, EmployeeRole.Admin, string.Empty);
await _adminUserRepository.InsertAsync(adminUser);
return(Result.Ok());
}
public async Task <Result> Create([FromBody] CustomerAddressCreateRequest request)
{
var userId = HttpContext.GetUserId();
var userAddress = new CustomerAddress(userId, request.IsDefault, request.PostalCode, request.ProvinceCode, request.CityCode, request.AreaCode, request.DetailInfo, request.TelNumber, request.UserName);
var defaultAddress = await _customerAddressRepository.Query().FirstOrDefaultAsync(e => e.CustomerId == userId && e.IsDefault);
if (defaultAddress != null)
{
defaultAddress.IsDefault = false;
await _customerAddressRepository.UpdateAsync(defaultAddress);
}
await _customerAddressRepository.InsertAsync(userAddress, false);
return(Result.Ok());
}
public async Task <Result> Create([FromBody] BankCardCreateRequest request)
{
var userId = HttpContext.GetUserId();
var bankCard = new BankCard
{
CustomerId = userId,
BankCode = request.BankCode,
BankNo = request.BankNo,
Createat = DateTime.Now,
Name = request.Name,
PhoneNumber = request.PhoneNumber
};
await _bankCardRepository.InsertAsync(bankCard);
return(Result.Ok());
}
private async Task LogRequest(HttpContext context, IRepositoryByInt <RequestResponseLog> repository)
{
var request = context.Request;
// var controllerActionDescriptor = context.GetEndpoint().Metadata.GetMetadata<ControllerActionDescriptor>();
// var controllerName = controllerActionDescriptor.ControllerName;
// var actionName = controllerActionDescriptor.ActionName;
var url = request.Path.ToString();
if (request.RouteValues.Count == 0)
{
return;
}
var log = new RequestResponseLog();
log.Url = url;
log.Method = request.Method;
log.Headers = JsonConvert.SerializeObject(request.Headers);
log.Createat = DateTime.Now;
if (request.Method.Equals("get", StringComparison.InvariantCultureIgnoreCase))
{
log.RequestBody = request.QueryString.Value;
}
else if (request.Method.Equals("post", StringComparison.InvariantCultureIgnoreCase) ||
request.Method.Equals("put", StringComparison.InvariantCultureIgnoreCase))
{
if (request.ContentType == "application/json")
{
var stream = request.Body;
stream.Seek(0, SeekOrigin.Begin);
var bytes = new byte[request.ContentLength.Value];
stream.Read(bytes, 0, bytes.Length);
log.RequestBody = Encoding.UTF8.GetString(bytes);
stream.Seek(0, SeekOrigin.Begin);
}
}
await repository.InsertAsync(log);
}
public async Task<Result> Create([FromBody] AdminEmployeeCreateRequest request)
{
var anyName = await _repository.Query().AnyAsync(e => e.Name == request.Name || e.Tel == request.Tel);
if (anyName) return Result.Fail(ResultCodes.UserExists, "用户名或手机号已存在");
var user = new AdminUser
{
Name = request.Name,
Createat = DateTime.Now,
IsAdmin = false,
NickName = request.NickName,
Role = request.Role,
Tel = request.Tel,
Pwd = request.Pwd.ToMD5Base64()
};
await _repository.InsertAsync(user);
return Result.Ok();
}
public async Task <Result> Create([FromBody] AdminPartnerApplyCreateRequest request)
{
var anyPartnerType = _partnerApplyRepository.Query().Any(e => e.PartnerRole == request.PartnerRole);
if (anyPartnerType)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前合伙人类型已设置申请条件"));
}
if (request.Goods == null || request.Goods.Count == 0)
{
return(Result.Fail(ResultCodes.RequestParamError, "请选择商品"));
}
if (request.TotalAmount == 0)
{
return(Result.Fail(ResultCodes.RequestParamError, "总金额不能为0"));
}
var partnerApply = new PartnerApply
{
OriginalPrice = request.OriginalPrice,
TotalAmount = request.TotalAmount,
ApplyType = PartnerApplyType.Default,
PartnerRole = request.PartnerRole,
TotalQuantity = request.TotalQuantity,
RepurchaseCommissionRatio = request.ReferralCommissionRatio,
ReferralCommissionRatio = request.RepurchaseCommissionRatio,
Createat = DateTime.Now,
};
var partnerApplyGoods = new List <PartnerApplyGoods>();
foreach (var goods in request.Goods)
{
partnerApplyGoods.Add(new PartnerApplyGoods(goods.GoodsId, goods.Quantity, goods.Price));
}
partnerApply.PartnerApplyGoods = partnerApplyGoods;
await _partnerApplyRepository.InsertAsync(partnerApply);
return(Result.Ok());
}
public async Task <Result> Billing(OrderBillingRequest request)
{
var billing = await _orderBillingRepository.Query().FirstOrDefaultAsync(e => e.OrderId == request.OrderId);
if (billing != null)
{
return(Result.Fail(ResultCodes.RequestParamError, "开票申请已提交，无法重复申请。"));
}
var anyOrder = await _orderRepository.Query().AnyAsync(e => e.Id == request.OrderId);
if (!anyOrder)
{
return(Result.Fail(ResultCodes.IdInvalid, "订单不存在"));
}
billing = new OrderBilling
{
OrderId = request.OrderId,
BankAccount = request.BankAccount,
BankName = request.BankName,
CompanyAddress = request.CompanyAddress,
Email = request.Email,
IsInvoiced = false,
TaxNumber = request.TaxNumber,
TelePhone = request.TelePhone,
Title = request.Title,
Createat = DateTime.Now,
};
await _orderBillingRepository.InsertAsync(billing);
await _adminUserManager.AccountingNotify(new BillingNotify
{
Title = request.Title
});
return(Result.Ok());
}
public async Task <Result> Upload(IFormFile file)
{
// string imgUrl = string.Empty;
if (file == null)
{
return(Result.Fail(ResultCodes.RequestParamError));
}
DateTime now = DateTime.Now;
string extension = ".jpg";//Path.GetExtension(file.FileName);
string name = Guid.NewGuid().ToString("N");
string folder = now.ToString("yyyyMMdd");
string originalName = name + "_original" + extension;
string compressionName = name + extension;
string originalPath = Path.Combine(PRODUCT_IMAGE_PATH, folder, originalName);
string compressionPath = Path.Combine(PRODUCT_IMAGE_PATH, folder, compressionName);
string originaPhysicalPath = Path.Combine(_environment.WebRootPath, originalPath);
string compressionPhysicalPath = Path.Combine(_environment.WebRootPath, compressionPath);
FileHelper.CreateImgFolder(compressionPhysicalPath);
using (Stream mStream = new FileStream(originaPhysicalPath, FileMode.Create))
{
await file.CopyToAsync(mStream);
//Bitmap srcBitmap = new Bitmap(stream);
//ImageHelper.Compress(srcBitmap, Path.Combine(imageDir, fileName), 50);
}
SixLaborsImageSharpHelper.Compress(originaPhysicalPath, compressionPhysicalPath, 50);
var media = new Media(compressionPath, file.ContentType, file.Length);
await _mediaRepository.InsertAsync(media);
// 返回完整地址
media.Url = _accessor.HttpContext.Request.GetHostUrl() + "/" + media.Url;
return(Result.Ok(_mapper.Map <MediaResponse>(media)));
}
/// <summary>
/// 修改资产
/// </summary>
/// <param name="assets"></param>
/// <param name="commission"></param>
/// <param name="amount"></param>
/// <param name="repurchase"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task UpdateAssets(Assets assets, int commission, int amount, int repurchase, string message)
{
assets.AvailableAmount += amount;
assets.TotalCommission += commission;
assets.RepurchaseAmount += repurchase;
assets.TotalAssets = assets.AvailableAmount + assets.RepurchaseAmount;
assets.UpdateTime = DateTime.Now;
await _assetsRepository.UpdateAsync(assets);
if (amount != 0)
{
var history = new AssetsHistory
{
CustomerId = assets.CustomerId,
TotalAmount = assets.AvailableAmount,
Amount = amount,
Createat = DateTime.Now,
Message = message
};
await _assetsHistoryRepository.InsertAsync(history);
}
}
public async Task <Result> Save(AdminLiteAppSaveRequest request)
{
var setting = await _repository.Query().FirstOrDefaultAsync();
if (setting == null)
{
setting = new LiteAppSetting
{
CityMembershipRights = request.CityMembershipRights,
BranchMembershipRights = request.BranchMembershipRights,
Createat = DateTime.Now
};
await _repository.InsertAsync(setting);
}
else
{
setting.CityMembershipRights = request.CityMembershipRights;
setting.BranchMembershipRights = request.BranchMembershipRights;
await _repository.UpdateAsync(setting);
}
return(Result.Ok());
}
public async Task <Result> LiteAppLogin([FromBody] WeChatLiteAppLoginRequest request)
{
string errorMsg = string.Empty;
try
{
JsCode2JsonResult jsonResult = SnsApi.JsCode2Json(WechatService.WxOpenAppId, WechatService.WxOpenAppSecret, request.Code);
if (jsonResult != null && jsonResult.errcode == ReturnCode.请求成功)
{
var customer = await _customerRepository.Query()
.FirstOrDefaultAsync(e => e.OpenId == jsonResult.openid);
if (customer == null)
{
int?parentId = null;
var anyParent = await _customerRepository.Query().AnyAsync(e => e.Id == request.ParentId);
if (anyParent)
{
parentId = request.ParentId;
}
var userInfo = request.UserInfo;
customer = new Customer
{
NickName = userInfo.NickName,
OpenId = jsonResult.openid,
SessionKey = jsonResult.session_key,
UnionId = jsonResult.unionid,
Gender = userInfo.Gender,
Country = userInfo.Country,
Province = userInfo.Province,
City = userInfo.City,
AvatarUrl = userInfo.AvatarUrl,
Language = userInfo.Language,
ParentId = parentId,
Createat = DateTime.Now,
Assets = new Assets()
{
TotalAssets = 0,
AvailableAmount = 0,
TotalCommission = 0,
UpdateTime = DateTime.Now,
Createat = DateTime.Now
}
};
await _customerRepository.InsertAsync(customer);
if (parentId.HasValue)
{
await _mediator.Publish(new CustomerRelationEvent
{
ParentId = request.ParentId,
ChildrenId = customer.Id
});
}
}
else
{
if (!customer.ParentId.HasValue && request.ParentId > 0)
{
var anyParent = await _customerRepository.Query().AnyAsync(e => e.Id == request.ParentId);
if (anyParent)
{
customer.ParentId = request.ParentId;
await _mediator.Publish(new CustomerRelationEvent
{
ParentId = request.ParentId,
ChildrenId = customer.Id
});
}
}
if (customer.SessionKey != jsonResult.session_key)
{
customer.SessionKey = jsonResult.session_key;
await _customerRepository.UpdateProperyAsync(customer, nameof(customer.SessionKey), nameof(customer.ParentId));
}
}
List <Claim> claims = new List <Claim>();
claims.Add(new Claim("id", customer.Id.ToString()));
// claims.Add(new Claim("openId", customer.OpenId));
var token = _tokenService.JwtToken(claims);
var customerRes = _mapper.Map <CustomerResponse>(customer);
return(Result.Ok(new WeChatLiteAppLoginResponse(token, customerRes)));
}
}
catch (Exception ex)
{
errorMsg = ex.Message;
}
return(Result.Fail(ResultCodes.RequestParamError, errorMsg));
}
