public async Task <Result> AddWareAsync(reqmodel <AddWareModel> reqmodel)
{
Result result = new Result {
code = ErrorCodeConst.ERROR_1030, status = ErrorCodeConst.ERROR_403
};
string sql_insert = g_sqlMaker.Insert <t_ware>(i =>
new
{
i.name,
i.location,
i.remark,
i.state,
i.status
}).ToSQL();
t_ware model = new t_ware
{
name = reqmodel.Data.name,
location = reqmodel.Data.location,
remark = reqmodel.Data.remark,
state = (int)EnumState.Normal,
status = (int)EnumStatus.Enable
};
bool insert_flag = await g_dbHelper.ExecAsync(sql_insert, model) > 0;
if (!insert_flag)
{
result.code = ErrorCodeConst.ERROR_1018;
return(result);
}
result.code = ErrorCodeConst.ERROR_1019;
result.status = ErrorCodeConst.ERROR_200;
return(result);
}
//[Privilege("searchfactorydrop")]
public async Task <IActionResult> SearchFactoryByPaginer([FromQuery] SearchFactoryModel model)
{
reqmodel <SearchFactoryModel> reqmodel = await RequestPackingAsync(model);
IFactoryServer factoryServer = new FactoryServerImpl(g_dbHelper, g_logServer);
return(await factoryServer.SearchFactoryByPaginer(reqmodel));
}
public async Task <IActionResult> DeleteFactory([FromBody] int id)
{
reqmodel <int> reqmodel = await RequestPackingAsync(id);
IFactoryServer factoryServer = new FactoryServerImpl(g_dbHelper, g_logServer);
return(await factoryServer.DeleteFactory(reqmodel));
}
public async Task <IActionResult> SearchStockInPaginer([FromQuery] SearchStockInModel model)
{
reqmodel <SearchStockInModel> reqmodel = await RequestPackingAsync(model);
IStockServer stockServer = new StockServerImpl(g_dbHelper, g_logServer);
return(await stockServer.SearchStockInPaginerAsync(reqmodel));
}
public async Task <IActionResult> DeleteDepartment([FromBody] int id)
{
reqmodel <int> reqmodel = await RequestPackingAsync(id);
IDepartmentServer departmentServer = new DepartmentServerImpl(g_dbHelper, g_logServer);
return(await departmentServer.DeleteDepartment(reqmodel));
}
public async Task <IActionResult> GetUserInfo()
{
reqmodel reqmodel = await RequestPackingAsync();
IUserServer userServer = new UserServerImpl(g_dbHelper, g_logServer);
return(await userServer.GetUserInfoAsync(reqmodel));
}
public async Task <IActionResult> DeleteProduct([FromBody] int id)
{
reqmodel <int> reqmodel = await RequestPackingAsync(id);
IProductServer productServer = new ProductServerImpl(g_dbHelper, g_logServer);
return(await productServer.DeleteProduct(reqmodel));
}
public async Task <Result> GetStockPaginerAsync(reqmodel <StockPaginerModel> reqmodel)
{
Result <PaginerData <StockPaginerResult> > result = new Result <PaginerData <StockPaginerResult> > {
status = ErrorCodeConst.ERROR_200, code = ErrorCodeConst.ERROR_200
};
result.data = await GetStockPaginer(reqmodel.Data.name, reqmodel.Data.page_index, reqmodel.Data.page_size);
return(result);
}
public async Task <Result> SearchFactoryByPaginer(reqmodel <SearchFactoryModel> reqmodel)
{
Result <PaginerData <SearchFactoryResult> > result = new Result <PaginerData <SearchFactoryResult> > {
status = ErrorCodeConst.ERROR_200, code = ErrorCodeConst.ERROR_200
};
result.data = await SearchFactoryByVagueName(reqmodel.Data.name, reqmodel.Data.page_index, reqmodel.Data.page_size);
return(result);
}
/// <summary>
/// @xis 待入库列表
/// </summary>
/// <param name="reqmodel"></param>
/// <returns></returns>
public async Task <Result> SearchStockPaginerAsync(reqmodel <SearchStockPreModel> reqmodel)
{
Result <PaginerData <SearchStockPrePaginerResult> > result = new Result <PaginerData <SearchStockPrePaginerResult> > {
status = ErrorCodeConst.ERROR_200, code = ErrorCodeConst.ERROR_200
};
IWhere <t_stock> stock_data_mkr = g_sqlMaker.Select <t_stock>(s => new { s.id, s.product_name }).Where();
IWhere <t_stockin_pre> stock_pre_data_mkr = g_sqlMaker.Select <t_stockin_pre>(s => new { s.id, s.stock_id, s.quantity }).Where();
IWhere <t_stockin_pre> stock_pre_total_mkr = g_sqlMaker.Select <t_stockin_pre>().Count().Where();
//模糊查询产品
List <t_stock> stock_list = new List <t_stock>();
if (!string.IsNullOrWhiteSpace(reqmodel.Data.name))
{
stock_data_mkr = stock_data_mkr.And("product_name", "like", "@product_name");
stock_pre_data_mkr = stock_pre_data_mkr.And("stock_id", "in", "@stock_id");
stock_pre_total_mkr = stock_pre_total_mkr.And("stock_id", "in", "@stock_id");
stock_list = await g_dbHelper.QueryListAsync <t_stock>(stock_data_mkr.ToSQL(), new { product_name = $"%{reqmodel.Data.name}%" });
}
//查询待入库
string stock_pre_data_sql = stock_pre_data_mkr.OrderByDesc("add_time").Pager(reqmodel.Data.page_index, reqmodel.Data.page_size).ToSQL();
List <t_stockin_pre> stock_pre_list = await g_dbHelper.QueryListAsync <t_stockin_pre>(stock_pre_data_sql, new { stock_id = stock_list.Select(s => s.id) });
int total = await g_dbHelper.QueryAsync <int>(stock_pre_total_mkr.ToSQL(), new { stock_id = stock_list.Select(s => s.id) });
if (string.IsNullOrWhiteSpace(reqmodel.Data.name) && stock_pre_list.Count > 0)
{
stock_list = await g_dbHelper.QueryListAsync <t_stock>(stock_data_mkr.And("id", "in", "@stock_id").ToSQL(), new { stock_id = stock_pre_list.Select(s => s.stock_id) });
}
List <SearchStockPrePaginerResult> search_list = new List <SearchStockPrePaginerResult>();
foreach (var item in stock_pre_list)
{
t_stock stock = stock_list.First(f => f.id == item.stock_id);
search_list.Add(new SearchStockPrePaginerResult
{
id = item.id,
stock_id = item.stock_id,
quantity = item.quantity,
product_name = stock.product_name,
});
}
PaginerData <SearchStockPrePaginerResult> paginer = new PaginerData <SearchStockPrePaginerResult>
{
page_index = reqmodel.Data.page_index,
page_size = reqmodel.Data.page_size,
Data = search_list,
total = total
};
result.data = paginer;
return(result);
}
public async Task <Result> GetUserInfoAsync(reqmodel reqmodel)
{
//const string modelname = "UserServerImpl.GetUserInfoAsync";
//ILogServer logServer = new LogServerImpl();
Result <LoginResult> result = new Result <LoginResult>();
result.code = ErrorCodeConst.ERROR_200;
result.status = ErrorCodeConst.ERROR_200;
result.data = reqmodel.User;
return(await Task.FromResult(result));
}
public async Task <IActionResult> AddFactory([FromBody] AddFactoryModel model)
{
if (!ModelState.IsValid)
{
return(GetModelErrorCode());
}
reqmodel <AddFactoryModel> reqmodel = await RequestPackingAsync(model);
IFactoryServer factoryServer = new FactoryServerImpl(g_dbHelper, g_logServer);
return(await factoryServer.AddFactory(reqmodel));
}
public async Task <IActionResult> Login([FromBody] LoginModel model)
{
if (!ModelState.IsValid)
{
return(GetModelErrorCode());
}
reqmodel <LoginModel> reqmodel = await RequestPackingAsync(model);
IUserServer userServer = new UserServerImpl(g_dbHelper, g_logServer);
return(await userServer.LoginAsync(reqmodel));
}
public async Task <Result> AddDepartment(reqmodel <AddDepartmentModel> reqmodel)
{
bool has_parent = false;
Result result = new Result {
code = ErrorCodeConst.ERROR_100
};
if (reqmodel.Data.department_parent != null)
{
string sql_exist_parent = g_sqlMaker.Select <t_department>(s => s.id)
.Where("id", "=", "@id")
.ToSQL();
bool exist_parent_flag = await g_dbHelper.QueryAsync <int>(sql_exist_parent, new { id = reqmodel.Data.department_parent.Value }) != 0;
if (!exist_parent_flag)
{
result.code = ErrorCodeConst.ERROR_1024;
return(result);
}
has_parent = true;
}
//上级部门
string sql_insert = null;
if (has_parent)
{
sql_insert = g_sqlMaker.Insert <t_department>(i => new { i.department_name, i.department_parent, i.state, i.status, i.add_time }).ToSQL();
}
else
{
sql_insert = g_sqlMaker.Insert <t_department>(i => new { i.department_name, i.state, i.status, i.add_time }).ToSQL();
}
t_department department_model = new t_department
{
department_name = reqmodel.Data.department_name,
department_parent = reqmodel.Data.department_parent,
state = (int)EnumState.Normal,
status = (int)EnumStatus.Enable
};
bool insert_flag = await g_dbHelper.ExecAsync(sql_insert, department_model) > 0;
if (!insert_flag)
{
result.code = ErrorCodeConst.ERROR_1018;
return(result);
}
result.status = ErrorCodeConst.ERROR_200;
result.code = ErrorCodeConst.ERROR_1019;
return(result);
}
/// <summary>
/// 包装返回的请求
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public async Task <reqmodel> RequestPackingAsync()
{
reqmodel reqmodel = new reqmodel
{
Lang = Lang,
Ip = Ip,
Request = Request,
User = await Request.GetUserAsync()
};
return(reqmodel);
}
public async Task <IActionResult> DepositStock([FromBody] StockDepositModel model)
{
if (!ModelState.IsValid)
{
return(GetModelErrorCode());
}
reqmodel <StockDepositModel> reqmodel = await RequestPackingAsync(model);
IWareServer wareServer = new WareServerImpl(g_dbHelper, g_logServer);
return(await wareServer.DepositStockAsync(reqmodel));
}
public async Task <IActionResult> GetStockInDetail([FromQuery] StockInDetailModel model)
{
if (!ModelState.IsValid)
{
return(GetModelErrorCode());
}
reqmodel <StockInDetailModel> reqmodel = await RequestPackingAsync(model);
IStockServer stockServer = new StockServerImpl(g_dbHelper, g_logServer);
return(await stockServer.GetStockInDetailAsync(reqmodel));
}
public async Task <IActionResult> StockInAudit([FromBody] AuditModel model)
{
if (!ModelState.IsValid)
{
return(GetModelErrorCode());
}
reqmodel <AuditModel> reqmodel = await RequestPackingAsync(model);
IStockServer stockServer = new StockServerImpl(g_dbHelper, g_logServer);
return(await stockServer.StockInAuditAsync(reqmodel));
}
public async Task <IActionResult> AddDepartment([FromBody] AddDepartmentModel model)
{
if (!ModelState.IsValid)
{
return(GetModelErrorCode());
}
reqmodel <AddDepartmentModel> reqmodel = await RequestPackingAsync(model);
IDepartmentServer departmentServer = new DepartmentServerImpl(g_dbHelper, g_logServer);
return(await departmentServer.AddDepartment(reqmodel));
}
/// <summary>
/// 包装返回的请求
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <returns></returns>
public async Task <reqmodel <T> > RequestPackingAsync <T>(T data)
{
reqmodel <T> reqmodel = new reqmodel <T>
{
Data = data,
Lang = Lang,
Ip = Ip,
Request = Request,
User = await Request.GetUserAsync()
};
return(reqmodel);
}
/// <summary>
/// @xis 搜索库存
/// </summary>
/// <param name="reqmodel"></param>
/// <returns></returns>
public async Task <Result> SearchStockAsync(reqmodel <SearchStockModel> reqmodel)
{
Result <IEnumerable <SearchStockResult> > result = new Result <IEnumerable <SearchStockResult> > {
code = ErrorCodeConst.ERROR_200, status = ErrorCodeConst.ERROR_200
};
List <t_stock> stock_list = await GetStockHasByVagueName(s => new { s.id, s.product_name, s.quantity }, reqmodel.Data.name, reqmodel.Data.count);
IEnumerable <SearchStockResult> result_list = stock_list.GroupBy(g => g.product_name).Select(s => new SearchStockResult {
name = s.Key, quantity = stock_list.Where(w => w.product_name == s.Key).Sum(sm => sm.quantity)
});
result.data = result_list;
return(result);
}
/// <summary>
/// @xis 搜索入库单
/// </summary>
/// <param name="reqmodel"></param>
/// <returns></returns>
public async Task <Result> SearchStockInPaginerAsync(reqmodel <SearchStockInModel> reqmodel)
{
PaginerData <t_stock_in> order_list = await GetStockHasByVagueOrderSn(s => new
{
s.in_user_id,
s.order_sn,
s.add_time,
s.apply_process,
s.apply_status,
s.department_id,
s.position_id
}, reqmodel.Data.order_sn, reqmodel.User.position_id, reqmodel.Data.page_index, reqmodel.Data.page_size);
Result <PaginerData <SearchStockInResult> > result = new Result <PaginerData <SearchStockInResult> > {
status = ErrorCodeConst.ERROR_200, code = ErrorCodeConst.ERROR_200
};
PaginerData <SearchStockInResult> result_paginer = new PaginerData <SearchStockInResult> {
page_index = order_list.page_index, page_size = order_list.page_size, total = order_list.total, Data = new List <SearchStockInResult>()
};
IAuditServer auditServer = new AuditServerImpl(g_dbHelper, g_logServer);
IUserServer userServer = new UserServerImpl(g_dbHelper, g_logServer);
IDepartmentServer departmentServer = new DepartmentServerImpl(g_dbHelper, g_logServer);
foreach (var item in order_list.Data)
{
t_user user_model = await userServer.GetUserById(s => new { s.real_name, s.job_number }, item.in_user_id);
t_department depart_model = await departmentServer.GetDepartment(s => new { s.department_name }, item.department_id);
result_paginer.Data.Add(new SearchStockInResult
{
add_time = item.add_time.Value.ToString("yyyy-MM-dd hh:mm:ss"),
applyer = user_model.real_name,
apply_status = item.apply_status,
apply_status_desc = ((EnumApplyStatus)item.apply_status).GetDesc(),
job_number = user_model.job_number,
order_sn = item.order_sn,
depart_name = depart_model.department_name,
audit_list = await auditServer.GetApplyLogByOrderSnAsync(EnumOrderType.IN, item.order_sn, item.department_id, item.position_id),
audit_step_index = auditServer.GetApplyIndex(EnumOrderType.IN, item.department_id, item.position_id, item.apply_process),//获取审批到第几步
op_audit = (auditServer.GetNextApplyer(EnumOrderType.IN, item.department_id, item.apply_process) == reqmodel.User.position_id) && item.apply_status == (int)EnumApplyStatus.Progress
});
}
result.data = result_paginer;
return(result);
}
public async Task <Result> SearchFactoryDrop(reqmodel <SearchFactoryModel> reqmodel)
{
Result <List <KVItemResult <int, string> > > result = new Result <List <KVItemResult <int, string> > > {
status = ErrorCodeConst.ERROR_200, code = ErrorCodeConst.ERROR_200
};
IEnumerable <t_factory> list = await GetFactoryByVagueName(s => new { s.id, s.factory_name }, reqmodel.Data.name);
result.data = new List <KVItemResult <int, string> >();
foreach (var item in list)
{
result.data.Add(new KVItemResult <int, string>
{
key = item.id,
value = item.factory_name
});
}
return(result);
}
public async Task <Result> AddFactory(reqmodel <AddFactoryModel> reqmodel)
{
Result result = new Result {
code = ErrorCodeConst.ERROR_1018, status = ErrorCodeConst.ERROR_403
};
if (!Regex.IsMatch(reqmodel.Data.factory_tel, @"^\d{11}$"))
{
result.code = ErrorCodeConst.ERROR_1028;
return(result);
}
string sql_insert = g_sqlMaker.Insert <t_factory>(i =>
new
{
i.factory_name,
i.factory_person_name,
i.factory_tel,
i.status,
i.state,
}).ToSQL();
t_factory factory_model = new t_factory
{
factory_name = reqmodel.Data.factory_name,
factory_tel = reqmodel.Data.factory_tel,
factory_person_name = reqmodel.Data.factory_person_name,
status = reqmodel.Data.status.GetValueOrDefault((int)EnumStatus.Enable),
state = (int)EnumState.Normal
};
bool insert_flag = await g_dbHelper.ExecAsync(sql_insert, factory_model) > 0;
if (!insert_flag)
{
result.code = ErrorCodeConst.ERROR_1018;
return(result);
}
result.status = ErrorCodeConst.ERROR_200;
result.code = ErrorCodeConst.ERROR_1019;
return(result);
}
public async Task <Result> LoginOutAsync(reqmodel reqmodel)
{
const string modelname = "UserServerImpl.LoginOutAsync";
Result result = new Result {
status = ErrorCodeConst.ERROR_403, code = ErrorCodeConst.ERROR_100
};
bool loginout_flag = await RedisHelper.Instance.DeleteStringKeyAsync(RedisPrefix + reqmodel.User.token);
if (!loginout_flag)
{
g_logServer.Log(modelname, "登出失败", new { msg = $"用户名:{reqmodel.User.user_name}" }, EnumLogType.Debug);
result.code = ErrorCodeConst.ERROR_100;
return(result);
}
result.code = ErrorCodeConst.ERROR_200;
result.status = ErrorCodeConst.ERROR_200;
return(result);
}
public async Task <Result> DeleteFactory(reqmodel <int> reqmodel)
{
Result result = new Result {
code = ErrorCodeConst.ERROR_1030, status = ErrorCodeConst.ERROR_403
};
string sql_update = g_sqlMaker.Update <t_factory>(u => new
{
u.state,
}).Where("id", "=", "@id").And("state", "=", "@state")
.ToSQL();
bool disable_flag = await g_dbHelper.ExecAsync(sql_update, new { id = reqmodel.Data, state = (int)EnumState.Normal }) > 0;
if (!disable_flag)
{
return(result);
}
result.code = ErrorCodeConst.ERROR_1029;
result.status = ErrorCodeConst.ERROR_200;
return(result);
}
public async Task <Result> DeleteProduct(reqmodel <int> reqmodel)
{
Result result = new Result {
code = ErrorCodeConst.ERROR_100, status = ErrorCodeConst.ERROR_403
};
string sql_update = g_sqlMaker.Update <t_product>(u => new { u.state }).Where($"id", "=", "@id").And("state", "=", "@state").ToSQL();
t_product product_model = new t_product
{
id = reqmodel.Data,
state = (int)EnumState.Delete
};
bool update_flag = await g_dbHelper.ExecAsync(sql_update, product_model) > 0;
if (!update_flag)
{
result.code = ErrorCodeConst.ERROR_1034;
return(result);
}
result.status = ErrorCodeConst.ERROR_200;
result.code = ErrorCodeConst.ERROR_1033;
return(result);
}
/// <summary>
/// @xis 获取入库单详情
/// </summary>
/// <param name="reqmodel"></param>
/// <returns></returns>
public async Task <Result> GetStockInDetailAsync(reqmodel <StockInDetailModel> reqmodel)
{
Result <StockInDetailResult> result = new Result <StockInDetailResult> {
code = ErrorCodeConst.ERROR_100, status = ErrorCodeConst.ERROR_403
};
t_stock_in stock_in_model = await GetStockInByOrderSn(f => new
{
f.in_user_id,
f.department_id,
f.add_time,
f.apply_status,
f.position_id,
f.order_sn
}, reqmodel.Data.order_sn);
if (stock_in_model == null)
{
result.code = ErrorCodeConst.ERROR_1038;
return(result);
}
IUserServer userServer = new UserServerImpl(g_dbHelper, g_logServer);
IDepartmentServer departmentServer = new DepartmentServerImpl(g_dbHelper, g_logServer);
IAuditServer auditServer = new AuditServerImpl(g_dbHelper, g_logServer);
t_user user_model = await userServer.GetUserById(s => new { s.real_name, s.job_number }, stock_in_model.in_user_id);
t_department depart_model = await departmentServer.GetDepartment(s => new { s.department_name }, stock_in_model.department_id);
result.data = new StockInDetailResult
{
add_time = stock_in_model.add_time.Value.ToString("yyyy-MM-dd hh:mm:ss") ?? "",
applyer = user_model.real_name,
apply_status = stock_in_model.apply_status,
apply_status_desc = ((EnumApplyStatus)stock_in_model.apply_status).GetDesc(),
audit_step_index = auditServer.GetApplyIndex(EnumOrderType.IN, stock_in_model.department_id, stock_in_model.position_id, stock_in_model.apply_process),
job_number = user_model.job_number,
order_sn = stock_in_model.order_sn,
depart_name = depart_model.department_name,
audit_list = await auditServer.GetApplyedLogByOrderSnAsync(EnumOrderType.IN, stock_in_model.order_sn, stock_in_model.department_id, stock_in_model.position_id),
products = new List <StockInProductResult>()
};
//获取入库的库存信息
List <t_stock_in_detail> stock_detail_list = await GetStockDetailsByOrderSn(f => new t_stock_in_detail {
}, stock_in_model.order_sn);
IFactoryServer factoryServer = new FactoryServerImpl(g_dbHelper, g_logServer);
foreach (var item in stock_detail_list)
{
result.data.products.Add(new StockInProductResult
{
batch_number = item.batch_number,
expiration_date = item.expiration_date,
factory_id = item.factory_id,
instructions = item.instructions,
material_number = item.material_number,
model_number = item.model_number,
package_size = item.package_size,
product_name = item.product_name,
report_card_url = item.report_card_url,
retest_date = item.retest_date,
spare_parts = item.spare_parts,
unit_name = item.unit_name,
quantity = item.quantity,
unit_price = item.unit_price,
factory_name = (await factoryServer.GetFactoryById(f => new { f.factory_name }, item.factory_id)).factory_name
});
}
result.code = ErrorCodeConst.ERROR_200;
result.status = ErrorCodeConst.ERROR_200;
return(result);
}
/// <summary>
/// @xis 入库申请
/// </summary>
/// <param name="reqmodel"></param>
/// <returns></returns>
public async Task <Result> StockInApplyAsync(reqmodel <StockInApplyModel> reqmodel)
{
const string modelname = "StockServerImpl.StockInApplyAsync";
Result result = new Result {
code = ErrorCodeConst.ERROR_1037, status = ErrorCodeConst.ERROR_403
};
//入库单
t_stock_in stock_in = new t_stock_in
{
apply_status = (int)EnumApplyStatus.Progress,
in_user_id = reqmodel.User.user_id,
department_id = reqmodel.User.department_id,
position_id = reqmodel.User.position_id,
status = (int)EnumStatus.Enable,
order_sn = MakeOrderSn("IN"),
apply_process = reqmodel.User.position_id,
add_time = DateTime.Now
};
List <t_stock_in_detail> stock_detail_list = new List <t_stock_in_detail>();
List <t_stock> stock_add_list = new List <t_stock>();
List <t_stock> stock_update_list = new List <t_stock>();
#region 数据验证
if (reqmodel.Data.products.Count == 0)
{
result.code = ErrorCodeConst.ERROR_1042;
return(result);
}
#endregion
List <t_stock> stock_info_list = await GetStockByIds(s => new { s.id, s.freeze_quantity, s.rv }, reqmodel.Data.products.Select(s => s.id));
//检查库存
foreach (var item in reqmodel.Data.products)
{
//更新库存
t_stock es_stock = stock_info_list.FirstOrDefault(f => f.id == item.id);
if (es_stock != null)
{
//添加已有的详细信息
stock_detail_list.Add(new t_stock_in_detail
{
order_sn = stock_in.order_sn,
unit_price = item.unit_price,
stock_id = item.id,
quantity = item.quantity,
batch_number = item.batch_number,
expiration_date = item.expiration_date,
instructions = item.instructions,
material_number = item.material_number,
model_number = item.model_number,
package_size = item.package_size,
product_name = item.product_name,
report_card_url = item.report_card_url,
retest_date = item.retest_date,
spare_parts = item.spare_parts,
unit_name = item.unit_name,
factory_id = item.factory_id
});
continue;
}
//添加新产品
stock_add_list.Add(new t_stock
{
add_time = DateTime.Now,
batch_number = item.batch_number,
expiration_date = item.expiration_date,
instructions = item.instructions,
material_number = item.material_number,
model_number = item.model_number,
package_size = item.package_size,
product_name = item.product_name,
report_card_url = item.report_card_url,
retest_date = item.retest_date,
spare_parts = item.spare_parts,
state = (int)EnumState.Normal,
status = (int)EnumStatus.Enable,
unit_price = item.unit_price,
util_name = item.unit_name,
quantity = item.quantity,//在详情处清0
freeze_quantity = 0,
factory_id = item.factory_id
});
}
try
{
g_dbHelper.Transaction();
bool insert_stock_in = await AddStockInAsync(stock_in) > 0;
if (!insert_stock_in)
{
g_dbHelper.Rollback();
result.code = ErrorCodeConst.ERROR_1030;
g_logServer.Log(modelname, "入库单申请失败", $"用户：{reqmodel.User.user_name},添加入库单失败", models.enums.EnumLogType.Info);
return(result);
}
if (stock_add_list.Count > 0)
{
foreach (var item in stock_add_list)
{
decimal quantity = item.quantity;
item.quantity = 0;
SVResult <int> add_result = await AddStock(item);
if (!add_result.state)
{
g_dbHelper.Rollback();
result.code = add_result.code;
g_logServer.Log(modelname, "入库单申请失败", $"用户：{reqmodel.User.user_name},添加新库存失败", models.enums.EnumLogType.Info);
return(result);
}
stock_detail_list.Add(new t_stock_in_detail
{
order_sn = stock_in.order_sn,
stock_id = add_result.data,
batch_number = item.batch_number,
expiration_date = item.expiration_date,
factory_id = item.factory_id,
instructions = item.instructions,
material_number = item.material_number,
model_number = item.model_number,
package_size = item.package_size,
product_name = item.product_name,
report_card_url = item.report_card_url,
retest_date = item.retest_date,
spare_parts = item.spare_parts,
unit_name = item.util_name,
quantity = quantity,
unit_price = item.unit_price,
});
}
}
//if (stock_info_list.Count > 0)
//{
// bool update_stock = await UpdateStock(u => new { u.freeze_quantity }, stock_info_list);
// if (!update_stock)
// {
// g_dbHelper.Rollback();
// result.code = ErrorCodeConst.ERROR_1030;
// g_logServer.Log(modelname, "入库单申请失败", $"用户：{reqmodel.User.user_name},更新库存失败", models.enums.EnumLogType.Info);
// return result;
// }
//}
SVResult <int> insert_stock_dtl_flag = await AddStockDetails(stock_detail_list);
if (!insert_stock_dtl_flag.state)
{
g_dbHelper.Rollback();
result.code = insert_stock_dtl_flag.code;
g_logServer.Log(modelname, "入库单申请失败", $"用户：{reqmodel.User.user_name},更新入库单详情失败", models.enums.EnumLogType.Info);
return(result);
}
g_dbHelper.Commit();
}
catch (Exception e)
{
g_dbHelper.Rollback();
g_logServer.Log(modelname, "入库单申请失败", $"用户：{reqmodel.User.user_name},错误信息：{e.Message}", models.enums.EnumLogType.Error);
return(result);
}
result.code = ErrorCodeConst.ERROR_1036;
result.status = ErrorCodeConst.ERROR_200;
g_logServer.Log(modelname, "入库单申请成功", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn}", models.enums.EnumLogType.Info);
return(result);
}
/// <summary>
/// @xis 入库审批
/// </summary>
/// <param name="reqmodel"></param>
/// <returns></returns>
public async Task <Result> StockInAuditAsync(reqmodel <AuditModel> reqmodel)
{
const string modelname = "StockServerImpl.StockInAuditAsync";
Result result = new Result {
code = ErrorCodeConst.ERROR_1037, status = ErrorCodeConst.ERROR_403
};
t_stock_in stock_in = await GetStockInByOrderSn(s => new
{
s.apply_process,
s.apply_status,
s.department_id
}, reqmodel.Data.order_sn);
if (stock_in == null)
{
result.code = ErrorCodeConst.ERROR_1038;
g_logServer.Log(modelname, "入库审批失败", $"用户：{reqmodel.User.user_name}，订单不存在", EnumLogType.Info);
return(result);
}
stock_in.order_sn = reqmodel.Data.order_sn;
if (stock_in.apply_status == (int)EnumApplyStatus.Agree)
{
result.code = ErrorCodeConst.ERROR_1039;
g_logServer.Log(modelname, "入库审批失败", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn}，订单被审核完成", EnumLogType.Info);
return(result);
}
if (stock_in.apply_status == (int)EnumApplyStatus.Reject)
{
result.code = ErrorCodeConst.ERROR_1041;
g_logServer.Log(modelname, "入库审批失败", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn}，订单被驳回", EnumLogType.Info);
return(result);
}
IAuditServer auditServer = new AuditServerImpl(g_dbHelper, g_logServer);
int? next_applyer = auditServer.GetNextApplyer(EnumOrderType.IN, stock_in.department_id, stock_in.apply_process);
if (next_applyer == null)
{
result.code = ErrorCodeConst.ERROR_1030;
g_logServer.Log(modelname, "入库审批失败", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn}，流程错误", EnumLogType.Info);
return(result);
}
if (next_applyer != reqmodel.User.position_id)
{
result.code = ErrorCodeConst.ERROR_1035;
g_logServer.Log(modelname, "入库审批失败", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn}，无法进行审批", EnumLogType.Info);
return(result);
}
t_apply_log apply_log = new t_apply_log
{
apply_status = reqmodel.Data.act,
order_sn = reqmodel.Data.order_sn,
user_id = reqmodel.User.user_id,
position_id = reqmodel.User.position_id
};
stock_in.apply_process = reqmodel.User.position_id;
try
{
g_dbHelper.Transaction();
//审批记录更新
bool insert_apply_log_flag = await AddApplyLog(apply_log);
if (!insert_apply_log_flag)
{
g_dbHelper.Rollback();
result.code = ErrorCodeConst.ERROR_1030;
g_logServer.Log(modelname, "入库审批失败", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn}，添加审批记录失败", models.enums.EnumLogType.Info);
return(result);
}
//审批状态更新
bool update_stock_in_flag;
if (reqmodel.Data.act == 1)
{
stock_in.apply_status = (int)EnumApplyStatus.Agree;
}
else
{
//驳回
stock_in.apply_status = (int)EnumApplyStatus.Reject;
}
//最后一步或者拒绝则更新审批状态
EnumApplyStepFlag step_flag = auditServer.GetApplyStepFlag(EnumOrderType.IN, stock_in.department_id, reqmodel.User.position_id);
if (step_flag == EnumApplyStepFlag.End || stock_in.apply_status == (int)EnumApplyStatus.Reject)
{
update_stock_in_flag = await UpdateStockInByOrderSn(u => new { u.apply_status, u.apply_process }, stock_in);
}
else
{
update_stock_in_flag = await UpdateStockInByOrderSn(u => new { u.apply_process }, stock_in);
}
if (!update_stock_in_flag)
{
g_dbHelper.Rollback();
result.code = ErrorCodeConst.ERROR_1030;
g_logServer.Log(modelname, "入库审批失败", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn}，更新审批状态失败", models.enums.EnumLogType.Info);
return(result);
}
//同意并且是最后一步审批，更新库存数量
if (step_flag == EnumApplyStepFlag.End && stock_in.apply_status == (int)EnumApplyStatus.Agree)
{
bool update_quality_flag = await StockInApplySuccess(stock_in.order_sn);
if (!update_quality_flag)
{
g_dbHelper.Rollback();
result.code = ErrorCodeConst.ERROR_1030;
g_logServer.Log(modelname, "入库审批失败", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn}，更新库存数量失败", models.enums.EnumLogType.Info);
return(result);
}
}
g_dbHelper.Commit();
}
catch (Exception ex)
{
g_dbHelper.Rollback();
result.code = ErrorCodeConst.ERROR_1030;
g_logServer.Log(modelname, "入库审批异常", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn},异常信息：{ex.Message}", models.enums.EnumLogType.Error);
return(result);
}
result.code = ErrorCodeConst.ERROR_1029;
result.status = ErrorCodeConst.ERROR_200;
g_logServer.Log(modelname, "入库审批成功", $"用户：{reqmodel.User.user_name},订单号：{stock_in.order_sn}", models.enums.EnumLogType.Info);
return(result);
}
