示例#1
0
        public IActionResult AddOrUpdate([FromForm] Sys_dict dict, [FromForm] string id)
        {
            var validator = new SysDictFluent();
            var results   = validator.Validate(dict);
            var success   = results.IsValid;

            if (!success)
            {
                //string msg = results.Errors.Aggregate("", (current, item) => current + (item.ErrorMessage + "</br>"));
                string msg = results.Errors.Aggregate("", (current, item) => (current + item.ErrorMessage + "</br>"));
                return(BootJsonH((PubEnum.Failed.ToInt32(), msg)));
            }
            if (id.IsEmptyZero())
            {
                if (_dictServices.IsAny(c => c.DictName == dict.DictName))
                {
                    return(BootJsonH((false, PubConst.Dict1)));
                }
                dict.DictId   = PubId.SnowflakeId;
                dict.CreateBy = UserDtoCache.UserId;
                bool flag = _dictServices.Insert(dict);
                return(BootJsonH(flag ? (flag, PubConst.Add1) : (flag, PubConst.Add2)));
            }
            else
            {
                dict.DictId       = id.ToInt64();
                dict.ModifiedBy   = UserDtoCache.UserId;
                dict.ModifiedDate = DateTimeExt.DateTime;
                var flag = _dictServices.Update(dict);
                return(BootJsonH(flag ? (flag, PubConst.Update1) : (flag, PubConst.Update2)));
            }
        }
示例#2
0
        public IActionResult AddOrUpdate([FromForm] Wms_material model, [FromForm] string id)
        {
            var validator = new MaterialFluent();
            var results   = validator.Validate(model);
            var success   = results.IsValid;

            if (!success)
            {
                string msg = results.Errors.Aggregate("", (current, item) => (current + item.ErrorMessage + "</br>"));
                return(BootJsonH((PubEnum.Failed.ToInt32(), msg)));
            }


            Sys_dict unitDict = _client.Queryable <Sys_dict>().First(x => x.DictId == model.Unit && x.DictType == PubDictType.unit.ToInt32().ToString());

            if (unitDict == null)
            {
                return(BootJsonH((false, PubConst.UnitNotFound)));
            }
            Sys_dict typeDict = _client.Queryable <Sys_dict>().First(x => x.DictId == model.MaterialType && x.DictType == PubDictType.material.ToInt32().ToString());

            if (typeDict == null)
            {
                return(BootJsonH((false, PubConst.MaterialTypeNotFound)));
            }

            if (id.IsEmptyZero())
            {
                if (_materialServices.IsAny(c => c.MaterialNo == model.MaterialNo || c.MaterialName == model.MaterialName))
                {
                    return(BootJsonH((false, PubConst.Material1)));
                }

                model.MaterialId       = PubId.SnowflakeId;
                model.UnitName         = unitDict.DictName;
                model.MaterialTypeName = typeDict.DictName;
                model.CreateBy         = UserDtoCache.UserId;
                model.CreateDate       = DateTime.Now;
                model.CreateUser       = UserDtoCache.UserName;
                model.ModifiedBy       = UserDtoCache.UserId;
                model.ModifiedDate     = DateTime.Now;
                model.ModifiedUser     = UserDtoCache.UserName;

                bool flag = _materialServices.Insert(model);
                return(BootJsonH(flag ? (flag, PubConst.Add1) : (flag, PubConst.Add2)));
            }
            else
            {
                model.MaterialId       = id.ToInt64();
                model.UnitName         = unitDict.DictName;
                model.MaterialTypeName = typeDict.DictName;
                model.ModifiedBy       = UserDtoCache.UserId;
                model.ModifiedDate     = DateTimeExt.DateTime;
                var flag = _materialServices.Update(model);
                return(BootJsonH(flag ? (flag, PubConst.Update1) : (flag, PubConst.Update2)));
            }
        }
示例#3
0
        public IActionResult Add(string id)
        {
            var model = new Sys_dict();

            if (id.IsEmpty())
            {
                return(View(model));
            }
            else
            {
                model = _dictServices.QueryableToEntity(c => c.DictId == SqlFunc.ToInt64(id));
                return(View(model));
            }
        }
示例#4
0
        public async Task <RouteData> ImportList(IFormFile file)
        {
            try
            {
                MaterialImportData[] importList = null;
                using (Stream stream = file.OpenReadStream())
                {
                    importList = NpoiUtil.Import <MaterialImportData>(
                        stream, file.FileName.EndsWith("xlsx") ? ExcelVersion.V2007 : ExcelVersion.V2003);
                    stream.Close();
                    stream.Dispose();
                }
                List <Sys_dict> typeDicts = await _client.Queryable <Sys_dict>().Where(x => x.DictType == PubDictType.material.ToByte().ToString()).ToListAsync();

                List <Sys_dict> unitDicts = await _client.Queryable <Sys_dict>().Where(x => x.DictType == PubDictType.unit.ToByte().ToString()).ToListAsync();

                foreach (MaterialImportData importData in importList)
                {
                    Wms_material material = null;
                    if (string.IsNullOrWhiteSpace(importData.MaterialOnlyId))
                    {
                        material = await _client.Queryable <Wms_material>().FirstAsync(x => x.MaterialNo == importData.MaterialNo);
                    }
                    else
                    {
                        material = await _client.Queryable <Wms_material>().FirstAsync(x => x.MaterialOnlyId == importData.MaterialOnlyId);
                    }

                    if (material == null)
                    {
                        Sys_dict typeDict = typeDicts.FirstOrDefault(x => x.DictName == importData.MaterialType);
                        if (typeDict == null)
                        {
                            return(RouteData <Wms_material> .From(PubMessages.E1001_SUPPLIESTYPE_NOTFOUND));
                        }
                        else if (typeDict.WarehouseId == null)
                        {
                            return(RouteData <Wms_material> .From(PubMessages.E1002_SUPPLIESTYPE_WAREHOUSEID_NOTSET));
                        }

                        Sys_dict unitDict = unitDicts.FirstOrDefault(x => x.DictName == importData.Unit);
                        if (unitDict == null)
                        {
                            return(RouteData <Wms_material> .From(PubMessages.E1003_UNIT_NOTFOUND));
                        }
                        long warehouseId = typeDict.WarehouseId.Value;

                        material = new Wms_material()
                        {
                            MaterialId     = PubId.SnowflakeId,
                            MaterialOnlyId = importData.MaterialOnlyId ?? "",
                            MaterialNo     = importData.MaterialNo ?? "",
                            MaterialName   = importData.MaterialName,
                            MaterialType   = typeDict.DictId,
                            WarehouseId    = warehouseId,
                            Unit           = unitDict.DictId,
                        };
                        this.Insert(material);
                    }
                    else
                    {
                        string unit = unitDicts.FirstOrDefault(x => x.DictId == material.Unit).DictName;
                        string type = typeDicts.FirstOrDefault(x => x.DictId == material.MaterialType).DictName;
                        if (material.MaterialNo != importData.MaterialNo)
                        {
                            return(RouteData.From(PubMessages.E4102_MATERIAL_IMPORT_EXIST_NOTMATCH,
                                                  $",物料编号不匹配,已保存的值为[{material.MaterialNo}],导入值为[{importData.MaterialNo}]"));
                        }
                        else if (material.MaterialOnlyId != importData.MaterialOnlyId)
                        {
                            return(RouteData.From(PubMessages.E4102_MATERIAL_IMPORT_EXIST_NOTMATCH,
                                                  $",物料唯一Id不匹配,已保存的值为[{material.MaterialOnlyId}],导入值为[{importData.MaterialOnlyId}]"));
                        }
                        else if (material.MaterialName != importData.MaterialName)
                        {
                            return(RouteData.From(PubMessages.E4102_MATERIAL_IMPORT_EXIST_NOTMATCH,
                                                  $",物料({importData.MaterialNo},{importData.MaterialOnlyId})名称不匹配,已保存的值为[{material.MaterialName}],导入值为[{importData.MaterialName}]"));
                        }
                        else if (type != importData.MaterialType)
                        {
                            return(RouteData.From(PubMessages.E4102_MATERIAL_IMPORT_EXIST_NOTMATCH,
                                                  $",物料({importData.MaterialNo},{importData.MaterialOnlyId})单位不匹配,已保存的值为[{type}],导入值为[{importData.MaterialType}]"));
                        }
                    }
                }
                return(RouteData.From(PubMessages.I4100_MATERIAL_IMPORT_SCCUESS));
            }
            catch
            {
                return(RouteData.From(PubMessages.E4100_MATERIAL_IMPORT_FAIL));
            }
        }