public ActionResult <Usuario> Post(RequestPost usuario)
{
try
{
var user = _services.CreateUserAccount(usuario);
if (user != null)
{
return(new JsonResult(new ResponseGetGenery {
id = user.IdUsuario, Tipo = "Usuario Creado", Status = true
})
{
StatusCode = 201
});
}
else
{
return(new JsonResult(new ResponseGetGenery {
id = 0, Tipo = null
})
{
StatusCode = 400
});
}
}
catch
{
return(new JsonResult(new ResponseGetGenery {
id = 0, Tipo = null
})
{
StatusCode = 500
});
}
}
public Usuario CreateUserAccount(RequestPost requestPost)
{
Usuario user = null;
ResultPost StateDireccion = PostDireccionApi(requestPost.Direccion).First();
if (StateDireccion.Id != null || StateDireccion.Id != "null")
{
user = Conversion.ConverUser(requestPost);
user.IdDireccion = int.Parse(StateDireccion.Id);
_repository.Add(user);
if (user != null)
{
CuentaDTO account = Conversion.ConverAccount(requestPost, user.IdUsuario);
ResultPost StateCuenta = PostCuentaApi(account).First();
if (StateCuenta.Id != null || StateCuenta.Id != "null")
{
user.IdCuenta = int.Parse(StateCuenta.Id);
_repository.Edit(user);
}
else
{
_repository.Delete(user);
user = null;
}
}
}
return(user);
}
/// <summary>
/// 新增T_PM_DictionaryInitInfo数据
/// </summary>
/// <param name="requestObject">返回响应结果对象，包括响应代码，新增操作结果</param>
/// <returns></returns>
public async Task <ResponseObject <bool> > PostAsync(RequestPost <TPMDictionaryInitInfoAddModel> requestObject)
{
try
{
//如果没有新增数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData,PostDataList不能都为null"));
}
var result = false;
//批量新增的优先级高于单条数据新增，且只会执行一个新增操作
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
var addList = _mapper.Map <List <TPMDictionaryInitInfoAddModel>, List <TPMDictionaryInitInfoDbModel> >(requestObject.PostDataList);
result = await _db.Instance.Insertable(addList).ExecuteCommandAsync() > 0;
}
else
{
var addModel = _mapper.Map <TPMDictionaryInitInfoDbModel>(requestObject.PostData);
result = await _db.Instance.Insertable(addModel).ExecuteCommandAsync() > 0;
}
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "新增数据失败!"));
}
catch (Exception ex)
{
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
public async Task <ResponseObject <List <string> > > ImportPrime(RequestPost <ImportPrimeModel> requestObject)
{
CurrentUser currentUser = TokenManager.GetCurentUserbyToken(HttpContext.Request.Headers);
return(await _inventoryReportService.ImportPrime(requestObject, currentUser));
//IFormFile
}
/// <summary>
/// 新增T_MM_BOMMain数据
/// </summary>
/// <param name="requestObject">Post请求参数</param>
/// <returns>返回响应结果对象，包括响应代码，新增操作结果</returns>
public async Task <ResponseObject <bool> > PostAsync(RequestPost <TMMBOMMainAddModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
//没有新增数据，返回错误信息
if (requestObject.PostData == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData不能为null"));
}
//开启事务
currDb.BeginTran();
//删除以前的数据
int PackageId = requestObject.PostData.PackageId;
TMMBOMMainDbModel oldDBMolde = _db.Instance.Queryable <TMMBOMMainDbModel>().Where(p => p.PackageId == PackageId).First();
if (oldDBMolde != null)
{
_db.Instance.Deleteable <TMMBOMDetailDbModel>().Where(p => p.MainId == PackageId).ExecuteCommand();
_db.Instance.Deleteable <TMMBOMMainDbModel>(oldDBMolde).ExecuteCommand();
}
//插入主表数据
var mapMainModel = _mapper.Map <TMMBOMMainDbModel>(requestObject.PostData);
var mainId = await currDb.Insertable(mapMainModel).ExecuteReturnIdentityAsync();
var materCache = BasicCacheGet.GetMaterial(currentUser);
//更新明细表外键ID值
requestObject.PostData.ChildList.ForEach(p => {
if (!materCache.Any(p1 => p1.MaterialName == p.MaterialName))
{
throw new Exception($"{p.MaterialName}物料不存在");
}
p.MainId = mainId;
});
//插入从表数据
var mapDetailModelList = _mapper.Map <List <TMMBOMDetailAddModel>, List <TMMBOMDetailDbModel> >(requestObject.PostData.ChildList);
var result = await currDb.Insertable(mapDetailModelList).ExecuteCommandAsync() > 0;
//提交事务
currDb.CommitTran();
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "新增数据失败!"));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
private void postBack(Associado OAssociado)
{
string json = JsonConvert.SerializeObject(OAssociado, new JsonSerializerSettings {
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
byte[] data = Encoding.ASCII.GetBytes("associado=" + json);
var ORequestPost = new RequestPost();
}
public static CuentaDTO ConverAccount(RequestPost entity, int iduser)
{
CuentaDTO account = new CuentaDTO()
{
Contraseña = entity.Cuenta.Password,
Mail = entity.Cuenta.Email,
IdTipoCuenta = 1,
IdUsuario = iduser
};
return(account);
}
public void UpdateUsuario()
{
//Arrange
int id = 0;
RequestPost user = new RequestPost();
UsuarioServices usuarioServices = new UsuarioServices(_repository.Object, _query.Object, _request.Object);
//Act
var result = usuarioServices.UpDateUsuario(id, user);
//Assert
Assert.IsNull(result);
}
private void postBack(Associado OAssociado)
{
try {
string json = JsonConvert.SerializeObject(OAssociado, new JsonSerializerSettings {
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
byte[] data = Encoding.ASCII.GetBytes("associado=" + json);
var ORequestPost = new RequestPost();
} catch (Exception ex) {
UtilLog.saveError(ex, "Erro ao realizar postback: OnAssociadoAlteradoHandler");
}
}
public static Usuario ConverUser(RequestPost entity)
{
Usuario user = new Usuario()
{
Nombre = entity.Nombre,
Apellido = entity.Apellido,
Dni = entity.Dni,
FechaNac = entity.FechaNac,
IdDireccion = 0,
IdCuenta = 0
};
return(user);
}
/// <summary>
/// 新增T_BM_SupplierFile数据
/// </summary>
/// <param name="requestObject">Post请求参数</param>
/// <returns>返回响应结果对象，包括响应代码，新增操作结果</returns>
public async Task <ResponseObject <bool> > PostAsync(RequestPost <TBMSupplierFileAddModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
//没有新增数据，返回错误信息
if (requestObject.PostData == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData不能为null"));
}
//开启事务
currDb.BeginTran();
//插入主表数据
var mapMainModel = _mapper.Map <TBMSupplierFileDbModel>(requestObject.PostData);
mapMainModel.CompanyId = currentUser.CompanyID;
if (_db.Instance.Queryable <TBMSupplierFileDbModel>().Any(p => p.SupplierCode == requestObject.PostData.SupplierCode && p.CompanyId == currentUser.CompanyID &&
SqlFunc.IsNull(p.DeleteFlag, false) == false)
)
{
throw new Exception("编码重复");
}
var mainId = await currDb.Insertable(mapMainModel).ExecuteReturnIdentityAsync();
if (requestObject.PostData.ChildList != null && requestObject.PostData.ChildList.Count() > 0)
{
//更新明细表外键ID值
requestObject.PostData.ChildList.ForEach(p => p.SupplierId = mainId);
//插入从表数据
var mapDetailModelList = _mapper.Map <List <TBMSupplierContactAddModel>, List <TBMSupplierContactDbModel> >(requestObject.PostData.ChildList);
var result = await currDb.Insertable(mapDetailModelList).ExecuteCommandAsync() > 0;
}
//提交事务
currDb.CommitTran();
//返回执行结果
return(ResponseUtil <bool> .SuccessResult(true));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
/// <summary>
/// 新增T_WM_ProfitMain数据
/// </summary>
/// <param name="requestObject">Post请求参数</param>
/// <param name="currentUser"></param>
/// <returns>返回响应结果对象，包括响应代码，新增操作结果</returns>
public async Task <ResponseObject <TWMProfitMainQueryModel> > PostAsync(RequestPost <TWMProfitMainAddModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
//没有新增数据，返回错误信息
if (requestObject.PostData == null)
{
return(ResponseUtil <TWMProfitMainQueryModel> .FailResult(null, "PostData不能为null"));
}
//开启事务
currDb.BeginTran();
//插入主表数据
var mapMainModel = _mapper.Map <TWMProfitMainDbModel>(requestObject.PostData);
mapMainModel.CompanyId = currentUser.CompanyID;
mapMainModel.OperatorId = currentUser.UserID;
mapMainModel.Number = requestObject.PostData.ChildList.Sum(p => p.ActualNumber);
mapMainModel.Amount = requestObject.PostData.ChildList.Sum(p => p.Amount);
var mainId = await currDb.Insertable(mapMainModel).ExecuteReturnIdentityAsync();
//更新明细表外键ID值
requestObject.PostData.ChildList.ForEach(p => p.MainId = mainId);
//插入从表数据
var mapDetailModelList = _mapper.Map <List <TWMProfitDetailAddModel>, List <TWMProfitDetailDbModel> >(requestObject.PostData.ChildList);
var result = await currDb.Insertable(mapDetailModelList).ExecuteCommandAsync() > 0;
//提交事务
currDb.CommitTran();
//返回执行结果
TWMProfitMainQueryModel returnObject = null;
if (result)
{
returnObject = await GetMainQueryModel(mainId);
}
return(result
? ResponseUtil <TWMProfitMainQueryModel> .SuccessResult(returnObject)
: ResponseUtil <TWMProfitMainQueryModel> .FailResult(null, "新增数据失败!"));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <TWMProfitMainQueryModel> .FailResult(null, ex.Message));
}
}
/// <summary>
/// 新增T_MM_BOMTempMain数据
/// </summary>
/// <param name="requestObject">Post请求参数</param>
/// <returns>返回响应结果对象，包括响应代码，新增操作结果</returns>
public async Task <ResponseObject <bool> > PostAsync(RequestPost <TMMBOMTempMainAddModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
//没有新增数据，返回错误信息
if (requestObject.PostData == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData不能为null"));
}
//开启事务
currDb.BeginTran();
//删除以前的数据
bool isExsit = _db.Instance.Queryable <TMMBOMTempMainDbModel>().Any(p => p.TempName == requestObject.PostData.TempName && p.CompanyId == currentUser.CompanyID);
if (isExsit)
{
return(ResponseUtil <bool> .FailResult(false, "模板名称已经存在!"));
}
//插入主表数据
var mapMainModel = _mapper.Map <TMMBOMTempMainDbModel>(requestObject.PostData);
mapMainModel.CompanyId = currentUser.CompanyID;
var mainId = await currDb.Insertable(mapMainModel).ExecuteReturnIdentityAsync();
//更新明细表外键ID值
//插入从表数据
var mapDetailModelList = _mapper.Map <List <TMMBOMTempDetailAddModel>, List <TMMBOMTempDetailDbModel> >(requestObject.PostData.ChildList);
mapDetailModelList.ForEach(p => p.MainId = mainId);
var result = await currDb.Insertable(mapDetailModelList).ExecuteCommandAsync() > 0;
//提交事务
currDb.CommitTran();
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "新增数据失败!"));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
public ActionResult <Usuario> Put(int id, RequestPost usuario)
{
try
{
var user = _services.UpDateUsuario(id, usuario);
return(new JsonResult(new ResponseGetGenery {
id = user.IdUsuario, Tipo = "Usuario Modificado", Status = true
})
{
StatusCode = 204
});
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
/// <summary>
/// 新增T_MM_PickApplyMain数据
/// </summary>
/// <param name="requestObject">Post请求参数</param>
/// <returns>返回响应结果对象，包括响应代码，新增操作结果</returns>
public async Task <ResponseObject <TMMPickApplyMainQueryModel> > PostAsync(RequestPost <TMMPickApplyMainAddModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
//没有新增数据，返回错误信息
if (requestObject.PostData == null)
{
return(ResponseUtil <TMMPickApplyMainQueryModel> .FailResult(null, "PostData不能为null"));
}
//开启事务
currDb.BeginTran();
//插入主表数据
var mapMainModel = _mapper.Map <TMMPickApplyMainDbModel>(requestObject.PostData);
mapMainModel.CompanyId = currentUser.CompanyID;
mapMainModel.OperatorId = currentUser.UserID;
mapMainModel.AuditStatus = 0;
mapMainModel.TransferFlag = true;
var mainId = await currDb.Insertable(mapMainModel).ExecuteReturnIdentityAsync();
//更新明细表外键ID值
requestObject.PostData.ChildList.ForEach(p => p.MainId = mainId);
//插入从表数据
var mapDetailModelList = _mapper.Map <List <TMMPickApplyDetailAddModel>, List <TMMPickApplyDetailDbModel> >(requestObject.PostData.ChildList);
var result = await currDb.Insertable(mapDetailModelList).ExecuteCommandAsync() > 0;
//提交事务
currDb.CommitTran();
var Reresult = await GetMainData(mainId, currentUser, false);
//返回执行结果
return(ResponseUtil <TMMPickApplyMainQueryModel> .SuccessResult(Reresult));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <TMMPickApplyMainQueryModel> .FailResult(null, ex.Message));
}
}
public Usuario EditarUsuario(int id, RequestPost user)
{
var nomb = user.Nombre;
var ape = user.Apellido;
var dni = user.Dni;
var fec = user.FechaNac;
var db = new QueryFactory(connection, sqlKataCompiler);
db.Query("Usuario")
.Where("idUsuario", id)
.Update(new
{
Nombre = nomb,
Apellido = ape,
Dni = dni,
FechaNac = fec,
});
return(Conversion.ConverUser(user));
}
/// <summary>
/// 新增T_MM_Formula数据
/// </summary>
/// <param name="requestObject">返回响应结果对象，包括响应代码，新增操作结果</param>
/// <param name="currUser">当前操作用户</param>
/// <returns></returns>
public async Task <ResponseObject <bool> > PostAsync(RequestPost <TMMFormulaAddModel> requestObject, CurrentUser currUser)
{
try
{
//如果没有新增数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostDataList不能都为null"));
}
var result = false;
//批量新增的优先级高于单条数据新增，且只会执行一个新增操作
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
}
else
{
var addModel = _mapper.Map <TMMFormulaDbModel>(requestObject.PostData);
if (_db.Instance.Queryable <TMMFormulaDbModel>().Any(p => p.FormulaName == addModel.FormulaName && p.CompanyId == currUser.CompanyID && SqlFunc.IsNull(p.DeleteFlag, false) == false))
{
throw new Exception("公式名重复");
}
addModel.CompanyId = currUser.CompanyID;
addModel.CreateId = currUser.UserID;
addModel.CreateTime = DateTime.Now;
result = await _db.Instance.Insertable(addModel).ExecuteCommandAsync() > 0;
}
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "新增数据失败!"));
}
catch (Exception ex)
{
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
/// <summary>
/// 新增T_SM_CompanyApply数据
/// </summary>
/// <param name="requestObject">返回响应结果对象，包括响应代码，新增操作结果</param>
/// <param name="currentUser"></param>
/// <returns></returns>
public async Task <ResponseObject <bool> > PostAsync(RequestPost <TSMCompanyApplyAddModel> requestObject, CurrentUser currentUser)
{
try
{
//如果没有新增数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData不能都为null"));
}
var result = false;
//批量新增的优先级高于单条数据新增，且只会执行一个新增操作
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
}
else
{
if (!_db.Instance.Queryable <TSMCompanyApplyDbModel>().Any(p => p.CompanyId == requestObject.PostData.CompanyId && p.AccountId == currentUser.UserID && p.ApplyStatus == 0))
{
var addModel = _mapper.Map <TSMCompanyApplyDbModel>(requestObject.PostData);
addModel.AccountId = currentUser.UserID;
addModel.ApplyStatus = 0;
addModel.ApplyTime = DateTime.Now;
await _db.Instance.Insertable(addModel).ExecuteCommandAsync();
var userAccount = _db.Instance.Queryable <TSMUserAccountDbModel>().Where(p => p.ID == addModel.AccountId).First();
//推送通知
PushNotice(addModel.AccountId, addModel.CompanyId, userAccount);
}
}
return(ResponseUtil <bool> .SuccessResult(true));
}
catch (Exception ex)
{
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
public async Task <ResponseObject <bool> > CheckIsExists(RequestPost <TSMCompanyCheckModel> requestObject, CurrentUser currentUser)
{
//如果没有新增数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(true, "PostData不能都为null"));
}
try
{
if (_db.Instance.Queryable <TSMCompanyDbModel>().Any(p => p.CompanyName == requestObject.PostData.CompanyName))
{
return(ResponseUtil <bool> .SuccessResult(true));
}
else
{
return(ResponseUtil <bool> .SuccessResult(false));
}
}
catch (Exception ex)
{
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
/// <summary>
/// 新增P_Test_UserSeed数据
/// </summary>
/// <param name="requestObject">返回响应结果对象，包括响应代码，新增操作结果</param>
/// <returns></returns>
public async Task <ResponseObject <bool> > PostAsync(RequestPost <PTestUserSeedAddModel> requestObject)
{
try
{
//如果没有新增数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData不能都为null"));
}
var result = false;
//批量新增的优先级高于单条数据新增，且只会执行一个新增操作
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
}
else
{
var addModel = _mapper.Map <PTestUserSeedDbModel>(requestObject.PostData);
addModel.CreateTime = DateTime.Now;
result = await _db.Instance.Insertable(addModel).ExecuteCommandAsync() > 0;
}
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "新增数据失败!"));
}
catch (Exception ex)
{
if (ex.Message.Contains("Duplicate entry"))
{
return(ResponseUtil <bool> .FailResult(false, "用户已经存在"));
}
else
{
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
}
/// <summary>
/// 新增T_MM_ColorSolutionMain数据
/// </summary>
/// <param name="requestObject">Post请求参数</param>
/// <returns>返回响应结果对象，包括响应代码，新增操作结果</returns>
public async Task <ResponseObject <bool> > PostAsync(RequestPost <TMMColorSolutionMainAddModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
//没有新增数据，返回错误信息
if (requestObject.PostData == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData不能为null"));
}
var allDic = BasicCacheGet.GetDic(currentUser);
var dicUnit = allDic.Where(p => p.TypeName == "计量单位" && p.DicValue == "个").FirstOrDefault();
if (dicUnit == null)
{
return(ResponseUtil <bool> .FailResult(false, "请设置'个'的计量单位 "));
}
var MaterialTypeDic = allDic.Where(p => p.TypeName == "物料分类" && p.DicValue == "产品").FirstOrDefault();
if (MaterialTypeDic == null)
{
return(ResponseUtil <bool> .FailResult(false, "请设置'产品'的物料分类 "));
}
//开启事务
currDb.BeginTran();
//插入主表数据
var mapMainModel = _mapper.Map <TMMColorSolutionMainDbModel>(requestObject.PostData);
if (_db.Instance.Queryable <TMMColorSolutionMainDbModel>().Any(p => p.SolutionCode == requestObject.PostData.SolutionCode && p.PackageId == requestObject.PostData.PackageId &&
p.DeleteFlag == false && p.CompanyId == currentUser.CompanyID))
{
throw new Exception("编号重复");
}
mapMainModel.CompanyId = currentUser.CompanyID;
var mainId = await currDb.Insertable(mapMainModel).ExecuteReturnIdentityAsync();
TBMPackageDbModel tBMPackageDbModel = _db.Instance.Queryable <TBMPackageDbModel>().Where(p => p.ID == requestObject.PostData.PackageId).First();
//生成物料
TBMMaterialFileDbModel material = new TBMMaterialFileDbModel();
material.MaterialCode = CreateNo(currentUser.CompanyID);
material.BaseUnitId = dicUnit.ID;
material.MaterialTypeId = MaterialTypeDic.ID;
material.MaterialName = tBMPackageDbModel.DicValue;
material.DeleteFlag = false;
material.CompanyId = currentUser.CompanyID;
material.ColorSolutionID = mainId;
material.PackageID = requestObject.PostData.PackageId;
material.Remark = requestObject.PostData.SolutionCode;
_db.Instance.Insertable(material).ExecuteReturnIdentity();
ClearCache(currentUser);//更新缓存
//更新明细表外键ID值
requestObject.PostData.ChildList.ForEach(p => p.MainId = mainId);
//插入从表数据
var mapDetailModelList = _mapper.Map <List <TMMColorSolutionDetailAddModel>, List <TMMColorSolutionDetailDbModel> >(requestObject.PostData.ChildList);
var result = await currDb.Insertable(mapDetailModelList).ExecuteCommandAsync() > 0;
//提交事务
currDb.CommitTran();
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "新增数据失败!"));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
public async Task <ResponseObject <bool> > Post(RequestPost <TPMSeedUsersAddModel> requestObject)
{
return(await _service.PostAsync(requestObject));
}
/// <summary>
/// 新增T_SM_UserAccount数据
/// </summary>
/// <param name="requestObject">返回响应结果对象，包括响应代码，新增操作结果</param>
/// <returns></returns>
public async Task <ResponseObject <string> > PostAsync(RequestPost <TSMUserAccountAddModel> requestObject)
{
var currDb = _db.Instance;
try
{
//如果没有新增数据，返回错误信息
if (requestObject.PostData == null && requestObject.PostDataList == null)
{
return(ResponseUtil <string> .FailResult(null, "PostData,PostDataList不能都为null"));
}
var result = false;
string token = string.Empty;
currDb.BeginTran();
//批量新增的优先级高于单条数据新增，且只会执行一个新增操作
if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
{
}
else
{
//注册账号信息
var addModel = _mapper.Map <TSMUserAccountDbModel>(requestObject.PostData);
addModel.Salt = RandCodeCreate.GenerateRandomNumber(32);
addModel.Passwd = EncryptUtil.EnAESBykey(addModel.Passwd, addModel.Salt);
addModel.Status = 1;
if (string.IsNullOrWhiteSpace(addModel.EmailAccount))
{
addModel.EmailAccount = null;
}
if (string.IsNullOrWhiteSpace(addModel.TelAccount))
{
addModel.TelAccount = null;
}
//生成用户详情记录
TSMUserInfoDbModel tSMUserInfoDbModel = new TSMUserInfoDbModel();
int cid = await _db.Instance.Insertable(tSMUserInfoDbModel).ExecuteReturnIdentityAsync();
addModel.UserInfoId = cid;
int id = _db.Instance.Insertable(addModel).ExecuteReturnIdentity();
var palyloads = new Dictionary <string, object>
{
{ "UserID", id },
{ "ID", Guid.NewGuid().ToString() },
{ "CompanyID", 0 },
{ "UserName", addModel.AccountName }
};
token = TokenManager.CreateTokenByHandler(palyloads, 60 * 24);
currDb.CommitTran();
}
//返回执行结果
return(ResponseUtil <string> .SuccessResult(token));
}
catch (Exception ex)
{
//返回异常结果
currDb.RollbackTran();
return(ResponseUtil <string> .FailResult(null, ex.Message));
}
}
/// <summary>
/// 新增T_PSM_PurchaseOrderMain数据
/// </summary>
/// <param name="requestObject">Post请求参数</param>
/// <param name="currentUser"></param>
/// <returns>返回响应结果对象，包括响应代码，新增操作结果</returns>
public async Task <ResponseObject <TPSMPurchaseOrderMainQueryModel> > PostAsync(RequestPost <TPSMPurchaseOrderMainAddModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
//没有新增数据，返回错误信息
if (requestObject.PostData == null)
{
return(ResponseUtil <TPSMPurchaseOrderMainQueryModel> .FailResult(null, "PostData不能为null"));
}
//开启事务
currDb.BeginTran();
//插入主表数据
var mapMainModel = _mapper.Map <TPSMPurchaseOrderMainDbModel>(requestObject.PostData);
mapMainModel.OperatorId = currentUser.UserID;
mapMainModel.CompanyId = currentUser.CompanyID;
mapMainModel.PurchaseNum = requestObject.PostData.ChildList.Sum(p => p.PurchaseNum);
mapMainModel.PurchaseAmount = requestObject.PostData.ChildList.Sum(p => p.PurchaseAmount);
var mainId = await currDb.Insertable(mapMainModel).ExecuteReturnIdentityAsync();
//更新明细表外键ID值
requestObject.PostData.ChildList.ForEach(p => p.MainId = mainId);
//插入从表数据
var mapDetailModelList = _mapper.Map <List <TPSMPurchaseOrderDetailAddModel>,
List <TPSMPurchaseOrderDetailDbModel> >(requestObject.PostData.ChildList);
var result = await currDb.Insertable(mapDetailModelList).ExecuteCommandAsync() > 0;
//如果是生产采购申请单转采购单，需要更新转单及数量信息
if (mapMainModel.SourceId > 0)
{
var transList = await GetTransDetailsAsync((int)mapMainModel.SourceId, mapDetailModelList, currentUser);
foreach (var item in transList)
{
await _db.Instance.Updateable <TMMPurchaseApplyDetailDbModel>()
.SetColumns(p => p.TransNum == p.TransNum - item.TransNum)
.Where(p => p.MainId == item.MainId && p.MaterialId == item.MaterialId)
.ExecuteCommandAsync();
}
FalseTMMPurchaseApplyMain(mapMainModel.SourceId.Value);
}
else
{
var detailModelLists = _db.Instance.Queryable <TPSMPurchaseOrderDetailDbModel>().Where(p => p.MainId == requestObject.PostData.ID).ToList();
var groupEntity = from p in detailModelLists
group p by new { p.MaterialId } into g
select new { g.Key, MaxPrice = g.Max(p => p.UnitPrice), MinPrice = g.Min(p => p.UnitPrice) };
var differentEntity = groupEntity.Where(p => p.MaxPrice != p.MinPrice).ToList();
if (differentEntity.Count() > 0)
{
var meList = BasicCacheGet.GetMaterial(currentUser);
string error = string.Join(",", differentEntity.Select(p => meList.Where(p1 => p1.ID == p.Key.MaterialId).FirstOrDefault()?.MaterialName));
throw new Exception($"{error}商品的单价不一致，请保证相同商品价格一致性");
}
}
//提交事务
currDb.CommitTran();
TPSMPurchaseOrderMainQueryModel returnObject = null;
if (result)
{
var tempreturnObject = await GetWholeMainData(mainId, currentUser);
returnObject = tempreturnObject.Data;
}
//返回执行结果
return(result ? ResponseUtil <TPSMPurchaseOrderMainQueryModel> .SuccessResult(returnObject)
: ResponseUtil <TPSMPurchaseOrderMainQueryModel> .FailResult(null, "新增数据失败!"));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <TPSMPurchaseOrderMainQueryModel> .FailResult(null, ex.Message));
}
}
public async Task <ResponseObject <bool> > Post(RequestPost <TMMBOMMainAddNewModel> requestObject)
{
var user = TokenManager.GetCurentUserbyToken(Request.Headers);
return(await _service.PostAsync(requestObject, user));
}
public ResponseObject <TWMCountModel> GetAmount(RequestPost <TWMStaQuery> requestPost)
{
return(ResponseUtil <TWMCountModel> .SuccessResult(_service.GeTWMCountModel(requestPost.PostData)));
}
public async Task <ResponseObject <TSSMSalesOrderMainQueryModel> > Post(RequestPost <TSSMSalesOrderMainAddModel> requestObject)
{
var currUser = TokenManager.GetCurentUserbyToken(Request.Headers);
return(await _service.PostAsync(requestObject, currUser));
}
public async Task <ResponseObject <bool> > PostAsync(RequestPost <TMMBOMMainAddNewModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
//没有新增数据，返回错误信息
if (requestObject.PostData == null)
{
return(ResponseUtil <bool> .FailResult(false, "PostData不能为null"));
}
//开启事务
currDb.BeginTran();
//删除以前的数据
int PackageId = requestObject.PostData.PackageId;
TMMBOMMainDbModel oldDBMolde = _db.Instance.Queryable <TMMBOMMainDbModel>().Where(p => p.PackageId == PackageId).First();
if (oldDBMolde != null)
{
_db.Instance.Deleteable <TMMBOMDetailDbModel>().Where(p => p.MainId == PackageId).ExecuteCommand();
_db.Instance.Deleteable <TMMBOMMainDbModel>(oldDBMolde).ExecuteCommand();
}
//插入主表数据
var mapMainModel = _mapper.Map <TMMBOMMainDbModel>(requestObject.PostData);
var mainId = await currDb.Insertable(mapMainModel).ExecuteReturnIdentityAsync();
var materCache = BasicCacheGet.GetMaterial(currentUser);
#region 处理配色项目
List <string> ItemList = requestObject.PostData.ChildList.Select(p => p.ItemName).Distinct().ToList();
Dictionary <string, int> itemToId = new Dictionary <string, int>();
foreach (string name in ItemList)
{
var colorItem = _db.Instance.Queryable <TMMPackageColorItemDbModel>().Where(p => p.CompanyId == currentUser.CompanyID && p.ItemName == name && p.PackageId == PackageId).First();
int ItemId = 0;
if (colorItem == null)
{
TMMPackageColorItemDbModel temp = new TMMPackageColorItemDbModel();
temp.CompanyId = currentUser.CompanyID;
temp.DeleteFlag = false;
temp.PackageId = mapMainModel.PackageId;
temp.ItemName = name;
ItemId = _db.Instance.Insertable(temp).ExecuteReturnIdentity();
}
else
{
ItemId = colorItem.ID;
if (colorItem.DeleteFlag == true)
{
colorItem.DeleteFlag = false;
_db.Instance.Updateable(colorItem).ExecuteCommand();
}
}
itemToId.Add(name, ItemId);
}
var itemIDs = _db.Instance.Queryable <TMMPackageColorItemDbModel>().Where(p => p.CompanyId == currentUser.CompanyID && p.PackageId == PackageId &&
!ItemList.Contains(p.ItemName)).Select(p => p.ID).ToList();
_db.Instance.Updateable <TMMPackageColorItemDbModel>().Where(p => itemIDs.Contains(p.ID)).
SetColumns(it => new TMMPackageColorItemDbModel {
DeleteFlag = true
}).ExecuteCommand();
_db.Instance.Deleteable <TMMColorSolutionDetailDbModel>().Where(p => SqlFunc.Subqueryable <TMMColorSolutionMainDbModel>().
Where(p1 => p1.ID == p.MainId && p1.CompanyId == currentUser.CompanyID && p1.PackageId == PackageId).Any() && itemIDs.Contains(p.ItemId));
#endregion
#region 处理部位
List <string> PartList = requestObject.PostData.ChildList.Where(p => !string.IsNullOrWhiteSpace(p.PartName)).Select(p => p.PartName).Distinct().ToList();
Dictionary <string, int> partId = new Dictionary <string, int>();
var dictionaryType = _db.Instance.Queryable <TBMDictionaryTypeDbModel>().Where(p => p.CompanyId == currentUser.CompanyID && p.TypeName == "部位档案").First();
foreach (string name in PartList)
{
var dicItem = _db.Instance.Queryable <TBMDictionaryDbModel>().Where(p => p.CompanyId == currentUser.CompanyID && p.DicValue == name).First();
int dicID = 0;
if (dicItem == null)
{
TBMDictionaryDbModel temp = new TBMDictionaryDbModel();
temp.CompanyId = currentUser.CompanyID;
temp.DeleteFlag = false;
temp.TypeId = dictionaryType.ID;
temp.DicValue = name;
dicID = _db.Instance.Insertable(temp).ExecuteReturnIdentity();
}
else
{
dicID = dicItem.ID;
}
partId.Add(name, dicID);
}
#endregion
List <TMMBOMDetailDbModel> deatail = new List <TMMBOMDetailDbModel>();
foreach (TMMBOMDetailAddNewModel item in requestObject.PostData.ChildList)
{
TMMBOMDetailDbModel tMMBOMDetailDbModel = ExpressionGenericMapper <TMMBOMDetailAddNewModel, TMMBOMDetailDbModel> .Trans(item);
tMMBOMDetailDbModel.MainId = mainId;
tMMBOMDetailDbModel.ItemId = itemToId[item.ItemName];
if (!string.IsNullOrWhiteSpace(item.PartName))
{
tMMBOMDetailDbModel.PartId = partId[item.PartName];
}
if (!materCache.Any(p1 => p1.MaterialName == item.MaterialName))
{
throw new Exception($"{item.MaterialName}物料不存在");
}
deatail.Add(tMMBOMDetailDbModel);
}
//插入从表数据
// var mapDetailModelList = _mapper.Map<List<TMMBOMDetailAddNewModel>, List<TMMBOMDetailDbModel>>(requestObject.PostData.ChildList);
var result = await currDb.Insertable(deatail).ExecuteCommandAsync() > 0;
//提交事务
currDb.CommitTran();
//返回执行结果
return(result ? ResponseUtil <bool> .SuccessResult(true) : ResponseUtil <bool> .FailResult(false, "新增数据失败!"));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <bool> .FailResult(false, ex.Message));
}
}
/// <summary>
/// 新增T_WM_ProductionWhMain数据
/// </summary>
/// <param name="requestObject">Post请求参数</param>
/// <returns>返回响应结果对象，包括响应代码，新增操作结果</returns>
public async Task <ResponseObject <TWMProductionWhMainQueryModel> > PostAsync(RequestPost <TWMProductionWhMainAddModel> requestObject, CurrentUser currentUser)
{
var currDb = _db.Instance;//事务需要使用同一个 SqlSugarClient对象实例
try
{
//没有新增数据，返回错误信息
if (requestObject.PostData == null)
{
return(ResponseUtil <TWMProductionWhMainQueryModel> .FailResult(null, "PostData不能为null"));
}
//开启事务
currDb.BeginTran();
//插入主表数据
var mapMainModel = _mapper.Map <TWMProductionWhMainDbModel>(requestObject.PostData);
mapMainModel.CompanyId = currentUser.CompanyID;
mapMainModel.OperatorId = currentUser.UserID;
mapMainModel.Number = requestObject.PostData.ChildList.Sum(p => p.ActualNum);
mapMainModel.Amount = requestObject.PostData.ChildList.Sum(p => p.Amount);
mapMainModel.AuditStatus = 0;
mapMainModel.WarehousingType = 1;
var mainId = await currDb.Insertable(mapMainModel).ExecuteReturnIdentityAsync();
//更新明细表外键ID值
requestObject.PostData.ChildList.ForEach(p => p.MainId = mainId);
//插入从表数据
var mapDetailModelList = _mapper.Map <List <TWMProductionWhDetailAddModel>, List <TWMProductionWhDetailDbModel> >(requestObject.PostData.ChildList);
var listItem = _db.Instance.Queryable <TMMWhApplyDetailDbModel>().Where(t => t.MainId == mapMainModel.SourceId).ToList();
var materList = BasicCacheGet.GetMaterial(currentUser);
List <TMMWhApplyDetailDbModel> toEdit = new List <TMMWhApplyDetailDbModel>();
foreach (var item in mapDetailModelList)
{
var procudeMaterial = listItem.Where(p => p.ID == item.ProOrderDetailId).FirstOrDefault(); //生产单明细
var me = materList.Where(p => p.ID == item.MaterialId).FirstOrDefault(); //物料
decimal wareTransNum = UnitChange.TranserUnit(me, UnitType.Produce, UnitType.Warehouse, procudeMaterial.TransNum); //可转的数量（仓库单位）
decimal proNum = UnitChange.TranserUnit(me, UnitType.Warehouse, UnitType.Produce, item.ActualNum); //实际转数量（生产单位）
if (item.ActualNum > wareTransNum)
{
throw new Exception($"物料代码{me.MaterialCode} 入库数量不能大于{wareTransNum }");
}
else if (item.ActualNum == wareTransNum)
{
item.ProActualNum = procudeMaterial.TransNum;
procudeMaterial.TransNum = 0;
}
else
{
if (proNum > procudeMaterial.TransNum)
{
item.ProActualNum = procudeMaterial.TransNum;
procudeMaterial.TransNum = 0;
}
else
{
item.ProActualNum = proNum;
procudeMaterial.TransNum = procudeMaterial.TransNum - proNum;
}
}
toEdit.Add(procudeMaterial);
}
if (toEdit != null && toEdit.Count() > 0)
{
_db.Instance.Updateable <TMMWhApplyDetailDbModel>(toEdit).ExecuteCommand();
}
if (!_db.Instance.Queryable <TMMWhApplyDetailDbModel>().Any(p => p.TransNum > 0 && p.MainId == mapMainModel.SourceId))
{
_db.Instance.Updateable <TMMWhApplyMainDbModel>().Where(p => p.ID == mapMainModel.SourceId).SetColumns(p => p.TransferFlag == false).ExecuteCommand();
}
var result = await currDb.Insertable(mapDetailModelList).ExecuteCommandAsync() > 0;
//提交事务
currDb.CommitTran();
var res = await GetWholeMainData(mainId, currentUser);
//返回执行结果
return(ResponseUtil <TWMProductionWhMainQueryModel> .SuccessResult(res.Data));
}
catch (Exception ex)
{
//回滚事务
currDb.RollbackTran();
//返回异常结果
return(ResponseUtil <TWMProductionWhMainQueryModel> .FailResult(null, ex.Message));
}
}
public async Task <ResponseObject <TSMUserLoginResult> > LoginPost(RequestPost <TSMUserAccountAddModel> requestObject)
{
ResponseObject <TSMUserLoginResult> result;
result = await _service.LoginAsync(requestObject);
var task = Task.Factory.StartNew(() =>
{
try
{
bool isSucess = string.IsNullOrEmpty(result.Data.Token) ? false : true;
if (isSucess == true)
{
string token = result.Data.Token.Split('.')[1];
var payLoad = JsonConvert.DeserializeObject <Dictionary <string, object> >(Base64UrlEncoder.Decode(token));
int userID = Convert.ToInt32(payLoad["UserID"]);
string ID = payLoad["ID"].ToString();
int CompanyID = Convert.ToInt32(payLoad["CompanyID"]);
if (CompanyID == 0) //没有加入公司的员工不保存登陆日志
{
return;
}
//写 登陆状态到redis
var redis = CacheFactory.Instance(CacheType.Redis);
UserStatus userStatus = new UserStatus()
{
ID = ID, LastRefreshTime = DateTime.Now
};
string redisKey = string.Format(CacheKeyString.UserLoginAllKey, userID, CompanyID, ID);
redis.AddOrUpdateKey <UserStatus>(redisKey, userStatus, 90);
//写登陆日志到 MangoDB
SMUserInfo sMUserInfo = SMCurentUserManager.GetCurentUserID(userID, _db.Instance);
string ipAddress = Request.HttpContext.Connection.RemoteIpAddress.ToString();
LoginLog loginLog = new LoginLog();
loginLog.LoginID = ID;
loginLog.Account = sMUserInfo.AccountName;
loginLog.CompanyID = sMUserInfo.CompanyId.Value;
loginLog.Description = isSucess ? LoginTypeEum.LoginSuccess : LoginTypeEum.LoginFail;
loginLog.IpAddress = ipAddress;
loginLog.LoginTime = DateTime.Now;
loginLog.RealName = sMUserInfo == null ? "" : sMUserInfo.RealName;
loginLog.RoleName = sMUserInfo == null ? "" : sMUserInfo.RoleName;
loginLog.Status = isSucess ? LoginStatusEum.Logining : LoginStatusEum.LogOut;
MongoDbUtil.AddDoc(loginLog);
}
else
{
//LoginLog loginLog = new LoginLog();
//loginLog.ID = Guid.NewGuid().ToString();
//loginLog.Account = sMUserInfo.AccountName;
//loginLog.CompanyID = sMUserInfo.CompanyId.Value;
//loginLog.Description = isSucess ? LoginTypeEum.LoginSuccess : LoginTypeEum.LoginFail;
//loginLog.IpAddress = ipAddress;
//loginLog.LoginTime = DateTime.Now;
//loginLog.RealName = sMUserInfo?.RealName;
//loginLog.RoleName = sMUserInfo?.RoleName;
//loginLog.Status = isSucess ? LoginStatusEum.Logining : LoginStatusEum.LogOut;
//MongoDbUtil.AddDoc(loginLog);
}
}
catch (Exception EX)
{
}
});
return(result);
}
