public async Task <IActionResult> NewPolicy(NewPolicyViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var foundPolicy = await _service.FetchPolicy(model.Name);

            if (foundPolicy != null)
            {
                ModelState.AddModelError("nameinuse", _sr["The policy name is already in use."]);
                return(View(model));
            }

            var policy = new AuthorizationPolicyInfo();

            policy.Name = model.Name;
            var result = await _service.CreatePolicy(policy);

            if (result.Succeeded)
            {
                var successFormat = _sr["The policy {0} was successfully created."];
                this.AlertSuccess(string.Format(successFormat, model.Name), true);
            }
            else
            {
                this.AlertDanger(_sr[result.Message], true);
            }

            return(RedirectToAction("EditPolicy", new { id = policy.Id }));
        }
        public async Task <IActionResult> Save([FromBody] NewPolicyViewModel viewModel)
        {
            var hasActivePoll = await _policyService.HasActivePoll();

            if (hasActivePoll)
            {
                ModelState.AddModelError("", _localizer["HasActivePoll"]);
                return(BadRequest(Errors.GetErrorList(ModelState)));
            }

            var latestAuthorityPoll = await _pollService.GetLastPollOfType <AuthorityPoll>();

            if (latestAuthorityPoll == null)
            {
                ModelState.AddModelError("", _localizer["CantStartPollBeforeAuthorityComplete"]);
                return(BadRequest(Errors.GetErrorList(ModelState)));
            }

            if (latestAuthorityPoll.Result == "Kararsız" ||
                latestAuthorityPoll.Result == PollResults.Undecided.ToString())
            {
                ModelState.AddModelError("", _localizer["CantStartPollBeforeAuthorityComplete"]);
                return(BadRequest(Errors.GetErrorList(ModelState)));
            }

            if (await _pollService.HasActivePollOfType <AuthorityPoll>())
            {
                ModelState.AddModelError("", _localizer["AuthorityPollActivePollError"]);
                return(BadRequest(Errors.GetErrorList(ModelState)));
            }


            var userId = User.ApiGetUserId();
            var policy = await _policyService.Add(new Policy
            {
                UserId       = userId,
                TenantId     = _tenantProvider.GetTenantId(),
                Body         = viewModel.Body,
                Title        = viewModel.Title,
                CreatedAt    = DateTime.UtcNow,
                PolicyStatus = PolicyStatus.Voting
            });

            var poll = await _pollViewModelService.NewPolicyChangePoll(new PolicyChangePollViewModel
            {
                UserId      = userId,
                StartedBy   = userId,
                Name        = "Yönetmelik Değişim Oylaması",
                Description = viewModel.PollDescription,
                PolicyId    = policy.Id
            });

            await _pollService.NotifyUsers(poll.PollType, PollNotificationTypes.Started, poll);

            return(Ok(_mapper.Map <PolicyChangePoll, PolicyChangePollViewModel>(poll)));
        }
        public IActionResult NewPolicy()
        {
            var model = new NewPolicyViewModel();

            return(View(model));
        }