public async Task <BaseResponse> AddSchemaAsync(int typeId, TypeSchemaAddViewModel req, string account) { //验证类型是否可以添加 var t = await _tr.FindAsync(typeId); if (t.Status == TypeStatus.Root) { return(new BaseResponse { Success = false, Message = "目录节点类型不能添加具体数据" }); } //检查是否存在同名 var data = await _ts.Find(a => a.TypeId == typeId && a.ParentId == req.ParentId && a.Name == req.Name).FirstOrDefaultAsync(); if (data != null) { return(new BaseResponse { Success = false, Message = "已存在相同名称的模式" }); } var define = await _td.FindAsync(req.DataDefineId); //检查所对应的key值是否存在 if (define == null) { return(new BaseResponse { Success = false, Message = "输入的数据定义不存在" }); } try { if (req.ParentId == 0) { req.ParentId = null; } var entity = _mapper.Map <TypeSchemaModel>(req); entity.Create = account; entity.TypeId = typeId; entity.Key = define.DataKey; await _ts.AddAsync(entity); _log.LogInformation($"{account}添加模式成功,模式标示为{entity.Id}"); return(new HandleResponse <int> { Success = true, Message = "添加模式成功", Key = entity.Id }); } catch (Exception ex) { _log.LogError($"{account}添加模式失败,失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}"); return(new BaseResponse { Success = false, Message = "添加模式失败,请联系管理员" }); } }
public async Task <BaseResponse> AddTypeHarewareConfigAsync(int typeId, TypeHardwareConfigAddDto req, string account) { //验证类型是否可以添加 var t = await _tr.FindAsync(typeId); if (t.Status == TypeStatus.Root) { return(new BaseResponse { Success = false, Message = "目录节点类型不能添加具体数据" }); } var dataDefine = await _tdr.FindAsync(req.DataDefineId); if (dataDefine == null) { return(new BaseResponse { Success = false, Message = "输入的数据定义编号不存在" }); } var data = await _th.Find(a => a.TypeId == typeId && a.Key == dataDefine.DataKey).FirstOrDefaultAsync(); if (data != null) { return(new BaseResponse { Success = false, Message = "该类型下已存在相同的配置数据" }); } try { var entity = _mapper.Map <TypeHardwareConfigModel>(req); entity.TypeId = typeId; entity.Create = account; entity.Key = dataDefine.DataKey; entity.KeyName = dataDefine.DataName; entity.Unit = dataDefine.Unit; entity.Format = dataDefine.Format; await _th.AddAsync(entity); _log.LogInformation($"{account}添加标示为:{entity.Id}的类型PLC配置数据成功"); return(new HandleResponse <int> { Success = true, Message = "添加配置数据成功", Key = entity.Id }); } catch (Exception ex) { _log.LogError($"{account}添加类型PLC配置数据失败,失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}"); return(new BaseResponse { Success = false, Message = "添加类型PLC配置数据失败,请联系管理员" }); } }
public async Task <BaseResponse> AddStatistics(int typeId, TypeStatisticsAddViewModel req, string account) { //验证类型是否可以添加 var t = await _tr.FindAsync(typeId); if (t.Status == TypeStatus.Root) { return(new BaseResponse { Success = false, Message = "目录节点类型不能添加具体数据" }); } //验证数据定义是否存在 var data = await _tdd.FindAsync(req.DataDefineId); if (data == null) { return(new BaseResponse { Success = false, Message = "输入类型的数据定义不存在" }); } //验证统计名称和数据定义key是否存在 var count = _tsr.Find(a => a.TypeId == typeId && (a.Name == req.Name || a.DataKey == data.DataKey)).Count(); if (count > 0) { return(new BaseResponse { Success = false, Message = "此类型下已存在相同名称的统计数据或者相同的key值" }); } try { var entity = _mapper.Map <TypeStatisticsInfoModel>(req); entity.TypeId = typeId; entity.Create = account; entity.DataKey = data.DataKey; entity.SUnit = data.Unit; await _tsr.AddAsync(entity); _log.LogInformation($"{account}添加标示为{entity.Id}的类型统计数据成功"); return(new HandleResponse <int> { Success = true, Message = "添加类型统计数据成功", Key = entity.Id }); } catch (Exception ex) { _log.LogError($"{account}添加类型统计数据失败,失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}"); return(new BaseResponse { Success = false, Message = "添加类型统计数据失败,请联系管理员" }); } }
public async Task <IActionResult> Recipe(RecipeViewModel model) { if (model.Ingredients == null) { ModelState.AddModelError("Ingredients", "Należy dodać chociażby jeden składnik"); } if (!ModelState.IsValid) { if (ModelState["TypeId"].Errors.Count != 0) { ModelState.Remove("TypeId"); ModelState.SetModelValue("TypeId", new ValueProviderResult("Należy wybrać typ przepisu", CultureInfo.InvariantCulture)); ModelState.AddModelError("TypeId", "Należy wybrać typ przepisu"); } model.Types = await typeRepository.Types(); return(View("Recipe", model)); } if (model.Image != null) { if (model.Image.Length > 0) { using (var stream = new MemoryStream()) { await model.Image.CopyToAsync(stream); model.Recipe.Img = stream.ToArray(); } } } IEnumerable <Product> productsToIngredients = await productRepository.FindAllAsync(p => model.Ingredients.Any(i => i.Id == p.Id)); model.Recipe.Ingredients = new List <Ingredient>(); foreach (var product in productsToIngredients) { model.Recipe.Ingredients.Add(new Ingredient { Product = product, Quantity = model.Ingredients.Where(i => i.Id == product.Id).First().Quantity }); } model.Recipe.Type = await typeRepository.FindAsync(t => t.Id == model.TypeId); recipeRepository.Add(model.Recipe); return(RedirectToAction("Recipe")); }
/// <summary> /// 验证该类型下是否能添加相关的信息 /// </summary> /// <param name="Id">类型标示</param> /// <param name="GroupId">类型所属的组织编号</param> /// <param name="status">类型是否能是叶子节点</param> /// <returns>类型是否存在</returns> public async Task <TypeCheckDto> CheckTypeAsync(int Id) { TypeCheckDto dto = new TypeCheckDto(); var data = await _tr.FindAsync(Id); if (data == null) { dto.GroupId = null; dto.Status = 0; dto.IsExist = false; } else { dto.GroupId = data.GroupId; dto.Status = (int)data.Status; dto.IsExist = true; } return(dto); }
//调用者检查类型是否存在 public async Task<BaseResponse> AddTypeDataDefine(int typeId, TypeDataDefineAddViewModel req, string account) { //验证类型是否可以添加 var t = await _tr.FindAsync(typeId); if (t.Status == TypeStatus.Root) { return new BaseResponse { Success = false, Message = "目录节点类型不能添加具体数据" }; } var dataDefine = await _ddl.FindAsync(req.DataDefineId); if (dataDefine == null) { return new BaseResponse { Success = false, Message = "输入的数据类型定义标示不存在" }; } //检查是否已存在相同key值 var ret = await _td.Find(a => a.TypeId == typeId && a.DataKey == dataDefine.DataKey).FirstOrDefaultAsync(); if (ret != null) { return new BaseResponse { Success = false, Message = "该类型下存在相同key值" }; } try { var entity = _mapper.Map<TypeDataDefineModel>(req); entity.Create = account; entity.TypeId = typeId; entity.DataKey = dataDefine.DataKey; entity.DataName = dataDefine.DataName; entity.Unit = dataDefine.Unit; entity.DataType = dataDefine.DataType; entity.DefaultValue = dataDefine.DefaultValue; entity.Format = dataDefine.Format; entity.Model = (DataDefineModel)dataDefine.Model; entity.Category = dataDefine.Category; await _td.AddAsync(entity); _log.LogInformation($"{account}添加类型数据定义{entity.DataKey}成功"); return new HandleResponse<int> { Success = true, Message = "添加数据成功", Key = entity.Id }; } catch (Exception ex) { _log.LogError($"{account}添加类型数据定义{dataDefine.DataKey}失败,失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}"); return new BaseResponse { Success = false, Message = "添加数据失败,请联系管理员" }; } }
public async Task <BaseResponse> AddTypeUpdateFile(int typeId, TypeUpdateFileAddViewModel req, string account, string url) { //验证类型是否可以添加 var t = await _tr.FindAsync(typeId); if (t.Status == TypeStatus.Root) { return(new BaseResponse { Success = false, Message = "目录节点类型不能添加具体数据" }); } //是否存在重名 var ret = await _tu.Find(a => a.TypeId == typeId && a.Name == req.Name).FirstOrDefaultAsync(); if (ret != null) { return(new BaseResponse { Success = false, Message = "已存在相同名称的升级文件" }); } try { var dto = _mapper.Map <TypeUpdateFileModel>(req); dto.Create = account; dto.Url = url; dto.TypeId = typeId; await _tu.AddAsync(dto); _log.LogInformation($"{account}添加Id为{dto.Id}名称为{dto.Name}的升级文件成功"); return(new HandleResponse <int> { Success = true, Message = "添加升级文件成功", Key = dto.Id }); } catch (Exception ex) { _log.LogError($"{account}添加升级文件{req.Name}失败,失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}"); return(new BaseResponse { Success = false, Message = "添加失败文件失败,请联系管理员" }); } }
public async Task <BaseResponse> AddTypeImage(int typeId, TypeImageAddViewModel req, string account, string path) { //验证类型是否可以添加 var t = await _tr.FindAsync(typeId); if (t.Status == TypeStatus.Root) { return(new BaseResponse { Success = false, Message = "目录节点类型不能添加具体数据" }); } //验证是否重名 var ret = await _ti.Find(a => a.TypeId == typeId && a.ImageName == req.ImageName).FirstOrDefaultAsync(); if (ret != null) { return(new BaseResponse { Success = false, Message = "该类型下已存在相同名称的图片" }); } try { var dto = _mapper.Map <TypeImageModel>(req); dto.TypeId = typeId; dto.Url = path; dto.Create = account; await _ti.AddAsync(dto); _log.LogInformation($"{account}添加类型图片{dto.Id},名称为{dto.ImageName}成功"); return(new HandleResponse <int> { Success = true, Message = "添加类型图片成功", Key = dto.Id }); } catch (Exception ex) { _log.LogError($"{account}添加类型图片失败,失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}"); return(new BaseResponse { Success = false, Message = "添加类型图片失败" }); } }
/// <summary> /// 添加类型分组数据 /// </summary> /// <param name="Account">操作人</param> /// <param name="TypeId">类型编号</param> /// <param name="req">类型分组数据</param> /// <returns></returns> public async Task <BaseResponse> AddTypeClassAsync(string Account, int TypeId, TypeClassAddDto req) { //验证类型是否可以添加 var t = await _tr.FindAsync(TypeId); if (t.Status == TypeStatus.Root) { return(new BaseResponse { Success = false, Message = "目录节点类型不能添加具体数据" }); } //验证是否重名 var data = await _tcr.Find(a => a.TypeId == TypeId && a.Name == req.Name).FirstOrDefaultAsync(); if (data != null) { return(new BaseResponse { Success = false, Message = "已存在相同名称的类型分组,请确认" }); } try { var entity = _mapper.Map <TypeClassModel>(req); entity.Create = Account; entity.TypeId = TypeId; await _tcr.AddAsync(entity); _log.LogInformation($"{Account}添加标识为{entity.Id}的类型分组数据成功"); return(new HandleResponse <int> { Key = entity.Id, Success = true, Message = "添加数据成功" }); } catch (Exception ex) { _log.LogError($"{Account}添加类型分组失败,失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}"); return(new BaseResponse { Success = false, Message = "添加类型分组数据失败,请联系管理员" }); } }
public async Task <BaseResponse> AddAsync(int typeId, TypeConfigAddViewModel req, string account) { //验证类型是否可以添加 var t = await _tr.FindAsync(typeId); if (t.Status == TypeStatus.Root) { return(new BaseResponse { Success = false, Message = "目录节点类型不能添加具体数据" }); } //验证是否重名 var data = await _tc.Find(a => a.TypeId == typeId && a.DataName == req.DataName).FirstOrDefaultAsync(); if (data != null) { return(new BaseResponse { Success = true, Message = "已存在相同名称的类型配置,请确认" }); } try { var entity = _mapper.Map <TypeConfigModel>(req); entity.Create = account; entity.TypeId = typeId; await _tc.AddAsync(entity); _log.LogInformation($"{account}添加标示为{entity.Id}的类型配置数据成功"); return(new HandleResponse <int> { Success = true, Message = "添加类型配置数据成功", Key = entity.Id }); } catch (Exception ex) { _log.LogError($"{account}添加类型配置数据失败,失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}"); return(new BaseResponse { Success = false, Message = "添加类型配置数据失败,请联系管理员" }); } }