public async Task <ActionResult> RestoreByMaster(int projectId, int claimId, ClaimOperationViewModel viewModel)
{
var claim = await _claimsRepository.GetClaim(projectId, claimId);
if (claim == null)
{
return(NotFound());
}
try
{
if (!ModelState.IsValid)
{
return(await ShowClaim(claim));
}
await
_claimService.RestoreByMaster(claim.ProjectId, claim.ClaimId, CurrentUserId, viewModel.CommentText);
return(ReturnToClaim(projectId, claimId));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(await ShowClaim(claim));
}
}
public async Task <ActionResult> Close(CloseProjectViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
try
{
await ProjectService.CloseProject(viewModel.ProjectId,
CurrentUserId,
viewModel.PublishPlot);
return(await RedirectToProject(viewModel.ProjectId));
}
catch (Exception ex)
{
ModelState.AddException(ex);
var project = await ProjectRepository.GetProjectAsync(viewModel.ProjectId);
viewModel.OriginalName = project.ProjectName;
viewModel.IsMaster =
project.HasMasterAccess(CurrentUserId, acl => acl.CanChangeProjectProperties);
return(View(viewModel));
}
}
public async Task <ActionResult> Create(GameFieldCreateViewModel viewModel)
{
var project = await ProjectRepository.GetProjectAsync(viewModel.ProjectId);
var error = AsMaster(project, pa => pa.CanChangeFields);
if (error != null)
{
return(error);
}
if (!ModelState.IsValid)
{
return(View(FillFromProject(project, viewModel)));
}
try
{
await FieldSetupService.AddField(project.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);
return(ReturnToIndex(project));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(View(FillFromProject(project, viewModel)));
}
}
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)));
}
}
public async Task <ActionResult> Add(AddClaimViewModel viewModel)
{
var project = await ProjectRepository.GetProjectAsync(viewModel.ProjectId);
var error = WithEntity(project);
if (error != null)
{
return(error);
}
try
{
await _claimService.AddClaimFromUser(viewModel.ProjectId, viewModel.CharacterGroupId, viewModel.CharacterId,
CurrentUserId, viewModel.ClaimText,
GetCustomFieldValuesFromPost());
return(RedirectToAction(
"SetupProfile",
"Manage",
new { checkContactsMessage = true }));
}
catch (Exception exception)
{
ModelState.AddException(exception);
var source = await GetClaimSource(viewModel.ProjectId, viewModel.CharacterGroupId, viewModel.CharacterId);
//TODO: Отображать ошибки верно
return(View(viewModel.Fill(source, GetCurrentUser())));
}
}
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> Add(AddClaimViewModel viewModel)
{
var project = await ProjectRepository.GetProjectAsync(viewModel.ProjectId);
if (project == null)
{
return(HttpNotFound());
}
try
{
await _claimService.AddClaimFromUser(viewModel.ProjectId, viewModel.CharacterGroupId, viewModel.CharacterId, viewModel.ClaimText,
GetCustomFieldValuesFromPost());
return(RedirectToAction(
"SetupProfile",
"Manage",
new { checkContactsMessage = true }));
}
catch (Exception exception)
{
ModelState.AddException(exception);
var source = await ProjectRepository.GetClaimSource(viewModel.ProjectId, viewModel.CharacterGroupId, viewModel.CharacterId).ConfigureAwait(false);
return(View(viewModel.Fill(source, CurrentUserId)));
}
}
public async Task <ActionResult> AddGroup(AddCharacterGroupViewModel viewModel, int charactergroupid)
{
var field = await ProjectRepository.GetGroupAsync(viewModel.ProjectId, charactergroupid);
if (field == null)
{
return(HttpNotFound());
}
if (!ModelState.IsValid)
{
return(View(FillFromCharacterGroup(viewModel, field)));
}
try
{
var responsibleMasterId = viewModel.ResponsibleMasterId == -1 ? (int?)null : viewModel.ResponsibleMasterId;
await ProjectService.AddCharacterGroup(
viewModel.ProjectId,
viewModel.Name, viewModel.IsPublic,
viewModel.ParentCharacterGroupIds.GetUnprefixedGroups(), viewModel.Description, viewModel.HaveDirectSlotsForSave(),
viewModel.DirectSlotsForSave(), responsibleMasterId);
return(RedirectToIndex(field.ProjectId, viewModel.ParentCharacterGroupIds.GetUnprefixedGroups().First()));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(View(FillFromCharacterGroup(viewModel, field)));
}
}
public async Task <ActionResult> CreateThread([NotNull] CreateForumThreadViewModel viewModel)
{
var group = (await ProjectRepository.GetGroupAsync(viewModel.ProjectId, viewModel.CharacterGroupId)).EnsureActive();
viewModel.CharacterGroupName = group.CharacterGroupName;
viewModel.ProjectName = group.Project.ProjectName;
if (!ModelState.IsValid)
{
return(View(viewModel));
}
try
{
var forumThreadId = await ForumService.CreateThread(
viewModel.ProjectId,
viewModel.CharacterGroupId,
viewModel.Header,
viewModel.CommentText,
viewModel.HideFromUser,
viewModel.EmailEverybody);
return(RedirectToAction("ViewThread", new { viewModel.ProjectId, forumThreadId }));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(View(viewModel));
}
}
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(HttpNotFound());
}
if (!ModelState.IsValid)
{
viewModel.FillNotEditable(field, CurrentUserId);
return(View(viewModel));
}
try
{
await
FieldSetupService.UpdateFieldParams(project.ProjectId, field.ProjectFieldId,
viewModel.Name, viewModel.DescriptionEditable, viewModel.CanPlayerEdit, viewModel.CanPlayerView,
viewModel.IsPublic, (MandatoryStatus)viewModel.MandatoryStatus,
viewModel.ShowForGroups.GetUnprefixedGroups(), viewModel.ValidForNpc, viewModel.IncludeInPrint,
viewModel.ShowForUnApprovedClaim);
return(ReturnToIndex(project));
}
catch (Exception exception)
{
ModelState.AddException(exception);
viewModel.FillNotEditable(field, CurrentUserId);
return(View(viewModel));
}
}
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));
}
}
public async Task <ActionResult> DeclineByMaster(MasterDenialOperationViewModel viewModel)
{
var claim = await _claimsRepository.GetClaim(viewModel.ProjectId, viewModel.ClaimId);
if (claim == null)
{
return(HttpNotFound());
}
try
{
if (!ModelState.IsValid)
{
return(await ShowClaim(claim));
}
await
_claimService.DeclineByMaster(
claim.ProjectId,
claim.ClaimId,
(Claim.DenialStatus) viewModel.DenialStatus,
viewModel.CommentText,
viewModel.DeleteCharacter);
return(ReturnToClaim(viewModel));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(await ShowClaim(claim));
}
}
public async Task <ActionResult> SetupProfile(EditUserProfileViewModel viewModel)
{
try
{
await
_userService.UpdateProfile(viewModel.UserId, viewModel.SurName, viewModel.FatherName,
viewModel.BornName, viewModel.PrefferedName, viewModel.Gender, viewModel.PhoneNumber, viewModel.Nicknames,
viewModel.GroupNames, viewModel.Skype, viewModel.Vk, viewModel.Livejournal, viewModel.Telegram);
if (viewModel.LastClaimId == null || viewModel.LastClaimProjectId == null)
{
return(RedirectToAction("SetupProfile"));
}
else
{
return(RedirectToAction("Edit", "Claim",
new { ClaimId = viewModel.LastClaimId, ProjectId = viewModel.LastClaimProjectId }));
}
}
catch (Exception e)
{
ModelState.AddException(e);
return(View(viewModel));
}
}
public async Task <ActionResult> DeclineByPlayer(ClaimOperationViewModel viewModel)
{
var claim = await _claimsRepository.GetClaim(viewModel.ProjectId, viewModel.ClaimId);
if (claim == null)
{
return(HttpNotFound());
}
if (claim.PlayerUserId != CurrentUserId)
{
return(NoAccesToProjectView(claim.Project));
}
try
{
if (!ModelState.IsValid)
{
return(await ShowClaim(claim));
}
await
_claimService.DeclineByPlayer(claim.ProjectId, claim.ClaimId, viewModel.CommentText);
return(ReturnToClaim(viewModel));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(await ShowClaim(claim));
}
}
/// <param name="viewModel"></param>
/// <param name="claimTarget">Note that name is hardcoded in view. (TODO improve)</param>
public async Task <ActionResult> Move(AddCommentViewModel viewModel, string claimTarget)
{
var claim = await _claimsRepository.GetClaim(viewModel.ProjectId, viewModel.ClaimId);
var error = AsMaster(claim);
if (error != null)
{
return(error);
}
try
{
if (!ModelState.IsValid)
{
return(await ShowClaim(claim));
}
var characterGroupId = claimTarget.UnprefixNumber(CharacterAndGroupPrefixer.GroupFieldPrefix);
var characterId = claimTarget.UnprefixNumber(CharacterAndGroupPrefixer.CharFieldPrefix);
await
_claimService.MoveByMaster(claim.ProjectId, claim.ClaimId, CurrentUserId, viewModel.CommentText, characterGroupId, characterId);
return(ReturnToClaim(viewModel));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(await ShowClaim(claim));
}
}
public async Task <ActionResult> CreateElement(int projectId, int plotFolderId, string content,
string todoField, [CanBeNull] ICollection <string> targets, PlotElementTypeView elementType)
{
try
{
return(await CreateElementImpl(projectId, plotFolderId, content, todoField, targets, elementType));
}
catch (Exception exception)
{
ModelState.AddException(exception);
var folder = await _plotRepository.GetPlotFolderAsync(projectId, plotFolderId);
if (folder == null)
{
return(NotFound());
}
return(View(new AddPlotElementViewModel()
{
ProjectId = projectId,
PlotFolderId = plotFolderId,
PlotFolderName = folder.MasterTitle,
Content = content,
TodoField = todoField,
}));
}
}
public async Task <ActionResult> EditSubscribe(SubscribeSettingsViewModel viewModel)
{
var group = await ProjectRepository.GetGroupAsync(viewModel.ProjectId, viewModel.CharacterGroupId);
if (group == null)
{
return(HttpNotFound());
}
var user = await UserRepository.GetWithSubscribe(CurrentUserId);
var serverModel = new SubscribeSettingsViewModel(user, group);
serverModel.OrSetIn(viewModel);
try
{
await
ProjectService.UpdateSubscribeForGroup(new SubscribeForGroupRequest
{
CharacterGroupId = group.CharacterGroupId,
ProjectId = group.ProjectId,
}.AssignFrom(serverModel.GetOptionsToSubscribeDirectly()));
return(RedirectToIndex(group.Project));
}
catch (Exception e)
{
ModelState.AddException(e);
return(View(serverModel));
}
}
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)));
}
}
public async Task <ActionResult> Create(ProjectCreateViewModel model)
{
try
{
var project = await ProjectService.AddProject(model.ProjectName, GetCurrentUser());
return(RedirectTo(project));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(View(model));
}
}
public async Task <ActionResult> Create(AddPlotFolderViewModel viewModel)
{
try
{
await _plotService.CreatePlotFolder(viewModel.ProjectId, viewModel.PlotFolderTitleAndTags, viewModel.TodoField);
return(RedirectToAction("Index", "Plot", new { viewModel.ProjectId }));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(View(viewModel));
}
}
public async Task <ActionResult> Create(AddCharacterViewModel viewModel)
{
var characterGroupId = viewModel.ParentCharacterGroupIds.GetUnprefixedGroups().FirstOrDefault();
try
{
await CharacterService.AddCharacter(new AddCharacterRequest()
{
ProjectId = viewModel.ProjectId,
Name = viewModel.Name,
IsAcceptingClaims = viewModel.IsAcceptingClaims,
ParentCharacterGroupIds =
viewModel.ParentCharacterGroupIds.GetUnprefixedGroups(),
HidePlayerForCharacter = viewModel.HidePlayerForCharacter,
IsHot = viewModel.IsHot,
IsPublic = viewModel.IsPublic,
FieldValues = Request.GetDynamicValuesFromPost(FieldValueViewModel.HtmlIdPrefix),
});
if (viewModel.ContinueCreating)
{
return(RedirectToAction("Create",
new { viewModel.ProjectId, characterGroupId, viewModel.ContinueCreating }));
}
return(RedirectToIndex(viewModel.ProjectId, characterGroupId));
}
catch (Exception exception)
{
ModelState.AddException(exception);
CharacterGroup characterGroup;
if (characterGroupId == 0)
{
characterGroup = (await ProjectRepository.GetProjectAsync(viewModel.ProjectId))
.RootGroup;
}
else
{
characterGroup =
await ProjectRepository.GetGroupAsync(viewModel.ProjectId,
characterGroupId);
}
return(View(viewModel.Fill(characterGroup, CurrentUserId)));
}
}
// 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));
}
}
public async Task <ActionResult> Edit(EditPlotFolderViewModel viewModel)
{
try
{
await
_plotService.EditPlotFolder(viewModel.ProjectId, viewModel.PlotFolderId, viewModel.PlotFolderTitleAndTags, viewModel.TodoField);
return(ReturnToPlot(viewModel.ProjectId, viewModel.PlotFolderId));
}
catch (Exception exception)
{
ModelState.AddException(exception);
var folder = await _plotRepository.GetPlotFolderAsync(viewModel.ProjectId, viewModel.PlotFolderId);
viewModel.Fill(folder, CurrentUserId, UriService);
return(View(viewModel));
}
}
public async Task <ActionResult> Settings(FieldSettingsViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(await ViewIfFound(Manager.FillFailedSettingsModel(viewModel)));
}
try
{
await Manager.SettingsHandleAsync(viewModel);
return(ReturnToIndex());
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(View(await Manager.FillFailedSettingsModel(viewModel)));
}
}
public async Task <ActionResult> ForClaims(MassMailViewModel viewModel)
{
var claims = (await ClaimRepository.GetClaimsByIds(viewModel.ProjectId, viewModel.ClaimIds.UnCompressIdList())).ToList();
var project = claims.Select(c => c.Project).FirstOrDefault() ?? await ProjectRepository.GetProjectAsync(viewModel.ProjectId);
var canSendMassEmails = project.HasMasterAccess(CurrentUserId, acl => acl.CanSendMassMails);
var filteredClaims = claims.Where(claim => claim.ResponsibleMasterUserId == CurrentUserId || canSendMassEmails).ToArray();
var error = AsMaster(project);
if (error != null)
{
return(error);
}
try
{
var recepients =
filteredClaims
.Select(c => c.Player)
.UnionIf(project.ProjectAcls.Select(acl => acl.User), viewModel.AlsoMailToMasters)
.Distinct();
await EmailService.Email(new MassEmailModel()
{
Initiator = await GetCurrentUserAsync(),
ProjectName = project.ProjectName,
Text = new MarkdownString(viewModel.Body),
Recepients = recepients.ToList(),
Subject = viewModel.Subject
});
return(View("Success"));
}
catch (Exception exception)
{
viewModel.Claims = filteredClaims.Select(claim => new ClaimShortListItemViewModel(claim));
viewModel.ToMyClaimsOnlyWarning = !canSendMassEmails &&
claims.Any(c => c.ResponsibleMasterUserId != CurrentUserId);
viewModel.ProjectName = project.ProjectName;
ModelState.AddException(exception);
ModelState.AddModelError("", "При отправке письма произошла ошибка");
return(View(viewModel));
}
}
public async Task <ActionResult> Setup(CheckInSetupModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
await ProjectService.SetCheckInOptions(model.ProjectId, model.CheckInProgress,
model.EnableCheckInModule, model.AllowSecondRoles);
return(RedirectToAction("Setup", new { model.ProjectId }));
}
catch (Exception ex)
{
ModelState.AddException(ex);
return(View(model));
}
}
public async Task <ActionResult> SecondRole(SecondRoleViewModel model)
{
var claim = await ClaimsRepository.GetClaim(model.ProjectId, model.ClaimId);
if (claim == null)
{
return(HttpNotFound());
}
try
{
var newClaim = await ClaimService.MoveToSecondRole(model.ProjectId, model.ClaimId, model.CharacterId);
return(RedirectToAction("CheckIn", new { model.ProjectId, claimId = newClaim }));
}
catch (Exception ex)
{
ModelState.AddException(ex);
return(await ShowSecondRole(model.ProjectId, model.ClaimId));
}
}
public async Task <ActionResult> DoCheckIn(int projectId, int claimId, int money, Checkbox?feeAccepted)
{
var claim = await ClaimsRepository.GetClaim(projectId, claimId);
if (claim == null)
{
return(HttpNotFound());
}
try
{
await ClaimService.CheckInClaim(projectId, claimId, feeAccepted == Checkbox.@on?money : 0);
return(RedirectToAction("Index", new { projectId }));
}
catch (Exception ex)
{
ModelState.AddException(ex);
return(await ShowCheckInForm(claim));
}
}
public async Task <ActionResult> ChangeResponsible(int projectId, int claimId, int responsibleMasterId)
{
var claim = await _claimsRepository.GetClaim(projectId, claimId);
if (claim == null)
{
return(HttpNotFound());
}
try
{
await _claimService.SetResponsible(projectId, claimId, CurrentUserId, responsibleMasterId);
return(ReturnToClaim(claimId, projectId));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(await ShowClaim(claim));
}
}
public async Task <ActionResult> OnHoldByMaster(ClaimOperationViewModel viewModel)
{
var claim = await _claimsRepository.GetClaim(viewModel.ProjectId, viewModel.ClaimId);
if (claim == null)
{
return(HttpNotFound());
}
try
{
await
_claimService.OnHoldByMaster(claim.ProjectId, claim.ClaimId, CurrentUserId, viewModel.CommentText);
return(ReturnToClaim(viewModel));
}
catch (Exception exception)
{
ModelState.AddException(exception);
return(await ShowClaim(claim));
}
}
