public async Task <Result> ResetPwd([FromBody] AdminForgetResetPwdRequest request)
{
var user = await _adminUserRepository.Query().FirstOrDefaultAsync(e => e.Tel == request.Tel);
if (user == null)
{
return(Result.Fail(ResultCodes.UserNotExists));
}
var code = HttpContext.Session.GetString(request.Tel);
if (string.IsNullOrEmpty(code))
{
return(Result.Fail(ResultCodes.RequestParamError, "验证码已过期或未获取验证码"));
}
if (!request.Code.Equals(code, System.StringComparison.InvariantCultureIgnoreCase))
{
return(Result.Fail(ResultCodes.RequestParamError, "验证码不正确"));
}
user.Pwd = request.Password.ToMD5Base64();
await _adminUserRepository.UpdateAsync(user);
HttpContext.Session.Remove(request.Tel);
return(Result.Ok());
}
public async Task <Result> List([FromQuery] AdminGoodsListQueryRequest request)
{
var page = request.Page;
var limit = request.Limit;
if (page <= 0)
{
page = 1;
}
if (limit <= 0)
{
limit = 10;
}
var queryable = _goodsRepository.Query()
.Include(e => e.ThumbnailImage)
.Where(e => e.IsVisible == false);
if (!string.IsNullOrEmpty(request.Name))
{
queryable = queryable.Where(e => e.Name.Contains(request.Name));
}
if (request.IsPublished.HasValue)
{
queryable = queryable.Where(e => e.IsPublished == request.IsPublished.Value);
}
var totalRows = await queryable.CountAsync();
var goodses = await queryable.OrderByDescending(e => e.Id).Skip((page - 1) * limit).Take(limit).ToListAsync();
var pagination = new PaginationResponse(page, totalRows, _mapper.Map <List <AdminGoodsListResponse> >(goodses));
return(Result.Ok(pagination));
}
public async Task <Result> List([FromQuery] AdminPartnerApplyListRequest request)
{
var page = request.Page;
var limit = request.Limit;
if (page <= 0)
{
page = 1;
}
if (limit <= 0)
{
limit = 10;
}
var queryable = _partnerApplyRepository.Query();
if (request.PartnerRole != null)
{
queryable = queryable.Where(e => e.PartnerRole == request.PartnerRole);
}
var totalRows = await queryable.CountAsync();
var partnerApplys = await queryable.OrderByDescending(e => e.Id).Skip((page - 1) * limit).Take(limit).ToListAsync();
var pagination = new PaginationResponse(page, totalRows, _mapper.Map <List <AdminPartnerApplyListResponse> >(partnerApplys));
return(Result.Ok(pagination));
}
public async Task <Result> GetAll([FromQuery] string nickName)
{
var customers = new List <Customer>();
if (!string.IsNullOrEmpty(nickName))
{
customers = await _customerRepository.Query().Where(e => e.NickName.Contains(nickName)).ToListAsync();
}
return(Result.Ok(_mapper.Map <List <CustomerResponse> >(customers)));
}
public async Task <Result> Get()
{
var setting = await _repository.Query().FirstOrDefaultAsync();
if (setting == null)
{
setting = new LiteAppSetting();
}
return(Result.Ok(setting));
}
public async Task<Result> List([FromQuery] PaginationRequest request)
{
var queryable = _repository.Query();
var totalRows = await queryable.CountAsync();
var users = await queryable.OrderByDescending(e => e.Id)
.Skip((request.Page - 1) * request.Limit).Take(request.Limit)
.ToListAsync();
return Result.Ok(new PaginationResponse(request.Page, totalRows, _mapper.Map<List<AdminEmployeeResponse>>(users)));
}
public async Task <Result> List()
{
var userId = HttpContext.GetUserId();
var userAddresses = await _customerAddressRepository.Query()
.Include(e => e.Province)
.Include(e => e.City)
.Include(e => e.Area)
.Where(e => e.CustomerId == userId)
.OrderByDescending(e => e.Id).ToListAsync();
return(Result.Ok(_mapper.Map <List <CustomerAddressResponse> >(userAddresses)));
}
public async Task <Result> Get(int id)
{
var userId = HttpContext.GetUserId();
var item = await _orderItemRepository.Query()
.Include(e => e.ReturnApply).ThenInclude(e => e.ReturnAddress)
// .Where(e => e.Order.CustomerId == userId && e.RefundStatus != RefundStatus.Default)
.FirstOrDefaultAsync(e => e.Id == id);
if (item == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
return(Result.Ok(_mapper.Map <RefundGetResponse>(item)));
}
public async Task <Result> List([FromQuery] AdminCategoryQueryRequest request)
{
var page = request.Page;
var limit = request.Limit;
if (page <= 0)
{
page = 1;
}
if (limit <= 0)
{
limit = 10;
}
var queryable = _categoryRepository.Query();
if (!string.IsNullOrEmpty(request.Name))
{
queryable = queryable.Where(e => e.Name.Contains(request.Name));
}
var totalRows = await queryable.CountAsync();
var categorys = await queryable.Skip((page - 1) *limit).Take(limit).OrderByDescending(e => e.Id).ToListAsync();
return(Result.Ok(new PaginationResponse(page, totalRows, _mapper.Map <List <AdminCategoryResponse> >(categorys))));
}
public async Task <Result> Condition(PartnerRole role)
{
var partnerApply = await _partnerApplyRepository.Query()
.Include(e => e.PartnerApplyGoods).ThenInclude(e => e.Goods).ThenInclude(e => e.ThumbnailImage)
.FirstOrDefaultAsync(e => e.PartnerRole == role);
return(Result.Ok(_mapper.Map <PartnerApplyConditionResponse>(partnerApply)));
}
public async Task <Result> History([FromQuery] AdminWithdrawalHistoryRequest request)
{
var queryable = _withdrawalHistoryRepository.Query();
if (request.CustomerId.HasValue)
{
queryable = queryable.Where(e => e.CustomerId == request.CustomerId.Value);
}
var totalRows = await queryable.CountAsync();
var histores = await queryable
.OrderByDescending(e => e.Id)
.Skip((request.Page - 1) * request.Limit).Take(request.Limit)
.ToListAsync();
return(Result.Ok(new PaginationResponse(request.Page, totalRows, _mapper.Map <List <WithdrawalHistoryResponse> >(histores))));
}
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());
}
public async Task <Result> List([FromQuery] AdminShipmentListRequest request)
{
var queryable = _shipmentRepository.Query();
if (request.Status.HasValue)
{
queryable = queryable.Where(e => e.ShippingStatus == request.Status.Value);
}
var totalRows = await queryable.CountAsync();
var shipments = await queryable.Include(e => e.ShippingAddress)
.OrderByDescending(e => e.Id)
.Skip((request.Page - 1) * request.Limit).Take(request.Limit)
.ToListAsync();
return(Result.Ok(new PaginationResponse(request.Page, totalRows, _mapper.Map <List <AdminShipmentListResponse> >(shipments))));
}
public async Task <Result> List([FromQuery] AdminOrderListRequest request)
{
var queryable = _orderRepository.Query();
if (request.CustomerId.HasValue)
{
queryable = queryable.Where(e => e.CustomerId == request.CustomerId.Value);
}
if (!string.IsNullOrEmpty(request.OrderNo))
{
queryable = queryable.Where(e => e.OrderNo == request.OrderNo);
}
if (request.Status.HasValue)
{
queryable = queryable.Where(e => e.OrderStatus == request.Status.Value);
}
var totalRows = await queryable.CountAsync();
var orders = await queryable.OrderByDescending(e => e.Id)
.Skip((request.Page - 1) * request.Limit).Take(request.Limit)
.Select(e => new AdminOrderListResponse
{
Id = e.Id,
AvatarUrl = e.Customer.AvatarUrl,
NickName = e.Customer.NickName,
Createat = e.Createat,
OrderNo = e.OrderNo,
OrderStatus = e.OrderStatus,
PaymentFee = e.PaymentFee,
PaymentMethod = e.PaymentMethod,
PaymentTime = e.PaymentTime,
PaymentType = e.PaymentType,
TotalFee = e.TotalFee,
ActuallyAmount = e.ActuallyAmount,
WalletAmount = e.WalletAmount
})
.ToListAsync();
return(Result.Ok(new PaginationResponse(request.Page, totalRows, orders)));
}
public async Task <Result> ErrorList([FromQuery] PaginationRequest request)
{
var queryable = _errorLogRepository.Query();
var totalRows = await queryable.CountAsync();
var errores = await queryable.OrderByDescending(e => e.Id)
.Skip((request.Page - 1) * request.Limit).Take(request.Limit)
.ToListAsync();
return(Result.Ok(new PaginationResponse(request.Page, totalRows, _mapper.Map <List <AdminLogErrorListResponse> >(errores))));
}
/// <summary>
/// 执行前
/// </summary>
/// <param name="context"></param>
public override void OnActionExecuting(ActionExecutingContext context)
{
var quantity = _adminUserRepository.Query().Count();
if (quantity > 0)
{
context.Result = new ObjectResult(Result.Fail(ResultCodes.NotRegister));
return;
}
base.OnActionExecuting(context);
}
public async Task <Result> Assets()
{
var userId = HttpContext.GetUserId();
var assets = await _assetsRepository.Query().FirstOrDefaultAsync(e => e.CustomerId == userId);
if (assets == null)
{
assets = new Assets();
}
return(Result.Ok(_mapper.Map <AssetsResponse>(assets)));
}
public async Task <Result> AssetsHistory([FromQuery] PaginationRequest request)
{
var userId = HttpContext.GetUserId();
var queryable = _assetsHistoryRepository.Query().Where(e => e.CustomerId == userId);
var totalRows = await queryable.CountAsync();
var historys = await queryable.OrderByDescending(e => e.Id)
.Skip((request.Page - 1) * request.Limit).Take(request.Limit)
.ToListAsync();
return(Result.Ok(new PaginationResponse(request.Page, totalRows, _mapper.Map <List <CustomerAssetsHistoryResponse> >(historys))));
}
public async Task <Result> List([FromQuery] PaginationRequest request)
{
var queryable = _orderBillRepository.Query().Where(e => !e.IsInvoiced);
var totalRows = await queryable.CountAsync();
var billings = await queryable.OrderByDescending(e => e.Id)
.Skip((request.Page - 1) * request.Limit)
.Take(request.Limit)
.ToListAsync();
return(Result.Ok(new PaginationResponse(request.Page, totalRows, _mapper.Map <List <AdminOrderBillingResponse> >(billings))));
}
public async Task <Result> DataStatistics()
{
// 总销售额
var totalSales = await _orderRepository.Query().Where(e => e.OrderStatus >= OrderStatus.PaymentReceived).SumAsync(e => e.PaymentFee);
// 总订单数
var totalOrders = await _orderRepository.Query().Where(e => e.OrderStatus >= OrderStatus.PaymentReceived).CountAsync();
// 待发货
var pendingShipmentCount = await _shipmentRepository.Query().Where(e => e.ShippingStatus == ShippingStatus.PendingShipment).CountAsync();
// 总合伙人数
var totalCustomer = await _customerRepository.Query().Where(e => e.Role > PartnerRole.Default).CountAsync();
return(Result.Ok(new AdminHomeDataStatisticsResponse
{
TotalCustomer = totalCustomer,
PendingShipmentCount = pendingShipmentCount,
TotalOrders = totalOrders,
TotalSales = totalSales
}));
}
public async Task <Result> List([FromQuery] PaginationRequest request)
{
var queryable = _returnApplyRepository.Query();
var totalRows = await queryable.CountAsync();
var refundItems = await queryable
.OrderByDescending(e => e.Id)
.Skip((request.Page - 1) * request.Limit).Take(request.Limit)
.Select(e => new AdminRefundListResponse
{
Id = e.Id,
AuditTime = e.AuditTime,
Createat = e.Createat,
Status = e.Status,
RefundAmount = e.RefundAmount,
CustomerId = e.CustomerId,
CustomerName = e.Customer.NickName,
AvatarUrl = e.Customer.AvatarUrl,
})
.ToListAsync();
return(Result.Ok(new PaginationResponse(request.Page, totalRows, refundItems)));
}
public async Task <Result> List([FromQuery] ShipmentListRequest request)
{
var page = request.Page;
var limit = request.Limit;
if (page <= 0)
{
page = 1;
}
if (limit <= 0)
{
limit = 10;
}
var userId = HttpContext.GetUserId();
var queryable = _shipmentRepository.Query().Where(e => e.CustomerId == userId);
if (request.Status == ShippingStatus.Complete)
{
queryable = queryable.Where(e => e.ShippingStatus == request.Status);
}
else
{
queryable = queryable.Where(e => e.IsValid && e.ShippingStatus >= ShippingStatus.PendingShipment && e.ShippingStatus < ShippingStatus.Complete);
}
var totalRows = await queryable.CountAsync();
var shipments = await queryable.Include(e => e.ShipmentOrderItems).ThenInclude(e => e.OrderItem)
.OrderByDescending(e => e.Id)
.Skip((page - 1) * limit).Take(limit)
.ToListAsync();
return(Result.Ok(new PaginationResponse(page, totalRows, _mapper.Map <List <ShipmentListResponse> >(shipments))));
}
public async Task <Result> All()
{
var addresses = await _addressRepository.Query()
.Include(e => e.Province)
.Include(e => e.City)
.Include(e => e.Area)
.ToListAsync();
return(Result.Ok(_mapper.Map <List <CustomerAddressResponse> >(addresses)));
}
public async Task <Result> Team([FromQuery] PaginationRequest request)
{
var userId = HttpContext.GetUserId();
var queryable = _customerRelationRepository.Query().Where(e => e.ParentId == userId);
var totalRows = await queryable.CountAsync();
var teams = await queryable.Include(e => e.Children).ThenInclude(e => e.Assets)
.OrderByDescending(e => e.Id)
.Skip((request.Page - 1) * request.Limit).Take(request.Limit)
.Select(e => e.Children)
.ToListAsync();
return(Result.Ok(new PaginationResponse(request.Page, totalRows, _mapper.Map <List <CustomerTeamResponse> >(teams))));
}
public async Task <Result> List()
{
var userId = HttpContext.GetUserId();
var bankCards = await _bankCardRepository.Query().Where(e => e.CustomerId == userId).ToListAsync();
var responses = _mapper.Map <List <BankCardResponse> >(bankCards);
foreach (var item in responses)
{
item.BankNo = Regex.Replace(item.BankNo, @"(\w{4})\d{10}(\w{4})", "$1*****$2");
item.BankName = BankHelper.GetBankName(item.BankCode);
}
return(Result.Ok(responses));
}
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());
}
private async Task SmsNotify(INotify notify, params EmployeeRole[] roles)
{
var employeeTels = await _adminUserRepository.Query()
.Where(e => roles.Contains(e.Role))
.Select(e => e.Tel)
.ToListAsync();
if (employeeTels.Count > 0)
{
var notifyEvent = new SmsNotifyEvent
{
Tels = employeeTels,
Message = notify
};
await _mediator.Publish(notifyEvent);
}
}
public async Task <Result> Agree(int id)
{
var apply = await _withdrawalHistoryRepository.FirstOrDefaultAsync(id);
if (apply == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
if (apply.Status != WithdrawalStatus.Apply)
{
return(Result.Fail(ResultCodes.RequestParamError, "当前申请状态不允许确认"));
}
var openId = await _custoemrRepository.Query()
.Where(e => e.Id == apply.CustomerId)
.Select(e => e.OpenId)
.FirstOrDefaultAsync();
apply.Status = WithdrawalStatus.Success;
apply.Message = "提现成功";
var wxRequest = new WeChatPayPromotionTransfersRequest
{
PartnerTradeNo = apply.PartnerTradeNo,
OpenId = openId,
CheckName = "FORCE_CHECK",// "NO_CHECK"
ReUserName = apply.Name,
Amount = apply.Amount,
Desc = "提现"
};
var response = await _client.ExecuteAsync(wxRequest, _weChatPayOptions);
if (response.ReturnCode != WeChatPayCode.Success || response.ResultCode != WeChatPayCode.Success)
{
apply.Status = WithdrawalStatus.Failed;
apply.Message = "提现异常，请重新申请";
apply.Description = response.ErrCodeDes;
await _customerManager.UpdateAssets(apply.CustomerId, 0, apply.Total, -apply.ReservedAmount, "提现失败返回金额");
}
await _withdrawalHistoryRepository.UpdateAsync(apply);
return(Result.Ok());
}
public async Task <Result> Query(int id)
{
var shipment = await _shipmentRepository.Query().Include(e => e.ShippingAddress).FirstOrDefaultAsync(e => e.Id == id);
if (shipment == null)
{
return(Result.Fail(ResultCodes.IdInvalid));
}
var tel = shipment.ShippingAddress.TelNumber;
var courierCompany = shipment.CourierCompany;
var courierCompanyCode = shipment.CourierCompanyCode;
// if (string.IsNullOrEmpty(courierCompanyCode)) return Result.Fail(ResultCodes.RequestParamError, "快递公司编码参数无效");
var trackingNumber = shipment.TrackingNumber;
// if (string.IsNullOrEmpty(trackingNumber)) return Result.Fail(ResultCodes.RequestParamError, "快递单号无效");
var response = await ShippingQuery(id, tel, courierCompany, courierCompanyCode, trackingNumber);
return(Result.Ok(response));
}
public async Task <Result> GetMembershipRights()
{
var user = await _customerManger.GetUserAsync();
var setting = await _repository.Query().FirstOrDefaultAsync();
var content = string.Empty;
if (user.Role == PartnerRole.CityPartner)
{
content = setting.CityMembershipRights;
}
else
{
content = setting.BranchMembershipRights;
}
return(Result.Ok(content));
}
