public async Task <IActionResult> Edit(string id, [Bind("Description,Id,Name")] CrmRole crmRole)
        {
            if (id != crmRole.Id)
            {
                return(NotFound());
            }

            if (!ModelState.IsValid)
            {
                return(View(crmRole));
            }
            try
            {
                await _roleManager.UpdateAsync(crmRole);
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CrmRoleExists(crmRole.Id))
                {
                    return(NotFound());
                }
                throw;
            }

            return(RedirectToAction(nameof(Index)));
        }
        public async Task <IActionResult> Create([Bind("Description,Id,Name")]
                                                 CrmRole crmRole)
        {
            if (!ModelState.IsValid)
            {
                return(View(crmRole));
            }
            await _roleManager.CreateAsync(crmRole);

            return(RedirectToAction(nameof(Index)));
        }
Example #3
0
        public static CrmRolesResult GetCRMRoles(int itemId, int accountId, int packageId)
        {
            CrmRolesResult res = StartTask <CrmRolesResult>("CRM", "GET_CRM_ROLES");

            try
            {
                int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedCRM);
                if (serviceId == 0)
                {
                    CompleteTask(res, CrmErrorCodes.CRM_IS_NOT_SELECTED_IN_HOSTING_PLAN, null, "CRM is not selected in hosting plan.");
                    return(res);
                }

                CRM crm = new CRM();
                ServiceProviderProxy.Init(crm, serviceId);

                Organization org = OrganizationController.GetOrganization(itemId);

                CrmUserResult crmUserResult = GetCrmUser(itemId, accountId);
                res.ErrorCodes.AddRange(crmUserResult.ErrorCodes);
                if (!crmUserResult.IsSuccess)
                {
                    CompleteTask(res);
                    return(res);
                }

                CrmUser        crmUser  = crmUserResult.Value;
                CrmRolesResult crmRoles = crm.GetAllCrmRoles(org.OrganizationId, crmUser.BusinessUnitId);
                res.ErrorCodes.AddRange(crmRoles.ErrorCodes);
                if (!crmRoles.IsSuccess)
                {
                    CompleteTask(res);
                    return(res);
                }
                Guid           userId       = crmUser.CRMUserId;
                CrmRolesResult crmUserRoles = crm.GetCrmUserRoles(org.OrganizationId, userId);

                res.ErrorCodes.AddRange(crmUserRoles.ErrorCodes);
                if (!crmUserRoles.IsSuccess)
                {
                    CompleteTask(res);
                    return(res);
                }

                foreach (CrmRole role in crmUserRoles.Value)
                {
                    CrmRole retRole = crmRoles.Value.Find(delegate(CrmRole currentRole)
                    {
                        return(currentRole.RoleId == role.RoleId);
                    });
                    if (retRole != null)
                    {
                        retRole.IsCurrentUserRole = true;
                    }
                }

                res.Value = crmRoles.Value;
            }
            catch (Exception ex)
            {
                CompleteTask(res, CrmErrorCodes.CANNOT_GET_CRM_ROLES_GENERAL_ERROR, ex);
                return(res);
            }

            CompleteTask();
            return(res);
        }