418 lines
16 KiB
C#
418 lines
16 KiB
C#
using Hncore.Infrastructure.Common;
|
|
using Hncore.Infrastructure.EntitiesExtension;
|
|
using Hncore.Infrastructure.Extension;
|
|
using Hncore.Infrastructure.WebApi;
|
|
using Hncore.Pass.Vpn.Domain;
|
|
using Hncore.Pass.Vpn.Model;
|
|
using Hncore.Pass.Vpn.Request.Product;
|
|
using Hncore.Pass.Vpn.Service;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace Hncore.Pass.Vpn.Controllers
|
|
{
|
|
[ApiVersion("1.0")]
|
|
[Route("api/course/v{version:apiVersion}/productaccount/[action]")]
|
|
public class ProductAccountController : HncoreControllerBase
|
|
{
|
|
private ProductAccountService m_AccountService;
|
|
private UserService m_UserService;
|
|
private AgentService m_agentService;
|
|
private ProductPackageService m_PackageService;
|
|
private ProductService m_ProductService;
|
|
public ProductAccountController(ProductAccountService _AccountServic
|
|
, UserService _UserService
|
|
, AgentService _agentService
|
|
, ProductPackageService _PackageService
|
|
, ProductService _ProductService)
|
|
{
|
|
m_AccountService = _AccountServic;
|
|
m_UserService = _UserService;
|
|
m_agentService = _agentService;
|
|
m_PackageService = _PackageService;
|
|
m_ProductService = _ProductService;
|
|
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<ApiResult> Post([FromBody]ProductAccountEntity request)
|
|
{
|
|
request.TenantId = this.Request.GetManageUserInfo().TenantId;
|
|
await m_AccountService.Add(request);
|
|
return Success();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 修改
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<ApiResult> Put([FromBody]ProductAccountEntity request)
|
|
{
|
|
await m_AccountService.Update(request);
|
|
return Success();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<ApiResult> Delete([FromQuery]int id)
|
|
{
|
|
var account = await m_AccountService.Query(m => m.Id == id).FirstOrDefaultAsync();
|
|
account.DeleteTag = 1;
|
|
|
|
await m_AccountService.Update(account);
|
|
|
|
return Success();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<ApiResult> Deletes([FromBody] List<int> ids)
|
|
{
|
|
var data= m_AccountService.Query(m => ids.Contains(m.Id));
|
|
var flag = await m_AccountService.Deletes(data);
|
|
if (flag)
|
|
return Success();
|
|
else
|
|
return Error("删除失败");
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 详情
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
[HttpGet]
|
|
public async Task<ApiResult> Get([FromQuery]int id)
|
|
{
|
|
var data = await m_AccountService.GetById(id);
|
|
return Success(data);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 分页查询
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
[HttpGet]
|
|
public async Task<ApiResult> Page([FromQuery]AccountPageRequest request)
|
|
{
|
|
Expression<Func<ProductAccountEntity, bool>> expr = m => 1 == 1;
|
|
expr = expr.And(m => m.DeleteTag == 0);
|
|
if (request.UserId > 0)
|
|
{
|
|
expr = expr.And(m => m.UserId == request.UserId);
|
|
}
|
|
if (request.KeyWord.Has())
|
|
{
|
|
expr = expr.And(m => m.UserCode.Contains(request.KeyWord)
|
|
|| m.ProductName.Contains(request.KeyWord)
|
|
|| m.PackageName.Contains(request.KeyWord)
|
|
|| m.Account.Contains(request.KeyWord));
|
|
}
|
|
if (request.ProductIds != null && request.ProductIds.Count > 0)
|
|
{
|
|
expr = expr.And(m =>request.ProductIds.Contains((int)m.ProductId));
|
|
}
|
|
if (request.PackageNames != null && request.PackageNames.Count > 0)
|
|
{
|
|
expr = expr.And(m =>request.PackageNames.Contains((string)m.PackageName));
|
|
}
|
|
if (request.AccountTypes!=null&&request.AccountTypes.Count>0)
|
|
{
|
|
expr = expr.And(m => request.AccountTypes.Contains(m.AccountType));
|
|
}
|
|
if (request.BTime.HasValue && request.ETime.HasValue)
|
|
{
|
|
expr = expr.And(m => m.EndTime>=request.BTime&&m.EndTime<=request.ETime);
|
|
}
|
|
if (request.BkTime.HasValue && request.EkTime.HasValue)
|
|
{
|
|
expr = expr.And(m => m.StartTime>=request.BkTime&&m.StartTime<=request.EkTime);
|
|
}
|
|
if (request.ExpirdDay > -1)
|
|
{
|
|
if (request.ExpirdDay == 0)
|
|
{
|
|
expr = expr.And(m => m.EndTime.Value < DateTime.Now);
|
|
}
|
|
else
|
|
{
|
|
var startTime = DateTime.Now.Begin().AddDays(request.ExpirdDay);
|
|
startTime = startTime < DateTime.Now ? DateTime.Now : startTime;
|
|
var EndTime = DateTime.Now.End().AddDays(request.ExpirdDay);
|
|
expr = expr.And(m => m.EndTime >= startTime && m.EndTime <= EndTime);
|
|
}
|
|
// expr = expr.And(m => Math.Ceiling((m.EndTime - DateTime.Now).Value.TotalDays) == request.ExpirdDay);
|
|
}
|
|
var ret = await m_AccountService.PageDesc(request.PageIndex, request.PageSize, expr,true,m=>m.Id);
|
|
// ret.List.ForEach(
|
|
// m => {m.UserCode = "***";
|
|
// });
|
|
var data = ret.ToApiResult();
|
|
return data;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 分页查询
|
|
/// </summary>
|
|
/// <param name="request"></param>
|
|
/// <returns></returns>
|
|
[HttpGet]
|
|
public async Task<ApiResult> Search([FromQuery]AccountPageRequest request)
|
|
{
|
|
if (request.KeyWord.Has())
|
|
{
|
|
Expression<Func<ProductAccountEntity, bool>> expr = m => (m.Account== request.KeyWord||m.UserCode== request.KeyWord) && m.DeleteTag==0;
|
|
var ret = await m_AccountService.PageDesc(request.PageIndex, request.PageSize, expr, true, m => m.Id);
|
|
var data = ret.ToApiResult();
|
|
return data;
|
|
}
|
|
return Error("请输入关键字");
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 迁移
|
|
/// </summary>
|
|
/// <param name="id"></param>
|
|
/// <returns></returns>
|
|
[HttpPost]
|
|
public async Task<ApiResult> BindUser([FromBody]BindUserRequest request)
|
|
{
|
|
var entityList = await m_AccountService.Query(m => request.AccountIds.Contains(m.Id)).ToListAsync();
|
|
if (entityList == null|| entityList.Count==0)
|
|
return Error("没有选择账号");
|
|
var userEntity= await m_UserService.GetById(request.UserId);
|
|
if (userEntity == null)
|
|
return Error("会员不存在");
|
|
|
|
entityList.ForEach(entity =>
|
|
{
|
|
entity.UserId = request.UserId;
|
|
entity.UserCode = userEntity.LoginCode;
|
|
entity.UserPhone = userEntity.Phone;
|
|
});
|
|
|
|
await m_AccountService.Update(entityList);
|
|
return Success();
|
|
}
|
|
[HttpGet]
|
|
public async Task<ApiResult> GetOrginAccount([FromQuery]string accounts)
|
|
{
|
|
var accountList = await m_AccountService.GetAccounts(string.Join(",", accounts));
|
|
var originModel = await m_agentService.GetOriginAccounts(accountList);
|
|
return Success(originModel);
|
|
}
|
|
|
|
|
|
[HttpGet]
|
|
public async Task<ApiResult> UpdateOrginPwd([FromQuery]int productId, string account, string pwd)
|
|
{
|
|
var flag = await m_agentService.UpdateAccountPwd(productId, account, pwd);
|
|
if (flag)
|
|
return Success();
|
|
else
|
|
return Error("修改密码失败");
|
|
}
|
|
[HttpGet, UserAuth]
|
|
public async Task<ApiResult> ExistAccount([FromQuery]int productId, [FromQuery]string accounts)
|
|
{
|
|
var flag =await m_AccountService.CheckAccountExist(productId, accounts.Split(',').ToList());
|
|
if (flag)
|
|
{
|
|
return Error("账号已经存在");
|
|
}
|
|
return Success();
|
|
}
|
|
|
|
[HttpPost, UserAuth]
|
|
public async Task<ApiResult> CreateTestAccount([FromBody]CreateTestAccountRequest request)
|
|
{
|
|
if (request.Account.NotHas() || request.Pwd.NotHas())
|
|
{
|
|
return Error("账户和密码不能为空");
|
|
}
|
|
if (request.Account == request.Pwd)
|
|
{
|
|
return Error("账户和密码不能一致");
|
|
}
|
|
var userId = this.Request.GetUserInfo().UserId;
|
|
var packageEntity = await m_PackageService.GetById(request.PackageId);
|
|
if (packageEntity==null|| packageEntity.Status==0)
|
|
{
|
|
return Error("套餐不存在");
|
|
}
|
|
if (packageEntity.IsTest == 0)
|
|
{
|
|
return Error("非测试套餐");
|
|
}
|
|
|
|
var flag = await m_AccountService.CheckAccountExist(packageEntity.ProductId, new List<string> { request.Account });
|
|
if (flag)
|
|
{
|
|
return Error("账号已经存在");
|
|
}
|
|
var restTimes = await m_AccountService.GetRestTestCount(userId);
|
|
|
|
var is_verify = await m_AccountService.GetUserStatus(userId);
|
|
|
|
if (restTimes <= 0)
|
|
{
|
|
return Error("没有测试次数了");
|
|
}
|
|
|
|
if (is_verify == 0)
|
|
{
|
|
return Error("请点击前往实名认证");
|
|
}
|
|
|
|
|
|
var ret= await m_agentService.NewAccount(0, request.PackageId, request.Account, request.Pwd, accountType: 0);
|
|
|
|
if (ret.Code == ResultCode.C_SUCCESS)
|
|
{
|
|
var ProductEntity = await m_ProductService.GetById(packageEntity.ProductId);
|
|
var accountEntity = new ProductAccountEntity()
|
|
{
|
|
Account = request.Account,
|
|
AccountType = (int)AccountType.Test,
|
|
ConnectCount = 1,
|
|
StartTime = DateTime.Now,
|
|
EndTime = DateTime.Now.AddHours(packageEntity.DayCount),
|
|
PackageId = packageEntity.Id,
|
|
PackageName = packageEntity.Name,
|
|
ProductId = packageEntity.ProductId,
|
|
ProductName = ProductEntity.Name,
|
|
Pwd = request.Pwd,
|
|
ChargeStatus = AccountChargeStatus.Normal,
|
|
UserId = this.Request.GetUserInfo().UserId,
|
|
UserCode = this.Request.GetUserInfo().LoginName,
|
|
};
|
|
await m_AccountService.Add(accountEntity);
|
|
|
|
var userEntity = await m_UserService.GetById(userId);
|
|
userEntity.UseTestCount++;
|
|
await m_UserService.Update(userEntity);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 是否在线
|
|
/// </summary>
|
|
/// <param name="productId"></param>
|
|
/// <param name="account"></param>
|
|
/// <returns></returns>
|
|
// [UserAuth]
|
|
[AllowAnonymous]
|
|
public virtual async Task<ApiResult<List<OriginAccountOnlineModel>>> OnLine(int productId, string account)
|
|
{
|
|
return await m_agentService.OnLine(productId, account);
|
|
}
|
|
/// <summary>
|
|
/// 踢号
|
|
/// </summary>
|
|
/// <param name="productId"></param>
|
|
/// <param name="account"></param>
|
|
/// <returns></returns>
|
|
// [UserAuth]
|
|
[AllowAnonymous]
|
|
public virtual async Task<ApiResult> KillOut(int productId, string id)
|
|
{
|
|
return Success(await m_agentService.KillOut(productId, id));
|
|
}
|
|
|
|
[HttpGet]
|
|
public async Task<IActionResult> Export([FromQuery]AccountPageRequest request)
|
|
{
|
|
|
|
Expression<Func<ProductAccountEntity, bool>> expr = m => 1 == 1;
|
|
if (request.UserId > 0)
|
|
{
|
|
expr = expr.And(m => m.UserId == request.UserId);
|
|
}
|
|
if (request.KeyWord.Has())
|
|
{
|
|
expr = expr.And(m => m.Account.Contains(request.KeyWord));
|
|
}
|
|
if (request.ProductId.HasValue)
|
|
{
|
|
expr = expr.And(m => m.ProductId == request.ProductId);
|
|
}
|
|
if (request.PackageId.HasValue)
|
|
{
|
|
expr = expr.And(m => m.PackageId == request.PackageId);
|
|
}
|
|
if (request.AccountTypes != null && request.AccountTypes.Count > 0)
|
|
{
|
|
expr = expr.And(m => request.AccountTypes.Contains(m.AccountType));
|
|
}
|
|
if (request.ExpirdDay > -1)
|
|
{
|
|
if (request.ExpirdDay == 0)
|
|
{
|
|
expr = expr.And(m => m.EndTime.Value < DateTime.Now);
|
|
}
|
|
else
|
|
{
|
|
var startTime = DateTime.Now.Begin().AddDays(request.ExpirdDay);
|
|
startTime = startTime < DateTime.Now ? DateTime.Now : startTime;
|
|
var EndTime = DateTime.Now.End().AddDays(request.ExpirdDay);
|
|
expr = expr.And(m => m.EndTime >= startTime && m.EndTime <= EndTime);
|
|
}
|
|
// expr = expr.And(m => Math.Ceiling((m.EndTime - DateTime.Now).Value.TotalDays) == request.ExpirdDay);
|
|
}
|
|
var ret = await m_AccountService.PageDesc(request.PageIndex,10000, expr, true, m => m.Id);
|
|
|
|
var data = new ExcelData<ProductAccountEntity>
|
|
{
|
|
SheetName = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
Data = ret.List
|
|
};
|
|
|
|
var title = new List<ExcelTitle>(){
|
|
new ExcelTitle { Property = "UserCode", Title = "用户" },
|
|
new ExcelTitle { Property = "ProductName", Title = "产品" },
|
|
new ExcelTitle { Property = "PackageName", Title = "套餐" },
|
|
new ExcelTitle { Property = "Account", Title = "账号" },
|
|
new ExcelTitle { Property = "AccountType", Title = "类型" , Format=(val)=>((AccountType)val).GetEnumDisplayName() },
|
|
new ExcelTitle { Property = "ConnectCount", Title = "连接数"},
|
|
new ExcelTitle { Property = "StartTime", Title = "开通时间" , Format=(val)=>((DateTime) val).ToString("yyyy-MM-dd hh:mm:ss")},
|
|
new ExcelTitle { Property = "EndTime", Title = "到期时间" ,Format=(val)=>((DateTime) val).ToString("yyyy-MM-dd hh:mm:ss")},
|
|
new ExcelTitle { Property = "RestTime", Title = "剩余时间" },
|
|
};
|
|
var fileBytes = ExcelHelper.ExportListToExcel(data, title);
|
|
|
|
var fileName = $"{DateTime.Now.ToString("yyyyMMdd")}账号明细.xlsx";
|
|
Response.Headers.Add("X-Suggested-Filename", fileName.UrlEncode());
|
|
return File(fileBytes, "application/octet-stream", fileName);
|
|
|
|
}
|
|
|
|
}
|
|
}
|