public async Task <IActionResult> ProcessEdit(int id, [Bind("Id,Firstname,Surname,DateOfBirth,Species,Homeworld,Gender,Born,Eyes,Hair,Height,Weight,Affiliation,Assignment,Rank,RankImage,PostingId,PlayerId,History,StatusId,StateId,PlayerId,TypeId")] EditCharacterViewModel biography, CancellationToken cancellationToken)
        {
            if (id != biography.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                var command = _mapper.Map <UpdateCharacterCommand>(biography);
                var result  = await _mediator.Send(command, cancellationToken);

                TempData["Message"] = result switch
                {
                    UpdateCharacterResponse.Created => "Character Created",
                    UpdateCharacterResponse.Updated => "Character updated",
                    _ => TempData["Message"]
                };

                return(RedirectToAction("Characters", "My", new { area = "player" }));
            }

            biography.Postings = _context.Posting.Select(x => new SelectListItem(x.Name, x.Id.ToString())).ToList();

            return(View("Edit", biography));
        }
        public async Task <ActionResult> Edit(EditCharacterViewModel viewModel)
        {
            var field = await CharacterRepository.GetCharacterAsync(viewModel.ProjectId, viewModel.CharacterId);

            try
            {
                if (!ModelState.IsValid)
                {
                    return(View(viewModel.Fill(field, CurrentUserId)));
                }
                await ProjectService.EditCharacter(
                    CurrentUserId,
                    viewModel.CharacterId,
                    viewModel.ProjectId,
                    viewModel.Name, viewModel.IsPublic,
                    viewModel.ParentCharacterGroupIds.GetUnprefixedGroups(),
                    viewModel.IsAcceptingClaims&& field.ApprovedClaim == null, //Force this field to false if has approved claim
                    viewModel.Description,
                    viewModel.HidePlayerForCharacter,
                    GetCustomFieldValuesFromPost(),
                    viewModel.IsHot);

                return(RedirectToAction("Details", new { viewModel.ProjectId, viewModel.CharacterId }));
            }
            catch (Exception exception)
            {
                ModelState.AddException(exception);
                return(View(viewModel.Fill(field, CurrentUserId)));
            }
        }
        public async Task <ActionResult> Edit(EditCharacterViewModel viewModel)
        {
            var field =
                await CharacterRepository.GetCharacterAsync(viewModel.ProjectId,
                                                            viewModel.CharacterId);

            try
            {
                if (!ModelState.IsValid)
                {
                    return(View(viewModel.Fill(field, CurrentUserId)));
                }

                await CharacterService.EditCharacter(
                    CurrentUserId,
                    viewModel.CharacterId,
                    viewModel.ProjectId,
                    viewModel.Name,
                    viewModel.IsPublic,
                    viewModel.ParentCharacterGroupIds.GetUnprefixedGroups(),
                    viewModel.IsAcceptingClaims&&
                    field.ApprovedClaim == null,
                    viewModel.HidePlayerForCharacter,
                    Request.GetDynamicValuesFromPost(FieldValueViewModel.HtmlIdPrefix),
                    viewModel.IsHot);

                return(RedirectToAction("Details",
                                        new { viewModel.ProjectId, viewModel.CharacterId }));
            }
            catch (Exception exception)
            {
                ModelState.AddException(exception);
                return(View(viewModel.Fill(field, CurrentUserId)));
            }
        }
Beispiel #4
0
        public async Task <ActionResult> Edit(EditCharacterViewModel viewModel)
        {
            var field = await ProjectRepository.GetCharacterAsync(viewModel.ProjectId, viewModel.CharacterId);

            var error = AsMaster(field, s => s.CanEditRoles);

            if (error != null)
            {
                return(error);
            }
            try
            {
                if (!ModelState.IsValid)
                {
                    return(View(viewModel.Fill(field, CurrentUserId)));
                }
                await ProjectService.EditCharacter(
                    CurrentUserId,
                    viewModel.CharacterId,
                    viewModel.ProjectId,
                    viewModel.Name, viewModel.IsPublic, viewModel.ParentCharacterGroupIds.GetUnprefixedGroups(), viewModel.IsAcceptingClaims,
                    viewModel.Description,
                    viewModel.HidePlayerForCharacter,
                    GetCustomFieldValuesFromPost(),
                    viewModel.IsHot);

                return(RedirectToAction("Details", new { viewModel.ProjectId, viewModel.CharacterId }));
            }
            catch (Exception exception)
            {
                ModelState.AddException(exception);
                return(View(viewModel.Fill(field, CurrentUserId)));
            }
        }
Beispiel #5
0
        public async Task <IActionResult> EditCharacter(EditCharacterViewModel model)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var dto = Mapper <EditCharacterViewModel, EditCharacterDTO>(model);
                    await _characterService.UpdateCharacter(dto, User.Identity.Name);

                    return(View(model));
                }
                catch (TryingToAccessOtherAccountException)
                {
                    // If someone try to access a character of other account
                    LogInformation($" Trying to access other persons character edit page. Account: {User.Identity.Name}");
                    return(RedirectToAction(nameof(Index)));
                }
                catch (InvalidIdException)
                {
                    // id of a character that does not exist
                    return(RedirectToAction(nameof(Index)));
                }
                catch (Exception ex)
                {
                    LogError(ex, nameof(AccountController), nameof(EditCharacter));
                    AddModelErrors(_localizer["UnknownErrorContactAnAdmin"]);
                }
            }

            return(View(model));
        }
        public EditCharacterPage(CharacterCreateUpdateDTO character)
        {
            InitializeComponent();

            BindingContext        = _viewModel = DependencyService.Resolve <EditCharacterViewModel>();
            _viewModel.Navigation = Navigation;
            _viewModel.Init(character);
        }