コード例 #1
0
        public ActionResult SaveRole(Guid?roleId, string roleName, string roleText, string[] functions, string applicationName)
        {
            bool      result;
            IRoleInfo roleInfo = null;

            if (roleId == null)
            {
                roleInfo = WebSecurity.CreateRole(roleName, roleText);
                result   = roleInfo != null;
            }
            else
            {
                result   = WebSecurity.UpdateRoleText(roleText, roleId.Value);
                roleInfo = new SimpleRole(roleId.Value, roleName)
                {
                    RoleText = roleText
                };
            }
            if (result)
            {
                //更新角色功能列表
                if (functions != null && functions.Length > 0)
                {
                    result = WebSecurity.UpdateFunctionsForRole(roleInfo.RoleId, functions);
                    if (result)
                    {
                        //移除当前功能列表的缓存
                        WebSecurity.RemoveFunctionCache(roleInfo.RoleId);
                    }
                }
            }
            return(Json(new { Result = result, Data = roleInfo }));
        }
        /// <summary>添加标准通用角色与相关组织的映射关系</summary>
        /// <param name="standardGeneralRoleId">标准通用角色标识</param>
        /// <param name="organizationId">组织标识</param>
        /// <param name="roleId">角色标识</param>
        public int AddMappingRelation(string standardGeneralRoleId, string organizationId, string roleId)
        {
            if (this.HasMappingRelation(standardGeneralRoleId, organizationId))
            {
                // 已存在映射关系
                return(1);
            }

            IRoleInfo role = null;

            if (string.IsNullOrEmpty(roleId))
            {
                role = this.CreateNewRole(standardGeneralRoleId, organizationId);
            }
            else
            {
                role = MembershipManagement.Instance.RoleService.FindOne(roleId);
            }

            if (role == null)
            {
                // 相关角色信息不存在
                return(2);
            }

            return(this.provider.AddMappingRelation(standardGeneralRoleId, organizationId, role.Id, role.StandardRoleId));
        }
コード例 #3
0
        public async Task <int> RemoveRole(string code)
        {
            int ret;

            using (var scope = this._repo.BeginTransScope())
            {
                code = Utility.ClearSafeStringParma(code);

                IRoleInfo role = await this._repo.GetRole(code);

                if (role == null)
                {
                    throw new BizException("角色不存在,请检查后重试");
                }
                int diff = role.Right - role.Left + 1;
                if (diff > 2)
                {
                    throw new BizException("存在子角色不能删除!");
                }

                await _repo.MinusRolePoint(role.AppCode, role.Right);

                //清除用户和角色的关系
                await this._repo.RemovRolePrivilegeAsync(code, "");

                await this._repo.RemovRoleUserAsync(code, "");

                ret = await this._repo.RemoveRole(code);

                scope.Complete();
            }
            return(ret);
        }
コード例 #4
0
        public List <EmployeeModel> QueryEmployeeInfo(string name, string status, int pageIndex, int pageSize, out int rowCount)
        {
            using (TeamDBContext context = new TeamDBContext())
            {
                DatabaseAccess dba        = context.DatabaseAccess();
                DbCommand      cmd        = dba.CreateCommand();
                StringBuilder  sqlBuilder = new StringBuilder("SELECT u.UserName, u.[Enabled], ue.*, e.*, lc.UnitPrice AS PositionUnitPrice, lc.UnitValue AS PositionUnitValue, lc2.UnitPrice AS UserUnitPrice, lc2.UnitValue AS UserUnitValue FROM auth_User u INNER JOIN auth_UserExtend ue ON u.UserId = ue.UserId LEFT JOIN Employee e ON ue.UserId = e.EmployeeId LEFT JOIN LaborCost lc ON ue.Position = lc.TargetId AND lc.TargetType = 1 LEFT JOIN LaborCost lc2 ON u.UserId = lc2.TargetId AND lc2.TargetType = 2 WHERE 1 = 1");
                if (!String.IsNullOrEmpty(name))
                {
                    sqlBuilder.Append(" AND ue.RealName LIKE @RealName");
                    dba.AddInParameter(cmd, "RealName", DbType.String, String.Concat("%", name, "%"));
                }
                sqlBuilder.Append(" AND ue.Status = @Status");
                if (String.IsNullOrEmpty(status))
                {
                    dba.AddInParameter(cmd, "Status", DbType.String, "1-01");
                }
                else
                {
                    dba.AddInParameter(cmd, "Status", DbType.String, String.Concat("1-0", status));
                }
                sqlBuilder.Append(" ORDER BY ue.RealName, u.UserName");
                cmd.CommandText = sqlBuilder.ToString();

                List <EmployeeModel> data = null;
                using (DbDataReader reader = dba.ExecuteReaderPaging(cmd, PrepareQueryEmployeeInfoCommand, pageIndex, pageSize, out rowCount))
                {
                    if (reader.HasRows)
                    {
                        data = new List <EmployeeModel>(50);
                        Guid          lastUserId = Guid.Empty;
                        Guid          currentUserId;
                        EmployeeModel employee = null;
                        while (reader.Read())
                        {
                            currentUserId = reader.GetGuidOrNull("UserId").Value;
                            if (currentUserId != lastUserId)
                            {
                                employee = ReadEmployeeInfo <EmployeeQueryModel>(reader);
                                if (employee.Roles == null)
                                {
                                    employee.Roles = new List <IRoleInfo>(5);
                                }
                                data.Add(employee);
                                lastUserId = currentUserId;
                            }

                            IRoleInfo role = ReadRoleInfo(reader);
                            if (role != null)
                            {
                                employee.Roles.Add(role);
                            }
                        }
                    }
                }
                return(data);
            }
        }
コード例 #5
0
ファイル: RoleRepository.cs プロジェクト: ywscr/Vulcan
        public Task <int> UpdateRole(IRoleInfo entity)
        {
            var data = Map(entity);

            data.RemoveUpdateColumn("AppCode");
            data.RemoveUpdateColumn("IsSystemRole");
            data.RemoveUpdateColumn("ParentCode");
            return(base.UpdateAsync(data));
        }
コード例 #6
0
        // ------------------------------------------------------------------------------------------
        // 角色类的函数
        // ------------------------------------------------------------------------------------------

        /// <summary></summary>
        /// <param name="roles"></param>
        /// <returns></returns>
        public static IRoleInfo[] ToRoleArray(IList <IRoleInfo> roles)
        {
            IRoleInfo[] roleArray = new IRoleInfo[roles.Count];

            for (int index = 0; index < roleArray.Length; index++)
            {
                roleArray[index] = (IRoleInfo)roles[index];
            }

            return(roleArray);
        }
コード例 #7
0
        public async Task <int> SaveRole(IRoleInfo entity, int type)
        {
            int ret = -1;

            using (var scope = this._repo.BeginTransScope())
            {
                if (type == 1) // 新增
                {
                    if (!entity.RoleCode.StartsWith(entity.AppCode))
                    {
                        entity.RoleCode = entity.AppCode + "_" + entity.RoleCode;
                    }
                    // 校验
                    bool result = await this._repo.CheckCode(entity.RoleCode);

                    if (!result)
                    {
                        ret = -1;
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(entity.ParentCode)) // 根组织
                        {
                            entity.Left  = 1;
                            entity.Right = entity.Left + 1;
                        }
                        else
                        {
                            IRoleInfo pRole = await _repo.GetRole(entity.ParentCode);

                            if (pRole == null)
                            {
                                throw new BizException("父角色不存在,请检查后重新保存");
                            }

                            await _repo.UpdateRolePoint(entity.AppCode, pRole.Right);

                            entity.Left  = pRole.Right;
                            entity.Right = entity.Left + 1;
                        }

                        await this._repo.AddRole(entity);

                        ret = 1;
                    }
                }
                else
                {
                    ret = await this._repo.UpdateRole(entity);
                }
                scope.Complete();
            }
            return(ret);
        }
コード例 #8
0
        //#region 属性:HasOrganizationUnit(string accountId, string organizationNames)
        ///// <summary>
        ///// 检测用户是否拥有权限
        ///// </summary>
        ///// <param name="accountId"></param>
        ///// <param name="organizationNames"></param>
        ///// <returns></returns>
        //public static bool HasOrganizationUnit(string accountId, string organizationNames)
        //{
        //    return AuthorityContext.Instance.AuthorityService.HasAuthorizationObject(accountId, "OrganizationUnit", organizationNames);
        //}
        //#endregion

        //#region 函数:HasRole(string accountId, string roleNames)
        ///// <summary>
        ///// 检测用户是否拥有权限
        ///// </summary>
        ///// <param name="accountId"></param>
        ///// <param name="roleName"></param>
        ///// <returns></returns>
        //public static bool HasRole(string accountId, string roleNames)
        //{
        //    return AuthorityContext.Instance.AuthorityService.HasAuthorizationObject(accountId, "Role", roleNames);
        //}
        //#endregion

        //#region 函数:Check(IAccountInfo account, string[] roleName)
        ///// <summary>
        ///// 检测用户是否拥有权限
        ///// </summary>
        ///// <param name="account"></param>
        ///// <param name="authorityKeys"></param>
        ///// <returns></returns>
        //public static bool HasAuthority(string accountId, string authorityNames)
        //{
        //    return AuthorityContext.Instance.AuthorityService.HasAuthorizationObject(accountId, "Authority", authorityNames);
        //}
        //#endregion

        ////#region 函数:Check(IAccountInfo account, IRoleInfo[] roles, string[] authorityKeys)
        /////// <summary>
        /////// 检测用户是否拥有权限
        /////// </summary>
        /////// <param name="account"></param>
        /////// <param name="roles"></param>
        /////// <param name="authorityKeys"></param>
        /////// <returns></returns>
        ////public static bool Check(IAccountInfo account, IRoleInfo[] roles, string[] authorityKeys)
        ////{
        //    //
        //    // 1.获取帐号的权限
        //    //
        //    // 2.获取的需要的角色范围
        //    //
        //    // 3.需要的权限范围
        //    //
        //    // 4.需要的权限优先级大于需要的角色的优先级.
        //    //

        ////    IList<AuthorityInfo> accountAuthorities = GetAuthorities(account);

        ////    IList<AuthorityInfo> systemAuthorities = GetUnionAuthorities(GetAuthorities(roles), GetAuthorities(authorityKeys));

        ////    IList<AuthorityInfo> authorities = GetIntersectionAuthorities(accountAuthorities, systemAuthorities);

        ////    return authorities.Count > 0 ? true : false;
        ////}
        ////#endregion

        #region 函数:GetAuthorities(IAccountInfo account)
        /// <summary>获取权限列表</summary>
        /// <param name="account"></param>
        /// <returns></returns>
        public static IList <AuthorityInfo> GetAuthorities(IAccountInfo account)
        {
            IRoleInfo[] roles = new IRoleInfo[account.RoleRelations.Count];

            for (int i = 0; i < roles.Length; i++)
            {
                roles[i] = account.RoleRelations[i].GetRole();
            }

            return(GetAuthorities(roles));
        }
コード例 #9
0
        // -------------------------------------------------------
        // 保存 添加 修改 删除
        // -------------------------------------------------------

        #region 函数:Save(IRoleInfo param)
        /// <summary>保存记录</summary>
        /// <param name="param">IRoleInfo 实例详细信息</param>
        /// <returns>IRoleInfo 实例详细信息</returns>
        public IRoleInfo Save(IRoleInfo param)
        {
            if (!this.IsExist(param.Id))
            {
                this.Insert(param);
            }
            else
            {
                this.Update(param);
            }

            return(param);
        }
コード例 #10
0
        // -------------------------------------------------------
        // 查询
        // -------------------------------------------------------

        #region 函数:FindOne(XmlDocument doc)
        /// <summary>获取详细信息</summary>
        /// <param name="doc">Xml 文档对象</param>
        /// <returns>返回操作结果</returns>
        public string FindOne(XmlDocument doc)
        {
            StringBuilder outString = new StringBuilder();

            string id = XmlHelper.Fetch("id", doc);

            IRoleInfo param = this.service.FindOne(id);

            outString.Append("{\"data\":" + AjaxUtil.Parse <IRoleInfo>(param) + ",");

            outString.Append(MessageObject.Stringify("0", I18n.Strings["msg_query_success"], true) + "}");

            return(outString.ToString());
        }
コード例 #11
0
        protected bool HasRole(IAccountInfo account, IRoleInfo Role)
        {
            bool success = false;

            //// if (grade.IndexOf("[" + member.Grade + "]") > -1) success = true;

            //for (int i = 0; i < gradeArray.Length; i++)
            //{
            //    if (gradeArray[i] == member.Grade)
            //    {
            //        success = true;
            //    }
            //}

            return(success);
        }
コード例 #12
0
        /// <summary>添加记录</summary>
        /// <param name="param">IRoleInfo 实例的详细信息</param>
        public void Insert(IRoleInfo param)
        {
            if (string.IsNullOrEmpty(param.Id))
            {
                param.Id = DigitalNumberContext.Generate("Key_Guid");
            }

            if (string.IsNullOrEmpty(param.Code))
            {
                param.Code = DigitalNumberContext.Generate("Table_Role_Key_Code");
            }

            this.ibatisMapper.Insert(StringHelper.ToProcedurePrefix(string.Format("{0}_Insert", tableName)), param);

            // 绑定关系
            // BindRelation(param);
        }
コード例 #13
0
ファイル: RoleRepository.cs プロジェクト: ywscr/Vulcan
 private static RoleInfo Map(IRoleInfo source)
 {
     return(new RoleInfo()
     {
         AppCode = source.AppCode,
         IsSystemRole = source.IsSystemRole,
         LastModifyTime = source.LastModifyTime,
         LastModifyUserId = source.LastModifyUserId,
         LastModifyUserName = source.LastModifyUserName,
         ParentCode = source.ParentCode,
         Remark = source.Remark,
         RoleCode = source.RoleCode,
         RoleName = source.RoleName,
         Left = source.Left,
         Right = source.Right
     });
 }
コード例 #14
0
        /// <summary>����Ĭ�Ͻ�ɫ</summary>
        /// <param name="accountId">�ʺű�ʶ</param>
        /// <param name="roleId">��ɫ��ʶ</param>
        /// <returns>�޸ijɹ�, ���� 0, �޸�ʧ��, ���� 1.</returns>
        public virtual int SetDefaultRole(string accountId, string roleId)
        {
            IRoleInfo role = MembershipManagement.Instance.RoleService[roleId];

            if (role == null)
            {
                // δ�ҵ���ɫ��Ϣ��
                return(1);
            }

            // ����Ĭ�Ϲ�˾��������Ϣ��

            string organizationIds = string.Empty;

            IOrganizationUnitInfo organization = MembershipManagement.Instance.OrganizationUnitService.FindCorporationByOrganizationUnitId(role.OrganizationUnitId);

            if (organization == null)
            {
                // δ�ҵ���ɫ���صĹ�˾��Ϣ��
                return(2);
            }

            organizationIds += organization.Id + ",";

            int depth = 1;

            organization = MembershipManagement.Instance.OrganizationUnitService.FindOneByRoleId(roleId, depth);

            while (organization != null)
            {
                organizationIds += organization.Id + ",";

                depth++;

                organization = MembershipManagement.Instance.OrganizationUnitService.FindOneByRoleId(roleId, depth);
            }

            MembershipManagement.Instance.MemberService.SetDefaultCorporationAndDepartments(accountId, organizationIds);

            // ͳһ������ɫ���ݷ������á�
            return(MembershipManagement.Instance.RoleService.SetDefaultRelation(accountId, roleId));
        }
コード例 #15
0
        // -------------------------------------------------------
        // 角色
        // -------------------------------------------------------

        #region 函数:GetRoles(string ids)
        /// <summary>获取对应的角色信息</summary>
        /// <param name="ids">角色标识,多个以逗号隔开</param>
        /// <returns></returns>
        public IList <IRoleInfo> GetRoles(string ids)
        {
            string[] keys = ids.Split(new char[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);

            IList <IRoleInfo> list = new List <IRoleInfo>();

            IRoleInfo item = null;

            for (int i = 0; i < keys.Length; i++)
            {
                item = MembershipManagement.Instance.RoleService[keys[i]];

                // 过滤对象为空或者禁用的对象。
                if (item != null && item.Status == 1)
                {
                    list.Add(item);
                }
            }

            return(list);
        }
コード例 #16
0
        /// <summary>同步信息</summary>
        /// <param name="param">帐号信息</param>
        public int SyncFromPackPage(IAccountInfo param)
        {
            // 此版本只同步姓名和帐号状态,不同步登录名。

            string accountId = param.Id;

            this.ibatisMapper.Insert(StringHelper.ToProcedurePrefix(string.Format("{0}_SyncFromPackPage", tableName)), param);

            if (param.RoleRelations.Count > 0)
            {
                // 1.设置默认角色信息
                IMemberInfo member = MembershipManagement.Instance.MemberService.FindOne(param.Id);

                if (member.Role != null)
                {
                    IRoleInfo defaultRole = MembershipManagement.Instance.RoleService[member.Role.Id];

                    if (defaultRole != null)
                    {
                        MembershipManagement.Instance.RoleService.SetDefaultRelation(accountId, member.Role.Id);

                        MembershipManagement.Instance.OrganizationUnitService.SetDefaultRelation(accountId, member.Role.OrganizationUnitId);
                    }
                }

                // 2.移除非默认角色关系
                MembershipManagement.Instance.RoleService.RemoveNondefaultRelation(accountId);

                // 3.移除非默认组织关系
                MembershipManagement.Instance.OrganizationUnitService.RemoveNondefaultRelation(accountId);

                // 4.设置新的关系
                foreach (IAccountRoleRelationInfo item in param.RoleRelations)
                {
                    MembershipManagement.Instance.RoleService.AddRelation(accountId, item.RoleId);

                    // 根据角色设置组织关系

                    IRoleInfo role = MembershipManagement.Instance.RoleService.FindOne(item.RoleId);

                    // [容错]如果角色信息为空,中止相关组织设置
                    if (role == null)
                    {
                        continue;
                    }

                    if (!string.IsNullOrEmpty(role.OrganizationUnitId))
                    {
                        MembershipManagement.Instance.OrganizationUnitService.AddRelation(accountId, role.OrganizationUnitId);

                        MembershipManagement.Instance.OrganizationUnitService.AddParentRelations(accountId, role.OrganizationUnitId);
                    }
                }

                // 5.再次设置默认角色信息
                if (member.Role != null)
                {
                    MembershipManagement.Instance.RoleService.SetDefaultRelation(accountId, member.Role.Id);

                    MembershipManagement.Instance.OrganizationUnitService.SetDefaultRelation(accountId, member.Role.OrganizationUnitId);
                }

                //
                // 设置群组关系
                //

                // 1.移除群组关系
                MembershipManagement.Instance.GroupService.RemoveAllRelation(accountId);

                // 2.设置新的关系
                foreach (IAccountGroupRelationInfo item in param.GroupRelations)
                {
                    MembershipManagement.Instance.GroupService.AddRelation(accountId, item.GroupId);
                }
            }

            return(0);
        }
コード例 #17
0
 /// <summary>修改记录</summary>
 /// <param name="param">IRoleInfo 实例的详细信息</param>
 public void Update(IRoleInfo param)
 {
     this.ibatisMapper.Update(StringHelper.ToProcedurePrefix(string.Format("{0}_Update", tableName)), param);
 }
コード例 #18
0
ファイル: RoleRepository.cs プロジェクト: ywscr/Vulcan
        public Task <long> AddRole(IRoleInfo entity)
        {
            var data = Map(entity);

            return(base.InsertAsync(data));
        }
コード例 #19
0
        // -------------------------------------------------------
        // ���� ɾ��
        // -------------------------------------------------------

        #region 属性:Save(IMemberInfo param)
        /// <summary>������¼</summary>
        /// <param name="param">IMemberInfo ʵ����ϸ��Ϣ</param>
        /// <returns>IMemberInfo ʵ����ϸ��Ϣ</returns>
        public IMemberInfo Save(IMemberInfo param)
        {
            IMemberInfo originalObject = this.FindOne(param.Id);

            if (originalObject == null)
            {
                originalObject = param;
            }

            IRoleInfo defaultRole = null;

            IAssignedJobInfo defaultAssignedJob = null;

            // �����ֶ����� �Զ�������֯��Ϣ
            // AutoBindingOrganizationUnitByPrimaryKey : None | RoleId | AssignedJobId
            if (MembershipConfigurationView.Instance.AutoBindingOrganizationUnitByPrimaryKey == "RoleId" && !string.IsNullOrEmpty(param.RoleId))
            {
                defaultRole = MembershipManagement.Instance.RoleService[param.RoleId];

                param.OrganizationUnitId = defaultRole.OrganizationUnitId;

                this.SetDefaultOrganizationUnit(param.Account.Id, param.OrganizationUnitId);
                this.SetDefaultCorporationAndDepartmentsByOrganizationUnitId(param.Account.Id, param.OrganizationUnitId);
            }
            else if (MembershipConfigurationView.Instance.AutoBindingOrganizationUnitByPrimaryKey == "AssignedJobId" && !string.IsNullOrEmpty(param.AssignedJobId))
            {
                defaultAssignedJob = MembershipManagement.Instance.AssignedJobService[param.AssignedJobId];

                if (defaultAssignedJob != null)
                {
                    param.OrganizationUnitId = defaultAssignedJob.OrganizationUnitId;

                    this.SetDefaultOrganizationUnit(param.Account.Id, param.OrganizationUnitId);
                    this.SetDefaultCorporationAndDepartmentsByOrganizationUnitId(param.Account.Id, param.OrganizationUnitId);
                }
            }
            else if (MembershipConfigurationView.Instance.AutoBindingOrganizationUnitByPrimaryKey == "Self" && !string.IsNullOrEmpty(param.OrganizationUnitId))
            {
                // �����ֶ��󶨹���������֯��Ϣ
                this.SetDefaultOrganizationUnit(param.Account.Id, param.OrganizationUnitId);
                this.SetDefaultCorporationAndDepartmentsByOrganizationUnitId(param.Account.Id, param.OrganizationUnitId);
            }

            // ���ݸ�λ���� �Զ�����ְλ��Ϣ
            if (MembershipConfigurationView.Instance.AutoBindingJobByPrimaryKey == "AssignedJobId" && !string.IsNullOrEmpty(param.AssignedJobId))
            {
                if (defaultAssignedJob == null)
                {
                    defaultAssignedJob = MembershipManagement.Instance.AssignedJobService[param.AssignedJobId];
                }

                if (defaultAssignedJob != null)
                {
                    this.SetDefaultJob(param.Account.Id, defaultAssignedJob.JobId);
                }
            }
            else if (MembershipConfigurationView.Instance.AutoBindingJobByPrimaryKey == "Self" && !string.IsNullOrEmpty(param.JobId))
            {
                // ����������������ְλ��Ϣ
                this.SetDefaultJob(param.Account.Id, param.JobId);
            }

            // ���ݸ�λ���� �Զ�����ְ����Ϣ
            if (MembershipConfigurationView.Instance.AutoBindingJobGradeByPrimaryKey == "AssignedJobId" && !string.IsNullOrEmpty(param.AssignedJobId))
            {
                if (defaultAssignedJob == null)
                {
                    defaultAssignedJob = MembershipManagement.Instance.AssignedJobService[param.AssignedJobId];
                }

                if (defaultAssignedJob != null)
                {
                    this.SetDefaultJobGrade(param.Account.Id, defaultAssignedJob.JobGradeId);
                }
            }
            else if (MembershipConfigurationView.Instance.AutoBindingJobGradeByPrimaryKey == "Self" && !string.IsNullOrEmpty(param.JobGradeId))
            {
                // ����Ĭ����������ְ����Ϣ
                this.SetDefaultJobGrade(param.Account.Id, param.JobGradeId);
            }

            // ������֯ȫ·��
            param.FullPath = CombineFullPath(param.Account.Name, param.OrganizationUnitId);

            param = provider.Save(param);

            // 1.������չ��Ϣ
            if (param.ExtensionInformation != null)
            {
                param.ExtensionInformation.Save();
            }

            // 2.����Ĭ�Ͻ�ɫ��Ϣ
            if (param.Role != null)
            {
                MembershipManagement.Instance.RoleService.SetDefaultRelation(param.Account.Id, param.Role.Id);
            }

            // 3.����Ĭ�ϸ�λ��Ϣ
            if (param.AssignedJob != null)
            {
                MembershipManagement.Instance.AssignedJobService.RemoveDefaultRelation(param.Account.Id);
                MembershipManagement.Instance.AssignedJobService.SetDefaultRelation(param.Account.Id, param.AssignedJob.Id);
            }

            // 4.���ü�ְ��Ϣ
            if (param.PartTimeJobs.Count > 0)
            {
                this.BindPartTimeJobs(param);
            }
            else if (param.PartTimeJobs.Count == 0 && originalObject.PartTimeJobs.Count > 0)
            {
                // �Ƴ���Ĭ�ϸ�λ��ϵ
                MembershipManagement.Instance.AssignedJobService.RemoveNondefaultRelation(param.Account.Id);
            }

            return(param);
        }
コード例 #20
0
        /// <summary>同步信息</summary>
        /// <param name="param">角色信息</param>
        public int SyncFromPackPage(IRoleInfo param)
        {
            this.ibatisMapper.Insert(StringHelper.ToProcedurePrefix(string.Format("{0}_SyncFromPackPage", tableName)), param);

            return(0);
        }