/// <summary>
        /// 删除T_BM_DictionaryType数据
        /// </summary>
        /// <param name="requestObject"></param>
        /// <returns></returns>
        public async Task <ResponseObject <DeleteModel, bool> > DeleteAsync(RequestObject <DeleteModel> requestObject, CurrentUser currentUser)
        {
            var curentDB = _db.Instance;

            try
            {
                //执行结果
                var result = false;
                //没有删除数据,返回错误信息
                if (requestObject.PostData == null && requestObject.PostDataList == null)
                {
                    return(ResponseUtil <DeleteModel, bool> .FailResult(requestObject, false, "PostData、PostDataList不能都为null"));
                }

                curentDB.BeginTran();
                //批量删除的优先级高于单记录删除
                if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
                {
                    var ids = requestObject.PostDataList.Select(p => p.ID).ToList();
                    //批量删除
                    var idsEntity = requestObject.PostDataList.Select(p => new TBMDictionaryTypeDbModel()
                    {
                        ID = p.ID, DeleteFlag = true
                    }).ToList();
                    await curentDB.Updateable <TBMDictionaryDbModel>().Where(p => ids.Contains(p.TypeId)).SetColumns(p => new TBMDictionaryDbModel {
                        DeleteFlag = true
                    }).ExecuteCommandAsync();

                    result = await curentDB.Updateable <TBMDictionaryTypeDbModel>(idsEntity).UpdateColumns(p => new { p.DeleteFlag }).ExecuteCommandAsync() > 0;
                }
                else
                {
                    TBMDictionaryTypeDbModel id = new TBMDictionaryTypeDbModel()
                    {
                        ID = requestObject.PostData.ID, DeleteFlag = true
                    };

                    await curentDB.Updateable <TBMDictionaryDbModel>().Where(p => id.ID == p.TypeId).SetColumns(p => new TBMDictionaryDbModel {
                        DeleteFlag = true
                    }).ExecuteCommandAsync();

                    result = await curentDB.Updateable <TBMDictionaryTypeDbModel>(id).UpdateColumns(p => new { p.DeleteFlag }).ExecuteCommandAsync() > 0;
                }
                curentDB.CommitTran();

                var redis = CacheFactory.Instance(CacheType.Redis);

                string rediskey = string.Format(CacheKeyString.TBMDictionary, currentUser.CompanyID);
                redis.RemoveKey(rediskey);

                //返回执行结果
                if (result)
                {
                    return(ResponseUtil <DeleteModel, bool> .SuccessResult(requestObject, true));
                }
                return(ResponseUtil <DeleteModel, bool> .FailResult(requestObject, false, "删除数据失败!"));
            }
            catch (Exception ex)
            {
                curentDB.RollbackTran();
                //返回异常结果
                return(ResponseUtil <DeleteModel, bool> .FailResult(requestObject, false, ex.Message));
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// 新增T_SM_Company数据
        /// </summary>
        /// <param name="requestObject">返回响应结果对象,包括响应代码,新增操作结果</param>
        /// <returns></returns>
        public async Task <ResponseObject <string> > PostAsync(RequestPost <TSMCompanyAddModel> requestObject, CurrentUser currentUser)
        {
            try
            {
                _db.Instance.BeginTran();

                //如果没有新增数据,返回错误信息
                if (requestObject.PostData == null && requestObject.PostDataList == null)
                {
                    return(ResponseUtil <string> .FailResult(null, "PostData不能都为null"));
                }
                var result = false;

                string token = string.Empty;
                //批量新增的优先级高于单条数据新增,且只会执行一个新增操作
                if (requestObject.PostDataList != null && requestObject.PostDataList.Count > 0)
                {
                }
                else
                {
                    #region 创建公司时,需要效验验证是否过期
                    var    verification = CacheFactory.Instance(CacheType.Redis);
                    string RedisValue   = verification.GetValueByKey <string>(string.Format(CacheKeyString.LoginTimes, requestObject.PostData.TelAccount));
                    if (RedisValue == "")
                    {
                        return(ResponseUtil <string> .FailResult(null, "注册失败,验证码无效"));
                    }
                    if (Convert.ToInt32(RedisValue) >= 3)
                    {
                        if (string.IsNullOrWhiteSpace(requestObject.PostData.VerificationCode))
                        {
                            return(ResponseUtil <string> .FailResult(null, "注册失败,请输入验证码"));
                        }
                        if (requestObject.PostData.VerificationCode != verification.GetValueByKey <string>(string.Format(CacheKeyString.TimePassMsgCode, requestObject.PostData.TelAccount)))
                        {
                            return(ResponseUtil <string> .FailResult(null, "注册失败,输入的验证码不一致"));
                        }
                    }
                    #endregion
                    var addModel = _mapper.Map <TSMCompanyDbModel>(requestObject.PostData);
                    if (_db.Instance.Queryable <TSMCompanyDbModel>().Any(p => p.CompanyName == addModel.CompanyName))
                    {
                        throw new Exception("公司已经存在");
                    }

                    addModel.AdminId = currentUser.UserID;

                    result = _db.Instance.Insertable(addModel).ExecuteCommandIdentityIntoEntity();

                    var tTemplates = _db.Instance.Queryable <TTemplatesModel>().Where(p => p.isDefault).First();

                    TTenantsModel tenantsModel = new TTenantsModel();
                    tenantsModel.CreateId        = currentUser.UserID;
                    tenantsModel.TenantShortName = "";
                    tenantsModel.Status          = true;
                    tenantsModel.IsTrial         = true;
                    tenantsModel.TenantEngName   = "";
                    tenantsModel.ValidityPeriod  = DateTime.Now.AddMonths(1);

                    if (tTemplates != null)
                    {
                        tenantsModel.TemplateId = tTemplates.Id;
                    }

                    _db.Instance.Insertable <TTenantsModel>(tenantsModel).ExecuteCommandIdentityIntoEntity();

                    addModel.CompanyInfoId = tenantsModel.ID;//从表ID

                    _db.Instance.Updateable <TSMUserAccountDbModel>().Where(p => p.ID == currentUser.UserID).SetColumns(it => new TSMUserAccountDbModel()
                    {
                        Status = 1, CompanyId = addModel.ID
                    }).ExecuteCommand();

                    _db.Instance.Updateable(addModel).UpdateColumns(p => p.CompanyInfoId).ExecuteCommand();

                    #region 根据版本号查询默认权限
                    var defaultData = await _db.Instance.Queryable <TTempPermissionsModel>()
                                      .Where(p => p.TemplateId == SqlFunc.Subqueryable <TTemplatesModel>()
                                             .Where(p1 => p1.isDefault && p1.VersionType == requestObject.PostData.VersionType)
                                             .Select(p2 => p2.Id))
                                      .ToListAsync();

                    List <TTenantPermissionsModel> tenantPermissions = new List <TTenantPermissionsModel>();
                    foreach (var item in defaultData)
                    {
                        tenantPermissions.Add(new TTenantPermissionsModel
                        {
                            TenantId  = addModel.ID,
                            MenuId    = item.MenuId,
                            ButtonIds = item.ButtonIds,
                            CreateId  = currentUser.UserID
                        });
                    }
                    await _db.Instance.Insertable(tenantPermissions).ExecuteCommandAsync();

                    #endregion

                    #region 生成系统所需的字典类型及默认值
                    var dictionaryData = await _db.Instance.Queryable <TPMDictionaryInitInfoDbModel>().ToListAsync();

                    foreach (var item in dictionaryData)
                    {
                        var typeNameModel = new TBMDictionaryTypeDbModel
                        {
                            ID         = 0,
                            TypeName   = item.TypeName,
                            CompanyId  = addModel.ID,
                            DeleteFlag = false,
                            IsSys      = true
                        };
                        await _db.Instance.Insertable(typeNameModel).ExecuteCommandIdentityIntoEntityAsync();

                        var valueList = new List <TBMDictionaryDbModel>();
                        foreach (var v in item.TypeValues.Split(","))
                        {
                            if (string.IsNullOrEmpty(v))
                            {
                                continue;
                            }
                            valueList.Add(new TBMDictionaryDbModel
                            {
                                ID         = 0,
                                TypeId     = typeNameModel.ID,
                                DicCode    = "",
                                DicValue   = v,
                                Remark     = "",
                                CreateId   = currentUser.UserID,
                                CompanyId  = addModel.ID,
                                DeleteFlag = false
                            });
                        }

                        await _db.Instance.Insertable(valueList).ExecuteCommandAsync();
                    }
                    #endregion

                    var palyloads = new Dictionary <string, object>
                    {
                        { "UserID", currentUser.UserID },
                        { "ID", Guid.NewGuid().ToString() },
                        { "CompanyID", addModel.ID },
                        { "UserName", currentUser.UserName }
                    };
                    token = TokenManager.CreateTokenByHandler(palyloads, 60 * 24);
                }

                _db.Instance.CommitTran();
                //返回执行结果
                return(ResponseUtil <string> .SuccessResult(token));
            }
            catch (Exception ex)
            {
                _db.Instance.RollbackTran();
                //返回异常结果
                return(ResponseUtil <string> .FailResult(null, ex.Message));
            }
        }