ICM-WCS/wcs
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

!提交代码

Browse Source
This commit is contained in:
hehaibing-1996
2024-04-15 18:43:28 +08:00
commit e89b64ea3a
232 changed files with 22292 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
WCS.BLL/Services/IService/IHomerService.cs Normal file
View File

@ -0,0 +1,8 @@

namespace WCS.BLL.Services.IService
{
public interface IHomerService
{
}
}

17
WCS.BLL/Services/IService/IInstoreService.cs Normal file
View File

@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.Model;
namespace WCS.BLL.Services.IService
{
public interface IInstoreService
{
public ResponseBase shelfGoInInStore(ShelfGoInInstoreRequest request);
public ResponseBase shelfGoOutInStore(ShelfGoOutInStoreRequest request);
public ResponseBase queryByMatSn(QueryByMatSnRequest request);
public Task<ResponseBase> queryInstoreStatus(QueryByMatSnRequest request);
}
}

17
WCS.BLL/Services/IService/IInterfaceRecordService.cs Normal file
View File

@ -0,0 +1,17 @@

using WCS.BLL.DbModels;
using WCS.DAL.AuthDbModel;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.IService
{
public interface IInterfaceRecordService
{
public Task<PageQueryResponse<SystemApiLogRecord>> getInterfaceRecord(GetInterfaceRecordsRequest request);
public Task<PageQueryResponse<SystemApiLogRecord>> exportInterfaceRecord(GetInterfaceRecordsRequest request);
}
}

26
WCS.BLL/Services/IService/IMatBaseInfoService.cs Normal file
View File

@ -0,0 +1,26 @@

using WCS.BLL.DbModels;
using WCS.DAL.AuthDbModel;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.MatBaseInfo;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.IService
{
public interface IMatBaseInfoService
{
public Task<PageQueryResponse<MatBaseInfo>> getMatBaseInfo(GetMatBaseInfoRequest request);
public Task<PageQueryResponse<MatBaseInfo>> exportMatBaseInfo(GetMatBaseInfoRequest request);
public Task<ResponseCommon<List<string>>> importMatBaseInfo(List<MatBaseInfoImportModel> lists,string userName,string deviceType);
public Task<ResponseCommon<object>> addOrUpdateMatBaseInfo(AddMatBaseInfoRequest<MatBaseInfo> request);
public Task<ResponseCommon<object>> deleteMatBaseInfo(DeleteMatBaseInfosRequest request);
public Task<ResponseCommon<List<string>>> getMatCodeList(GetMatCodeListRequest request);
}
}

18
WCS.BLL/Services/IService/IMatInventoryDetailService.cs Normal file
View File

@ -0,0 +1,18 @@

using WCS.BLL.DbModels;
using WCS.DAL.AuthDbModel;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.MatInventoryDetail;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.IService
{
public interface IMatInventoryDetailService
{
public Task<PageQueryResponse<InventoryDetail>> getMatInventoryDetail(GetMatInventoryDetailRequest request);
public Task<PageQueryResponse<InventoryDetail>> exportMatInventoryDetail(GetMatInventoryDetailRequest request);
}
}

24
WCS.BLL/Services/IService/IOutstoreService.cs Normal file
View File

@ -0,0 +1,24 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.Model;
namespace WCS.BLL.Services.IService
{
public interface IOutstoreService
{
public Task<ResponseBase> SysOutOrderByMatCode(SysOutOrderByMatCodeRequest request);
public Task<ResponseBase> SysOutOrderByMatSn(SysOutOrderByMatSnRequest request);
public Task<ResponseBase> GetOutOrderList(GetOutOrderListRequest request);
public Task<ResponseBase> GetOutOrderDetail(GetOutOrderDetailRequest request);
public Task<ResponseBase> GoInOutstore(GetOutOrderDetailRequest request);
public Task<ResponseBase> GoOutOutstore(GetOutOrderDetailRequest request);
}
}

31
WCS.BLL/Services/IService/IStoreInfoService.cs Normal file
View File

@ -0,0 +1,31 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.DAL.AuthDbModel;
using WCS.Model.ApiModel.User;
using WCS.Model;
using WCS.DAL.DbModels;
using WCS.Model.ApiModel.StoreInfo;
using WCS.BLL.DbModels;
using WCS.Model.ApiModel.MatBaseInfo;
namespace WCS.BLL.Services.IService
{
public interface IStoreInfoService
{
/// <summary>
/// 查询货架列表
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Task<PageQueryResponse<ShelfInfo>> GetShelves(GetShelvesRequest request);
/// <summary>
/// 添加、更新、删除货架
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public Task<ResponseCommon<object>> addOrUpdateShelfInfo(AddShelfInfoRequest<ShelfInfo> request);
}
}

29
WCS.BLL/Services/IService/IUserService.cs Normal file
View File

@ -0,0 +1,29 @@

using WCS.DAL.AuthDbModel;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.IService
{
/// <summary>
/// 权限用户所有的后台处理方法
/// </summary>
public interface IUserService
{
/// <summary>
/// 模糊查询用户列表
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public Task<ResponseCommon<List<UserBase>>> GetUsers(GetUsersRequest request);
public Task<ResponseCommon<object>> AddUser(AddUserRequest<UserModel> request);
public Task<ResponseCommon<UserBase>> UserLogin(UserLoginRequest request);
public Task<ResponseCommon<List<RoleBase>>> GetRoles(GetUsersRequest request);
public Task<ResponseCommon<object>> AddRole(AddRoleRequest<RoleModel> request);
}
}

14
WCS.BLL/Services/Service/HomerService.cs Normal file
View File

@ -0,0 +1,14 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.BLL.Services.IService;
namespace WCS.BLL.Services.Service
{
public class HomerService: IHomerService
{
public HomerService() { }
}
}

170
WCS.BLL/Services/Service/InstoreService.cs Normal file
View File

@ -0,0 +1,170 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WCS.BLL.Config;
using WCS.BLL.HardWare;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.DAL.Db;
using WCS.Model;
namespace WCS.BLL.Services.Service
{
public class InstoreService : IInstoreService
{
public InstoreService() { }
public ResponseBase shelfGoInInStore(ShelfGoInInstoreRequest request)
{
//校验货架编码规则
bool isValid = Regex.IsMatch(request.ModuleCode, LocalFile.ModuleCodePattern);
if (!isValid)
{
return new ResponseBase()
{
Code = 202,
Message = $"模组编码{request.ModuleCode}不满足模组编码规则！",
};
}
//找到模组对应的货架
var shelf = ShelfManager.Shelves.Where(t => t.ModulesStr.Contains(request.ModuleCode)).FirstOrDefault();
if (shelf == null)//未找到
{
return new ResponseBase()
{
Code = 201,
Message = "未找到模组对应的货架",
};
}
//已找到模组对应货架
shelf.GoInInstore(request.IpAdress);
//成功进入入库模式
return new ShelfGoInInstoreResponse()
{
Code = 200,
Message = "货架进入入库模式成功！",
Data = new ShelfGoInInstoreDto()
{
ShelfCode = shelf.ShelfCode,
ModulesStr = shelf.ModulesStr,
}
};
}
public ResponseBase shelfGoOutInStore(ShelfGoOutInStoreRequest request)
{
//获取货架
var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == request.ShelfCode).FirstOrDefault();
if (shelf == null)//货架不存在
{
return new ResponseCommon()
{
Code = 201,
Message = $"退出入库模式失败：货架[{request.ShelfCode}]不存在!",
};
}
//TO DO 判断扫码枪 是否被其他扫码枪所占用 如果占用 直接退出入库模式 不发指令
//两个扫码枪互相占用入库会有问题
shelf.GoOutInstore();
return new ResponseCommon()
{
Code = 200,
Message = $"货架[{request.ShelfCode}]已退出入库模式!",
};
}
public ResponseBase queryByMatSn(QueryByMatSnRequest request)
{
//获取货架
var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == request.ShelfCode).FirstOrDefault();
if (shelf == null)//货架不存在
{
return new QueryByMatSnResponse()
{
Code = 201,
Message = $"操作失败：货架[{request.ShelfCode}]不存在!",
};
}
//判断当前是否是入库模式
if (shelf.CurentMode != Mode.入库模式)
{
return new QueryByMatSnResponse()
{
Code = 201,
Message = $"操作失败：货架[{request.ShelfCode}]不在入库模式!\r\n当前为{shelf.CurentMode}",
};
}
//调用接口或者直接查询数据库
if (1 == 1)
{
}
//查询数据库
else
{
}
return new QueryByMatSnResponse()
{
Code = 200,
Data = new MatInfoModel(),
Message = "success"
};
}
public async Task<ResponseBase> queryInstoreStatus(QueryByMatSnRequest request)
{
//获取货架
var shelf = ShelfManager.Shelves.Where(t => t.ShelfCode == request.ShelfCode).FirstOrDefault();
if (shelf == null)//货架不存在
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：货架[{request.ShelfCode}]不存在!",
};
}
//判断当前是否是入库模式
if (shelf.CurentMode != Mode.入库模式)
{
return new ResponseCommon()
{
Code = 201,
Message = $"操作失败：货架[{request.ShelfCode}]不在入库模式!\r\n当前为{shelf.CurentMode}",
};
}
//这个时间相当于需要入库扫码后需要等待的时间
var timeOut = 5000;
var timeSpan = TimeSpan.FromMilliseconds(0);
var beginTime = DateTime.Now;
while (timeSpan <= TimeSpan.FromMilliseconds(timeOut))
{
timeSpan = DateTime.Now - beginTime;
//已入库当前扫码的物料时 查询数据库
if (shelf.InStoreData == null || (shelf.InStoreData as object) == null)
{
await Task.Delay(50);
//var inventoryDetail = DbHelp.db.Queryable<InventoryDetail>().Where(t => t.MatSN == dto.matSn).First();
//if (inventoryDetail != null)
//{
// return Json(HttpResponseCommon.GetSuccessResponse($"{inventoryDetail.StoreCode}", null));
//}
}
//延时处理
Thread.Sleep(50);
}
return new ResponseCommon()
{
Code = 200,
Message = $"success",
};
}
}
}

128
WCS.BLL/Services/Service/InterfaceRecordService.cs Normal file
View File

@ -0,0 +1,128 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.DbModels;
using WCS.BLL.Services.IService;
using WCS.DAL;
using WCS.DAL.AuthDbModel;
using WCS.DAL.Db;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.Service
{
public class InterfaceRecordService : IInterfaceRecordService
{
public InterfaceRecordService() { }
public async Task<PageQueryResponse<SystemApiLogRecord>> getInterfaceRecord(GetInterfaceRecordsRequest request)
{
try
{
var recordsQueryable = DbHelp.dbLog.Queryable<SystemApiLogRecord>()
.WhereIF(!string.IsNullOrEmpty(request.RequestType), t => t.RequestType == request.RequestType)
.WhereIF(!string.IsNullOrEmpty(request.RequestUrl), t => t.RequestUrl.Contains(request.RequestUrl))
.WhereIF(!string.IsNullOrEmpty(request.RequestBody), t => t.RequestBody.Contains(request.RequestBody));
if (request.TimeType == TimeType.请求时间)
{
recordsQueryable = recordsQueryable.WhereIF(request.StartTime != null, t => request.StartTime <= t.RequestTime);
recordsQueryable = recordsQueryable.WhereIF(request.StartTime != null, t => request.EndTime >= t.RequestTime);
}
else if (request.TimeType == TimeType.响应时间)
{
recordsQueryable = recordsQueryable.WhereIF(request.StartTime != null, t => request.StartTime <= t.ResponseTime);
recordsQueryable = recordsQueryable.WhereIF(request.StartTime != null, t => request.EndTime >= t.ResponseTime);
}
var totalCount = await recordsQueryable.CountAsync();
var records = await recordsQueryable
.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
.ToListAsync();
//生成序号
for (int i = 0; i < records.Count; i++)
{
records[i].RowNumber = (request.PageNumber - 1) * 10 + i + 1;
}
//Task.WaitAll(new Task[] { recordsTask, totalCountTask });
//var records = recordsTask.Result;
//var totalCount = totalCountTask.Result;
return new PageQueryResponse<SystemApiLogRecord>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<SystemApiLogRecord>()
{
TotalCount = totalCount,
MaxPage = request.PageSize == 0 ? 0 : (int)Math.Ceiling((decimal)totalCount / request.PageSize),
Count = records.Count,
Lists = records.ToList()
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<SystemApiLogRecord>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
public async Task<PageQueryResponse<SystemApiLogRecord>> exportInterfaceRecord(GetInterfaceRecordsRequest request)
{
try
{
var recordsQueryable = DbHelp.dbLog.Queryable<SystemApiLogRecord>()
.WhereIF(!string.IsNullOrEmpty(request.RequestType), t => t.RequestType == request.RequestType)
.WhereIF(!string.IsNullOrEmpty(request.RequestUrl), t => t.RequestUrl.Contains(request.RequestUrl))
.WhereIF(!string.IsNullOrEmpty(request.RequestBody), t => t.RequestBody.Contains(request.RequestBody));
if (request.TimeType == TimeType.请求时间)
{
recordsQueryable = recordsQueryable.WhereIF(request.StartTime != null, t => request.StartTime <= t.RequestTime);
recordsQueryable = recordsQueryable.WhereIF(request.StartTime != null, t => request.EndTime >= t.RequestTime);
}
else if (request.TimeType == TimeType.响应时间)
{
recordsQueryable = recordsQueryable.WhereIF(request.StartTime != null, t => request.StartTime <= t.ResponseTime);
recordsQueryable = recordsQueryable.WhereIF(request.StartTime != null, t => request.EndTime >= t.ResponseTime);
}
var records = await recordsQueryable.ToListAsync();
//生成序号
var index = 1;
records.ForEach(r =>
{
r.RowNumber = index++;
});
return new PageQueryResponse<SystemApiLogRecord>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<SystemApiLogRecord>()
{
Lists = records
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<SystemApiLogRecord>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
}
}

416
WCS.BLL/Services/Service/MatBaseInfoService.cs Normal file
View File

@ -0,0 +1,416 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.DbModels;
using WCS.BLL.Services.IService;
using WCS.DAL;
using WCS.DAL.AuthDbModel;
using WCS.DAL.Db;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.MatBaseInfo;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.Service
{
/// <summary>
/// 物料基础信息
/// </summary>
public class MatBaseInfoService : IMatBaseInfoService
{
public MatBaseInfoService() { }
public async Task<PageQueryResponse<MatBaseInfo>> getMatBaseInfo(GetMatBaseInfoRequest request)
{
try
{
var recordsQueryable = DbHelp.db.Queryable<MatBaseInfo>()
.WhereIF(!string.IsNullOrEmpty(request.MatCode), t => t.MatCode.Contains(request.MatCode))
.WhereIF(!string.IsNullOrEmpty(request.MatName), t => t.MatName.Contains(request.MatName))
.WhereIF(!string.IsNullOrEmpty(request.MatSpec), t => t.MatSpec.Contains(request.MatSpec))
.WhereIF(request.IsEnable != null, t => t.IsEnable == request.IsEnable.GetValueOrDefault());
var totalCount = await recordsQueryable.CountAsync();
var records = await recordsQueryable
.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
.ToListAsync();
//生成序号
for (int i = 0; i < records.Count; i++)
{
records[i].RowNumber = (request.PageNumber - 1) * 10 + i + 1;
}
return new PageQueryResponse<MatBaseInfo>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<MatBaseInfo>()
{
TotalCount = totalCount,
MaxPage = request.PageSize == 0 ? 0 : (int)Math.Ceiling((decimal)totalCount / request.PageSize),
Count = records.Count,
Lists = records.ToList()
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<MatBaseInfo>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
public async Task<PageQueryResponse<MatBaseInfo>> exportMatBaseInfo(GetMatBaseInfoRequest request)
{
try
{
var recordsQueryable = DbHelp.db.Queryable<MatBaseInfo>()
.WhereIF(!string.IsNullOrEmpty(request.MatCode), t => t.MatCode.Contains(request.MatCode))
.WhereIF(!string.IsNullOrEmpty(request.MatName), t => t.MatName.Contains(request.MatName))
.WhereIF(!string.IsNullOrEmpty(request.MatSpec), t => t.MatSpec.Contains(request.MatSpec))
.WhereIF(request.IsEnable != null, t => t.IsEnable == request.IsEnable.GetValueOrDefault());
var records = await recordsQueryable.ToListAsync();
//生成序号
var index = 1;
records.ForEach(r =>
{
r.RowNumber = index++;
});
return new PageQueryResponse<MatBaseInfo>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<MatBaseInfo>()
{
Lists = records
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<MatBaseInfo>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
public async Task<ResponseCommon<List<string>>> importMatBaseInfo(List<MatBaseInfoImportModel> lists, string userName, string deviceType)
{
//获取数据
#region 校验导入的编号是否重复
var matCodes = lists.Select(t => t.物料编码)
.ToList();
var duplicates = matCodes.GroupBy(x => x)
.Where(g => g.Count() > 1)
.Select(g => g.Key).ToList();
//有重复的情况
if (duplicates.Count > 0)
{
return new ResponseCommon<List<string>>()
{
Code = 201,
Message = "导入失败：文件中存在物料编码重复",
Data = duplicates
};
}
#endregion
#region 校验导入数据与数据库中数据是否有重复数据
duplicates = await DbHelp.db.Queryable<MatBaseInfo>()
.Where(t => matCodes.Contains(t.MatCode))
.Select(t => t.MatCode)
.ToListAsync();
//有重复的情况
if (duplicates.Count > 0)
{
return new ResponseCommon<List<string>>()
{
Code = 201,
Message = "导入失败：以下物料编码已存在",
Data = duplicates
};
}
#endregion
#region 导入数据
try
{
await DbHelp.db.BeginTranAsync();
foreach (var mat in lists)
{
var matBaseInfo = new MatBaseInfo()
{
MatCode = mat.物料编码,
MatName = mat.名称,
MatSpec = mat.规格,
MatUnit = mat.单位,
MatCustomer = mat.客户,
IsEnable = mat.状态 == "启用" ? true : false,
};
await DbHelp.db.Insertable(matBaseInfo).ExecuteCommandAsync();
}
await DbHelp.db.CommitTranAsync();
return new ResponseCommon<List<string>>()
{
Code = 200,
Message = "导入数据成功",
Data = null
};
}
catch (Exception ex)
{
await DbHelp.db.RollbackTranAsync();
var ErrList = new List<string>
{
ex.Message
};
return new ResponseCommon<List<string>>()
{
Code = 200,
Message = "导入失败",
Data = ErrList
};
}
#endregion
}
public async Task<ResponseCommon<object>> addOrUpdateMatBaseInfo(AddMatBaseInfoRequest<MatBaseInfo> request)
{
try
{
var matBaseInfo = await DbHelp.db.Queryable<MatBaseInfo>()
.Where(t => t.MatCode == request.MatBaseInfo.MatCode)
.FirstAsync();
//修改物料基础数据
if (request.AddOrUpdate == AddOrUpdate.Update)
{
if (matBaseInfo == null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"更新物料基础数据失败：物料{request.MatBaseInfo}不存在！",
Data = null
};
}
else
{
matBaseInfo.MatName = request.MatBaseInfo.MatName;
matBaseInfo.MatSpec = request.MatBaseInfo.MatSpec;
matBaseInfo.MatUnit = request.MatBaseInfo.MatUnit;
matBaseInfo.MatCustomer = request.MatBaseInfo.MatCustomer;
matBaseInfo.IsEnable = request.MatBaseInfo.IsEnable;
matBaseInfo.ModifyTime = request.MatBaseInfo.ModifyTime;
matBaseInfo.ModifyUser = request.MatBaseInfo.ModifyUser;
var rowNum = await DbHelp.db.Updateable(matBaseInfo).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"更新物料基础数据失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"更新物料基础数据成功！",
Data = null
};
}
}
}
else if (request.AddOrUpdate == AddOrUpdate.Add)
{
if (matBaseInfo != null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"物料基础数据失败：物料{request.MatBaseInfo.MatCode}已存在",
Data = null
};
}
else
{
var newMatBaseInfo = new MatBaseInfo()
{
MatCode = request.MatBaseInfo.MatCode,
MatName = request.MatBaseInfo.MatName,
MatSpec = request.MatBaseInfo.MatSpec,
MatUnit = request.MatBaseInfo.MatUnit,
MatCustomer = request.MatBaseInfo.MatCustomer,
IsEnable = request.MatBaseInfo.IsEnable,
ModifyTime = request.MatBaseInfo.ModifyTime,
ModifyUser = request.MatBaseInfo.ModifyUser,
};
var rowNum = await DbHelp.db.Insertable(newMatBaseInfo).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"添加物料基础数据失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"添加物料基础数据成功！",
Data = null
};
}
}
}
//else if (request.AddOrUpdate == AddOrUpdate.Delete)
//{
// if (matBaseInfo == null)
// {
// return new ResponseCommon<Object>
// {
// Code = 201,
// Message = $"删除物料基础数据失败：物料{request.MatBaseInfo}不存在！",
// Data = null
// };
// }
// else
// {
// var rowNum = await AuthDbHelp.db.Deleteable(matBaseInfo).ExecuteCommandAsync();
// if (rowNum == 0)
// {
// return new ResponseCommon<Object>
// {
// Code = 201,
// Message = $"删除物料基础数据失败：请重试！",
// Data = null
// };
// }
// else
// {
// return new ResponseCommon<Object>
// {
// Code = 200,
// Message = $"删除物料基础数据成功！",
// Data = null
// };
// }
// }
//}
else
{
var response = new ResponseCommon<Object>
{
Code = 300,
Message = "不支持的操作！",
Data = null
};
return response;
}
}
catch (Exception ex)
{
var response = new ResponseCommon<Object>
{
Code = 300,
Message = $"操作失败:{ex.Message}",
Data = null
};
return response;
}
}
public async Task<ResponseCommon<object>> deleteMatBaseInfo(DeleteMatBaseInfosRequest request)
{
//先查询出具体的Id
var matBaseInfos = await DbHelp.db.Queryable<MatBaseInfo>()
.Where(t => request.MatBaseInfoIds.Contains(t.Id))
.ToListAsync();
//执行删除
try
{
var deleteRows = await DbHelp.db.Deleteable(matBaseInfos).ExecuteCommandAsync();
return new ResponseCommon<Object>
{
Code = 200,
Message = $"已删除{deleteRows}条数据！",
Data = null
};
}
catch (Exception ex)
{
var response = new ResponseCommon<Object>
{
Code = 300,
Message = $"操作失败:{ex.Message}",
Data = null
};
return response;
}
}
public async Task<ResponseCommon<List<string>>> getMatCodeList(GetMatCodeListRequest request)
{
try
{
List<string> matCodeList = null;
if (request.IsFromBaseData)
{
matCodeList = await DbHelp.db.Queryable<MatBaseInfo>()
.Select(t => t.MatCode)
.Distinct()
.ToListAsync();
}
else
{
matCodeList = await DbHelp.db.Queryable<InventoryDetail>()
.Select(t => t.MatCode)
.Distinct()
.ToListAsync();
}
return new ResponseCommon<List<string>>()
{
Code = 200,
Message = "success",
Data = matCodeList
};
}
catch (Exception e)
{
return new ResponseCommon<List<string>>()
{
Code = 201,
Message = $"获取失败：{e.Message}",
Data = null
};
}
}
}
}

126
WCS.BLL/Services/Service/MatInventoryDetailService.cs Normal file
View File

@ -0,0 +1,126 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.DbModels;
using WCS.BLL.Services.IService;
using WCS.DAL;
using WCS.DAL.AuthDbModel;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.MatInventoryDetail;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.Service
{
public class MatInventoryDetailService : IMatInventoryDetailService
{
public async Task<PageQueryResponse<InventoryDetail>> getMatInventoryDetail(GetMatInventoryDetailRequest request)
{
try
{
var recordsQueryable = DbHelp.db.Queryable<InventoryDetail>()
.LeftJoin<StoreInfo>((id, si) => id.StoreId == si.Id)
.WhereIF(!string.IsNullOrEmpty(request.MatSN), (id, si) => id.MatSN.Contains(request.MatSN))
.WhereIF(!string.IsNullOrEmpty(request.MatCode), (id, si) => id.MatCode.Contains(request.MatCode))
.WhereIF(!string.IsNullOrEmpty(request.MatName), (id, si) => id.MatName.Contains(request.MatName))
.WhereIF(!string.IsNullOrEmpty(request.MatBatch), (id, si) => id.MatBatch.Contains(request.MatBatch))
.WhereIF(!string.IsNullOrEmpty(request.MatSpec), (id, si) => id.MatSpec.Contains(request.MatSpec))
.WhereIF(!string.IsNullOrEmpty(request.MatSupplier), (id, si) => id.MatSpec.Contains(request.MatSupplier))
.WhereIF(!string.IsNullOrEmpty(request.MatCustomer), (id, si) => id.MatSpec.Contains(request.MatCustomer))
.WhereIF(request.StoreId != 0, (id, si) => id.StoreId == request.StoreId)
.WhereIF(!string.IsNullOrEmpty(request.StoreCode), (id, si) => id.StoreCode.Contains(request.StoreCode))
;
var totalCount = await recordsQueryable.CountAsync();
var records = await recordsQueryable
.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
.Select<InventoryDetail>()
.ToListAsync();
//生成序号
for (int i = 0; i < records.Count; i++)
{
records[i].RowNumber = (request.PageNumber - 1) * 10 + i + 1;
}
return new PageQueryResponse<InventoryDetail>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<InventoryDetail>()
{
TotalCount = totalCount,
MaxPage = request.PageSize == 0 ? 0 : (int)Math.Ceiling((decimal)totalCount / request.PageSize),
Count = records.Count,
Lists = records.ToList()
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<InventoryDetail>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
public async Task<PageQueryResponse<InventoryDetail>> exportMatInventoryDetail(GetMatInventoryDetailRequest request)
{
try
{
var recordsQueryable = DbHelp.db.Queryable<InventoryDetail>()
.LeftJoin<StoreInfo>((id, si) => id.StoreId == si.Id)
.WhereIF(!string.IsNullOrEmpty(request.MatSN), (id, si) => id.MatSN.Contains(request.MatSN))
.WhereIF(!string.IsNullOrEmpty(request.MatCode), (id, si) => id.MatCode.Contains(request.MatCode))
.WhereIF(!string.IsNullOrEmpty(request.MatName), (id, si) => id.MatName.Contains(request.MatName))
.WhereIF(!string.IsNullOrEmpty(request.MatBatch), (id, si) => id.MatBatch.Contains(request.MatBatch))
.WhereIF(!string.IsNullOrEmpty(request.MatSpec), (id, si) => id.MatSpec.Contains(request.MatSpec))
.WhereIF(!string.IsNullOrEmpty(request.MatSupplier), (id, si) => id.MatSpec.Contains(request.MatSupplier))
.WhereIF(!string.IsNullOrEmpty(request.MatCustomer), (id, si) => id.MatSpec.Contains(request.MatCustomer))
.WhereIF(request.StoreId != 0, (id, si) => id.StoreId == request.StoreId)
.WhereIF(!string.IsNullOrEmpty(request.StoreCode), (id, si) => id.StoreCode.Contains(request.StoreCode))
;
var records = await recordsQueryable
.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
.Select<InventoryDetail>()
.ToListAsync();
//生成序号
var index = 1;
records.ForEach(r =>
{
r.RowNumber = index++;
});
return new PageQueryResponse<InventoryDetail>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<InventoryDetail>()
{
Lists = records
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<InventoryDetail>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
}
}

328
WCS.BLL/Services/Service/OutstoreService.cs Normal file
View File

@ -0,0 +1,328 @@
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WCS.BLL.DbModels;
using WCS.BLL.Manager;
using WCS.BLL.Services.IService;
using WCS.DAL.Db;
using WCS.Model;
namespace WCS.BLL.Services.Service
{
public class OutstoreService : IOutstoreService
{
public OutstoreService()
{
}
public async Task<ResponseBase> SysOutOrderByMatCode(SysOutOrderByMatCodeRequest request)
{
//参数合法性校验
if (request.ItemList == null || request.ItemList.Count == 0)
{
return new ResponseBase()
{
Code = 201,
Message = "单据同步失败：缺少需要出库的物料类型！"
};
}
//判断是否有单据号 没有单据号系统自动生成一个
if (string.IsNullOrEmpty(request.OrderNumber))
{
request.OrderNumber = GetOrderNumber();
}
Console.WriteLine(DateTime.Now);
//保存数据
await DbHelp.db.BeginTranAsync();
try
{
var order = new OutOrder()
{
OrderNumber = request.OrderNumber,
OrderSource = request.OrderSource,
OrderType = request.OrderType,
CreateUser = request.UserName,
};
order.Id = await DbHelp.db.Insertable(order).ExecuteReturnIdentityAsync();
request.ItemList.ForEach(async item =>
{
var orderDetail = new OutOrderDetail()
{
OrderId = order.Id,
OrderNumber = order.OrderNumber,
MatCode = item.MatCode,
MatBatch = item.MatBatch,
ReqQty = item.ReqQty,
CreateUser = request.UserName
};
await DbHelp.db.Insertable(orderDetail).ExecuteCommandAsync();
});
await DbHelp.db.CommitTranAsync();
return new ResponseCommon()
{
Code = 200,
Message = "单据同步成功！"
}; ;
}
catch (Exception ex)
{
await DbHelp.db.RollbackTranAsync();
Console.WriteLine(ex.Message);
return new ResponseBase()
{
Code = 200,
Message = $"单据同步失败：{ex.Message}"
};
}
}
public async Task<ResponseBase> SysOutOrderByMatSn(SysOutOrderByMatSnRequest request)
{
//参数合法性校验
if (request.SnList == null || request.SnList.Count == 0)
{
return new ResponseBase()
{
Code = 201,
Message = "单据同步失败：缺少物料明细！"
};
}
//库存有无校验 & 库存已锁校验
try
{
await DbHelp.db.BeginTranAsync();
var inventoryDetails = await DbHelp.db.Queryable<InventoryDetail>()
.Where(t => request.SnList.Contains(t.MatSN))
.TranLock(DbLockType.Wait)
.ToListAsync();
if (inventoryDetails.Count < request.SnList.Count)//库存的物料少于需求的物料数量
{
var existsSns = inventoryDetails.Select(t => t.MatSN).ToList();
request.SnList.RemoveAll(t => existsSns.Contains(t));
await DbHelp.db.RollbackTranAsync();
//返回提示哪些物料库存不存在
return new ResponseCommon()
{
Code = 201,
Message = "单据同步失败：存在物料不在库存中！",
Data = request.SnList
};
}
else if (inventoryDetails.Where(t => t.IsLocked).Any())
{
await DbHelp.db.RollbackTranAsync();
//返回提示哪些物料库存已被锁定
return new ResponseCommon()
{
Code = 201,
Message = "单据同步失败：存在物料被锁定！",
Data = inventoryDetails.Where(t => t.IsLocked).Select(t => t.MatSN).ToList()
};
}
//判断是否有单据号 没有单据号系统自动生成一个
if (string.IsNullOrEmpty(request.OrderNumber))
{
request.OrderNumber = GetOrderNumber();
}
#region 保存数据
//锁库存
inventoryDetails.ForEach(t =>
{
t.IsLocked = false;
});
var lockTask = DbHelp.db.Updateable(inventoryDetails).ExecuteCommandAsync();
//保存数据
var order = new OutOrder()
{
OrderNumber = request.OrderNumber,
OrderSource = request.OrderSource,
OrderType = request.OrderType,
CreateUser = request.UserName,
};
order.Id = await DbHelp.db.Insertable(order).ExecuteReturnIdentityAsync();
//通过库存数据保存出库物料明细表
var matDetailTasks = inventoryDetails.Select(async t =>
{
var orderMatDetail = new OutOrderMatDetail()
{
OrderId = order.Id,
OrderNumber = order.OrderNumber,
InventoryDetailId = t.Id,
StoreId = t.StoreId,
StoreCode = t.StoreCode,
MatSN = t.MatSN,
MatCode = t.MatCode,
MatName = t.MatName,
MatSpec = t.MatSpec,
MatBatch = t.MatBatch,
MatQty = t.MatQty,
MatSupplier = t.MatSupplier,
MatCustomer = t.MatCustomer,
CreateUser = request.UserName
};
await DbHelp.db.Insertable(orderMatDetail).ExecuteCommandAsync();
}).ToList();
await lockTask;
await Task.WhenAll(matDetailTasks);
await DbHelp.db.CommitTranAsync();
return new ResponseCommon()
{
Code = 200,
Message = $"单据同步成功！",
Data = order.Id
};
#endregion
}
catch (Exception ex)
{
await DbHelp.db.RollbackTranAsync();
return new ResponseBase()
{
Code = 201,
Message = $"单据同步失败：{ex.Message}"
};
}
}
public async Task<ResponseBase> GetOutOrderList(GetOutOrderListRequest request)
{
//直接查询
var outOrderList = await DbHelp.db.Queryable<OutOrder>()
.WhereIF(!string.IsNullOrEmpty(request.OrderNumber), t => t.OrderNumber.Contains(request.OrderNumber))
.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
.ToListAsync();
return new PageQueryResponse<OutOrder>()
{
Code = 200,
Message = "success",
Data = new PageQueryResponseData<OutOrder>()
{
Lists = outOrderList,
Count = outOrderList.Count
}
};
}
public async Task<ResponseBase> GetOutOrderDetail(GetOutOrderDetailRequest request)
{
OutOrder outOrder = null;
#region 查询出库单
if (request.OrderId != 0)
{
outOrder = await DbHelp.db.Queryable<OutOrder>().Where(t => t.Id == request.OrderId).FirstAsync();
if (outOrder == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"查询失败：不存在Id为{request.OrderId}的出库单！",
};
}
}
else if (string.IsNullOrEmpty(request.OrderNumber))
{
outOrder = await DbHelp.db.Queryable<OutOrder>().Where(t => t.OrderNumber == request.OrderNumber)
.FirstAsync();
if (outOrder == null)
{
return new ResponseCommon()
{
Code = 201,
Message = $"查询失败：不存在单据号为{request.OrderNumber}的出库单！",
};
}
}
else
{
return new ResponseCommon()
{
Code = 201,
Message = $"查询失败：缺少必要参数！",
};
}
#endregion
#region 查询出库单明细
var orderDetailTask = DbHelp.db.Queryable<OutOrderDetail>()
.Where(t => t.OrderId == outOrder.Id)
.ToListAsync();
#endregion
#region 出库物料明细
var orderMatDetailTask = DbHelp.db.Queryable<OutOrderMatDetail>()
.Where(t => t.OrderId == outOrder.Id)
.ToListAsync();
#endregion
var orderDetail = await orderDetailTask;
var orderMatDetail = await orderMatDetailTask;
return new ResponseCommon()
{
Code = 200,
Message = "Success",
Data = new
{
OrderDetailLists = orderDetail,
OrderMatDetailLists = orderMatDetail,
}
};
}
private string GetOrderNumber()
{
var orderNumber = "PD" + DateTime.Now.ToString("yyyyMMddHHmmss");
return orderNumber;
}
public async Task<ResponseBase> GoInOutstore(GetOutOrderDetailRequest request)
{
//先找到所有物料
//分组 按物料找到对应得货架编码
//对应的货架进入出库模式 亮灯
//返回
return new ResponseCommon()
{
Code = 200,
Message = "Success",
Data = null
};
}
public async Task<ResponseBase> GoOutOutstore(GetOutOrderDetailRequest request)
{
//找到出库单号一致的货架列表
var shelves = ShelfManager.Shelves.Where(t => t.OutOrderNumber == request.OrderNumber)
.ToList();
//退出出库模式
shelves.ForEach(t =>
{
t.GoOutOutstore();
});
return new ResponseCommon()
{
Code = 200,
Message = "Success",
Data = null
};
}
}
}

240
WCS.BLL/Services/Service/StoreInfoService.cs Normal file
View File

@ -0,0 +1,240 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.DbModels;
using WCS.BLL.Services.IService;
using WCS.DAL;
using WCS.DAL.AuthDbModel;
using WCS.DAL.Db;
using WCS.DAL.DbModels;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.StoreInfo;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.Service
{
public class StoreInfoService : IStoreInfoService
{
public StoreInfoService() { }
public async Task<PageQueryResponse<ShelfInfo>> GetShelves(GetShelvesRequest request)
{
try
{
var recordsQueryable = DbHelp.db.Queryable<ShelfInfo>()
.WhereIF(request.ShelfTypeId != 0, t => t.ShelfTypeId == request.ShelfTypeId)
.WhereIF(!string.IsNullOrEmpty(request.ShelfCode), t => t.ShelfCode.Contains(request.ShelfCode));
var totalCount = await recordsQueryable.CountAsync();
var records = await recordsQueryable
.Skip((request.PageNumber - 1) * request.PageSize).Take(request.PageSize)
.ToListAsync();
//生成序号
for (int i = 0; i < records.Count; i++)
{
records[i].RowNumber = (request.PageNumber - 1) * 10 + i + 1;
}
return new PageQueryResponse<ShelfInfo>()
{
Code = 200,
Message = $"success",
Data = new PageQueryResponseData<ShelfInfo>()
{
TotalCount = totalCount,
MaxPage = request.PageSize == 0 ? 0 : (int)Math.Ceiling((decimal)totalCount / request.PageSize),
Count = records.Count,
Lists = records.ToList()
}
};
}
catch (Exception ex)
{
return new PageQueryResponse<ShelfInfo>()
{
Code = 300,
Message = $"操作失败:{ex.Message}",
};
}
}
public async Task<ResponseCommon<object>> addOrUpdateShelfInfo(AddShelfInfoRequest<ShelfInfo> request)
{
try
{
var shelfnfo = await DbHelp.db.Queryable<ShelfInfo>()
.Where(t => t.ShelfCode == request.ShelfInfo.ShelfCode)
.FirstAsync();
//修改货架信息
if (request.AddOrUpdate == AddOrUpdate.Update)
{
var existId = shelfnfo == null ? 0 : shelfnfo.Id;
shelfnfo = await DbHelp.db.Queryable<ShelfInfo>()
.Where(t => t.Id == request.ShelfInfo.Id)
.FirstAsync();
if (shelfnfo == null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"更新货架信息失败：货架{request.ShelfInfo.ShelfCode}不存在！",
Data = null
};
}
else if (existId != shelfnfo.Id)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"更新货架信息失败：已存在货架编码{request.ShelfInfo.ShelfCode}！",
Data = null
};
}
else
{
shelfnfo.ShelfCode = request.ShelfInfo.ShelfCode;
shelfnfo.ShelfTypeId = request.ShelfInfo.ShelfTypeId;
shelfnfo.ShelfTypeName = request.ShelfInfo.ShelfTypeName;
shelfnfo.Rowcounts = request.ShelfInfo.Rowcounts;
shelfnfo.Columncounts = request.ShelfInfo.Columncounts;
shelfnfo.LightId = request.ShelfInfo.LightId;
shelfnfo.ClientIp = request.ShelfInfo.ClientIp;
shelfnfo.GroupName = request.ShelfInfo.GroupName;
shelfnfo.IsBind = request.ShelfInfo.IsBind;
shelfnfo.BindShelfCode = request.ShelfInfo.BindShelfCode;
var rowNum = await DbHelp.db.Updateable(shelfnfo).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"更新货架信息失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"更新货架信息成功！",
Data = null
};
}
}
}
else if (request.AddOrUpdate == AddOrUpdate.Add)
{
if (shelfnfo != null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"货架信息失败：货架{request.ShelfInfo.ShelfCode}已存在!",
Data = null
};
}
else
{
var newShelfInfo = new ShelfInfo()
{
ShelfCode = request.ShelfInfo.ShelfCode,
ShelfTypeId = request.ShelfInfo.ShelfTypeId,
ShelfTypeName = request.ShelfInfo.ShelfTypeName,
Rowcounts = request.ShelfInfo.Rowcounts,
Columncounts = request.ShelfInfo.Columncounts,
LightId = request.ShelfInfo.LightId,
ClientIp = request.ShelfInfo.ClientIp,
GroupName = request.ShelfInfo.GroupName,
IsBind = request.ShelfInfo.IsBind,
BindShelfCode = request.ShelfInfo.BindShelfCode,
};
var rowNum = await DbHelp.db.Insertable(newShelfInfo).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"添加货架信息失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"添加货架信息成功！",
Data = null
};
}
}
}
else if (request.AddOrUpdate == AddOrUpdate.Delete)
{
shelfnfo = await DbHelp.db.Queryable<ShelfInfo>()
.Where(t => t.Id == request.ShelfInfo.Id)
.FirstAsync();
if (shelfnfo == null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"删除货架信息失败：货架{request.ShelfInfo}不存在！",
Data = null
};
}
else
{
var rowNum = await DbHelp.db.Deleteable(shelfnfo).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"删除货架信息失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"删除货架信息成功！",
Data = null
};
}
}
}
else
{
var response = new ResponseCommon<Object>
{
Code = 300,
Message = "不支持的操作！",
Data = null
};
return response;
}
}
catch (Exception ex)
{
var response = new ResponseCommon<Object>
{
Code = 300,
Message = $"操作失败:{ex.Message}",
Data = null
};
return response;
}
}
}
}

464
WCS.BLL/Services/Service/UserService.cs Normal file
View File

@ -0,0 +1,464 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using TouchSocket.Core;
using WCS.BLL.Services.IService;
using WCS.DAL;
using WCS.DAL.AuthDbModel;
using WCS.Model;
using WCS.Model.ApiModel;
using WCS.Model.ApiModel.User;
namespace WCS.BLL.Services.Service
{
public class UserService : IUserService
{
public UserService() { }
public async Task<ResponseCommon<List<UserBase>>> GetUsers(GetUsersRequest request)
{
try
{
var users = await AuthDbHelp.db.Queryable<UserBase>()
.WhereIF(!string.IsNullOrWhiteSpace(request.Info), o => o.LoginName.Contains(request.Info.Trim()))
.OrderBy(o => o.Id)
.ToListAsync();
//返回内容密码处理
if (users != null && users.Count > 0)
{
users.ForEach(t =>
{
t.Password = "******";
});
}
var response = new ResponseCommon<List<UserBase>>()
{
Code = 200,
Message = "success",
Data = users
};
return response;
}
catch (Exception ex)
{
var response = new ResponseCommon<List<UserBase>>()
{
Code = 200,
Message = "success",
Data = null
};
return response;
}
}
public async Task<ResponseCommon<object>> AddUser(AddUserRequest<UserModel> request)
{
try
{
var user = await AuthDbHelp.db.Queryable<UserBase>()
.Where(t => t.LoginName == request.User.LoginName)
.FirstAsync();
if (request.AddOrUpdate == AddOrUpdate.Update)
{
if (user == null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"更新用户信息失败：用户{user.LoginName}不存在！",
Data = null
};
}
else
{
user.Password = request.User.Password;
user.LoginName = request.User.LoginName;
user.RoleIds = request.User.RoleIds;
var rowNum = await AuthDbHelp.db.Updateable(user).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"更新用户信息失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"更新用户信息成功！",
Data = null
};
}
}
}
else if (request.AddOrUpdate == AddOrUpdate.Add)
{
if (user != null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"添加用户失败：用户{request.User.LoginName}已存在",
Data = null
};
}
else
{
var newUser = new UserBase()
{
LoginName = request.User.LoginName,
Password = request.User.Password,
RoleIds = request.User.RoleIds,
IsAdmin = request.User.IsAdmin,
Time = request.User.Time
};
var rowNum = await AuthDbHelp.db.Insertable(newUser).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"添加用户失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"添加用户成功！",
Data = null
};
}
}
}
else if (request.AddOrUpdate == AddOrUpdate.Delete)
{
if (user == null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"删除用户失败：用户{request.User.LoginName}不存在",
Data = null
};
}
else
{
var rowNum = await AuthDbHelp.db.Deleteable(user).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"删除用户失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"删除用户成功！",
Data = null
};
}
}
}
else
{
var response = new ResponseCommon<Object>
{
Code = 300,
Message = "不支持的操作！",
Data = null
};
return response;
}
}
catch (Exception ex)
{
var response = new ResponseCommon<Object>
{
Code = 300,
Message = $"操作失败:{ex.Message}",
Data = null
};
return response;
}
}
public async Task<ResponseCommon<List<RoleBase>>> GetRoles(GetUsersRequest request)
{
try
{
var users = await AuthDbHelp.db.Queryable<RoleBase>()
.WhereIF(!string.IsNullOrWhiteSpace(request.Info), o => o.Name.Contains(request.Info.Trim()))
.OrderBy(o => o.Id)
.ToListAsync();
var response = new ResponseCommon<List<RoleBase>>()
{
Code = 200,
Message = "success",
Data = users
};
return response;
}
catch (Exception ex)
{
var response = new ResponseCommon<List<RoleBase>>()
{
Code = 200,
Message = "success",
Data = null
};
return response;
}
}
public async Task<ResponseCommon<object>> AddRole(AddRoleRequest<RoleModel> request)
{
try
{
var Role = await AuthDbHelp.db.Queryable<RoleBase>()
.Where(t => t.Name == request.Role.Name)
.FirstAsync();
if (request.AddOrUpdate == AddOrUpdate.Update)
{
if (Role == null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"更新角色信息失败：角色{Role.Name}不存在！",
Data = null
};
}
else
{
Role.IsAdmin = request.Role.IsAdmin;
Role.Name = request.Role.Name;
Role.Auths = request.Role.Auths;
Role.Time = request.Role.Time;
var rowNum = await AuthDbHelp.db.Updateable(Role).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"更新角色信息失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"更新角色信息成功！",
Data = null
};
}
}
}
else if (request.AddOrUpdate == AddOrUpdate.Add)
{
if (Role != null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"添加角色失败：角色{request.Role.Name}已存在",
Data = null
};
}
else
{
var newRole = new RoleBase()
{
Name = request.Role.Name,
Auths = request.Role.Auths,
IsAdmin = request.Role.IsAdmin,
Time = request.Role.Time
};
var rowNum = await AuthDbHelp.db.Insertable(newRole).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"添加角色失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"添加角色成功！",
Data = null
};
}
}
}
else if (request.AddOrUpdate == AddOrUpdate.Delete)
{
if (Role == null)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"删除角色失败：角色{request.Role.Name}不存在",
Data = null
};
}
else
{
var isContains = AuthDbHelp.db.Queryable<UserBase>().Select(o => o.RoleIds).ToList().SelectMany(o => o).Contains(Role.Id);
if (isContains)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"删除角色失败：角色{request.Role.Name}已被用户使用！",
Data = null
};
}
var rowNum = await AuthDbHelp.db.Deleteable(Role).ExecuteCommandAsync();
if (rowNum == 0)
{
return new ResponseCommon<Object>
{
Code = 201,
Message = $"删除角色失败：请重试！",
Data = null
};
}
else
{
return new ResponseCommon<Object>
{
Code = 200,
Message = $"删除角色成功！",
Data = null
};
}
}
}
else
{
var response = new ResponseCommon<Object>
{
Code = 300,
Message = "不支持的操作！",
Data = null
};
return response;
}
}
catch (Exception ex)
{
var response = new ResponseCommon<Object>
{
Code = 300,
Message = $"操作失败:{ex.Message}",
Data = null
};
return response;
}
}
public async Task<ResponseCommon<UserBase>> UserLogin(UserLoginRequest request)
{
try
{
UserBase user = null;
if (request.IsNoLogin)//不登录模式 不校验密码
{
user = await AuthDbHelp.db.Queryable<UserBase>()
.Where(t => t.LoginName == "admin")
.FirstAsync();
}
else//登录模式需要校验密码
{
user = await AuthDbHelp.db.Queryable<UserBase>()
.Where(t => t.LoginName == request.UserName)
.FirstAsync();
if (user == null)
{
return new ResponseCommon<UserBase>()
{
Code = 201,
Message = $"登录失败:用户名[{request.UserName}]不存在！",
Data = null
};
}
else if (user.Password != request.PassWord)
{
return new ResponseCommon<UserBase>()
{
Code = 201,
Message = $"登录失败:密码错误！",
Data = null
};
}
}
//加载用户的权限
if (user != null)
{
if (user.IsAdmin)
{
user.GetRoles = await AuthDbHelp.db.Queryable<RoleBase>()
.OrderBy(o => o.Id)
.ToListAsync();
}
else if (user.RoleIds == null || !user.RoleIds.Any())
{
user.GetRoles = new List<RoleBase>();
}
else
{
user.GetRoles = await AuthDbHelp.db.Queryable<RoleBase>()
.Where(t => user.RoleIds.Contains(t.Id))
.OrderBy(o => o.Id)
.ToListAsync();
}
}
//返回字串不返回密码
user.Password = "***";
var response = new ResponseCommon<UserBase>()
{
Code = 200,
Message = "success",
Data = user
};
return response;
}
catch (Exception ex)
{
var response = new ResponseCommon<UserBase>()
{
Code = 300,
Message = $"登录失败:{ex.Message}",
Data = null
};
return response;
}
}
}
}