Exemple #1
0
        public async Task <ActionResult> CreateValue(GameFieldDropdownValueCreateViewModel viewModel)
        {
            try
            {
                var field = await ProjectRepository.GetProjectField(viewModel.ProjectId, viewModel.ProjectFieldId);

                var timeSlotOptions = viewModel.GetTimeSlotRequest(field, Request.Form["TimeSlotStartTime"].FirstOrDefault());

                await
                FieldSetupService.CreateFieldValueVariant(
                    new CreateFieldValueVariantRequest(
                        viewModel.ProjectId,
                        viewModel.Label,
                        viewModel.Description,
                        viewModel.ProjectFieldId,
                        viewModel.MasterDescription,
                        viewModel.ProgrammaticValue,
                        viewModel.Price,
                        viewModel.PlayerSelectable,
                        timeSlotOptions));

                return(RedirectToAction("Edit", new { viewModel.ProjectId, projectFieldId = viewModel.ProjectFieldId }));
            }
            catch (Exception ex)
            {
                ModelState.AddException(ex);
                return(View(viewModel));
            }
        }
Exemple #2
0
        public async Task <ActionResult> MoveFast(int projectId, int projectFieldId, int?afterFieldId)
        {
            var value = await ProjectRepository.GetProjectField(projectId, projectFieldId);

            if (value == null)
            {
                return(NotFound());
            }

            if (afterFieldId == -1)
            {
                afterFieldId = null;
            }

            try
            {
                await FieldSetupService.MoveFieldAfter(projectId, projectFieldId, afterFieldId);


                return(ReturnToIndex());
            }
            catch
            {
                return(ReturnToIndex());
            }
        }
Exemple #3
0
        public async Task <ActionResult> EditValue(GameFieldDropdownValueEditViewModel viewModel)
        {
            try
            {
                var field = await ProjectRepository.GetProjectField(viewModel.ProjectId, viewModel.ProjectFieldId);

                await FieldSetupService.UpdateFieldValueVariant(new UpdateFieldValueVariantRequest(
                                                                    viewModel.ProjectId,
                                                                    viewModel.ProjectFieldDropdownValueId,
                                                                    viewModel.Label,
                                                                    viewModel.Description,
                                                                    viewModel.ProjectFieldId,
                                                                    viewModel.MasterDescription,
                                                                    viewModel.ProgrammaticValue,
                                                                    viewModel.Price,
                                                                    viewModel.PlayerSelectable,
                                                                    viewModel.GetTimeSlotRequest(field, Request.Form["TimeSlotStartTime"][0])
                                                                    ));

                return(RedirectToAction("Edit", new { viewModel.ProjectId, projectFieldId = viewModel.ProjectFieldId }));
            }
            catch
            {
                return(View(viewModel));
            }
        }
Exemple #4
0
        // ReSharper disable once UnusedParameter.Global
        public async Task <ActionResult> Delete(int projectId, int projectFieldId, IFormCollection collection)
        {
            var field = await ProjectRepository.GetProjectField(projectId, projectFieldId);

            try
            {
                await FieldSetupService.DeleteField(projectId, field.ProjectFieldId);

                return(ReturnToIndex());
            }
            catch (Exception exception)
            {
                ModelState.AddException(exception);
                return(View(field));
            }
        }
Exemple #5
0
        public async Task <ActionResult> Edit(GameFieldEditViewModel viewModel)
        {
            var project = await ProjectRepository.GetProjectAsync(viewModel.ProjectId);

            var field = project.ProjectFields.SingleOrDefault(e => e.ProjectFieldId == viewModel.ProjectFieldId);

            if (field == null)
            {
                return(NotFound());
            }
            if (!ModelState.IsValid)
            {
                viewModel.FillNotEditable(field, CurrentUserId);
                return(View(viewModel));
            }
            try
            {
                var request = new UpdateFieldRequest(project.ProjectId,
                                                     viewModel.Name,
                                                     viewModel.DescriptionEditable,
                                                     viewModel.CanPlayerEdit,
                                                     viewModel.CanPlayerView,
                                                     viewModel.IsPublic,
                                                     (MandatoryStatus)viewModel.MandatoryStatus,
                                                     viewModel.ShowForGroups.GetUnprefixedGroups(),
                                                     viewModel.ValidForNpc,
                                                     viewModel.IncludeInPrint,
                                                     viewModel.ShowForUnApprovedClaim,
                                                     viewModel.Price,
                                                     viewModel.MasterDescriptionEditable,
                                                     field.ProjectFieldId,
                                                     viewModel.ProgrammaticValue);

                await FieldSetupService.UpdateFieldParams(request);

                return(ReturnToIndex());
            }
            catch (Exception exception)
            {
                ModelState.AddException(exception);
                viewModel.FillNotEditable(field, CurrentUserId);
                return(View(viewModel));
            }
        }
Exemple #6
0
        public async Task <ActionResult> Move(int projectid, int listItemId, short direction)
        {
            var value = await ProjectRepository.GetProjectField(projectid, listItemId);

            if (value == null)
            {
                return(NotFound());
            }

            try
            {
                await FieldSetupService.MoveField(projectid, listItemId, direction);

                return(ReturnToIndex());
            }
            catch
            {
                return(ReturnToIndex());
            }
        }
Exemple #7
0
        public async Task <ActionResult> MassCreateValueVariants(int projectId, int projectFieldId, string valuesToAdd)
        {
            var value = await ProjectRepository.GetProjectField(projectId, projectFieldId);

            if (value == null)
            {
                return(NotFound());
            }

            try
            {
                await FieldSetupService.CreateFieldValueVariants(projectId, projectFieldId, valuesToAdd);


                return(ReturnToField(value));
            }
            catch
            {
                return(ReturnToField(value));
            }
        }
Exemple #8
0
        public async Task <ActionResult> MoveValue(int projectid, int listItemId, int parentObjectId, short direction)
        {
            var value = await ProjectRepository.GetProjectField(projectid, parentObjectId);

            if (value == null)
            {
                return(HttpNotFound());
            }

            try
            {
                await FieldSetupService.MoveFieldVariant(projectid, parentObjectId, listItemId, direction);


                return(ReturnToField(value));
            }
            catch
            {
                return(ReturnToField(value));
            }
        }
        public async Task <ActionResult> EditValue(GameFieldDropdownValueEditViewModel viewModel)
        {
            try
            {
                await FieldSetupService.UpdateFieldValueVariant(new UpdateFieldValueVariantRequest(
                                                                    viewModel.ProjectId,
                                                                    viewModel.ProjectFieldDropdownValueId,
                                                                    viewModel.Label,
                                                                    viewModel.Description,
                                                                    viewModel.ProjectFieldId,
                                                                    viewModel.MasterDescription,
                                                                    viewModel.ProgrammaticValue,
                                                                    viewModel.Price,
                                                                    viewModel.PlayerSelectable));

                return(RedirectToAction("Edit", new { viewModel.ProjectId, projectFieldId = viewModel.ProjectFieldId }));
            }
            catch
            {
                return(View(viewModel));
            }
        }
Exemple #10
0
        public async Task <ActionResult> DeleteValueEx(int projectId, int projectFieldId, int valueId)
        {
            try
            {
                var value = await ProjectRepository.GetFieldValue(projectId, projectFieldId, valueId);

                if (value == null)
                {
                    return(NotFound());
                }

                await FieldSetupService.DeleteFieldValueVariant(value.ProjectId, value.ProjectFieldId, value.ProjectFieldDropdownValueId);

                return(value.IsActive
                    ? Ok()
                    : StatusCode(250));
            }
            catch (Exception)
            {
                // TODO: Implement exception logging here
                return(StatusCode(500));
            }
        }
Exemple #11
0
        public async Task <ActionResult> Create(GameFieldCreateViewModel viewModel)
        {
            if (!ModelState.IsValid)
            {
                return(await ViewIfFound(Manager.FillFailedModel(viewModel)));
            }
            try
            {
                var request = new CreateFieldRequest(
                    viewModel.ProjectId,
                    (ProjectFieldType)viewModel.FieldViewType,
                    viewModel.Name,
                    viewModel.DescriptionEditable,
                    viewModel.CanPlayerEdit,
                    viewModel.CanPlayerView,
                    viewModel.IsPublic,
                    (FieldBoundTo)viewModel.FieldBoundTo,
                    (MandatoryStatus)viewModel.MandatoryStatus,
                    viewModel.ShowForGroups.GetUnprefixedGroups(),
                    viewModel.ValidForNpc,
                    viewModel.FieldBoundTo == FieldBoundToViewModel.Character && viewModel.CanPlayerView,
                    viewModel.ShowForUnApprovedClaim,
                    viewModel.Price,
                    viewModel.MasterDescriptionEditable,
                    programmaticValue: null);

                await FieldSetupService.AddField(request);

                return(ReturnToIndex());
            }
            catch (Exception exception)
            {
                ModelState.AddException(exception);
                return(View(await Manager.FillFailedModel(viewModel)));
            }
        }