public async Task <ActionResult> DeleteEx(int projectId, int projectFieldId)
{
try
{
ProjectField field = await ProjectRepository.GetProjectField(projectId, projectFieldId);
if (field == null)
{
return(HttpNotFound());
}
if (AsMaster(field, pa => pa.CanChangeFields) != null)
{
return(new HttpUnauthorizedResult());
}
await FieldSetupService.DeleteField(field);
return(field.IsActive
? new HttpStatusCodeResult(200)
: new HttpStatusCodeResult(250));
}
catch (Exception)
{
// TODO: Implement exception logging here
return(new HttpStatusCodeResult(500));
}
}
public async Task AddField(CreateFieldRequest request)
{
var project = await ProjectRepository.GetProjectAsync(request.ProjectId);
_ = project.RequestMasterAccess(CurrentUserId, acl => acl.CanChangeFields);
if (project.GetTimeSlotFieldOrDefault() != null && request.FieldType == ProjectFieldType.ScheduleTimeSlotField)
{
throw new JoinFieldScheduleShouldBeUniqueException(project);
}
if (project.GetRoomFieldOrDefault() != null && request.FieldType == ProjectFieldType.ScheduleRoomField)
{
throw new JoinFieldScheduleShouldBeUniqueException(project);
}
var field = new ProjectField
{
ProjectId = request.ProjectId,
Project = project,
FieldType = request.FieldType,
FieldBoundTo = request.FieldBoundTo,
};
await SetFieldPropertiesFromRequest(request, field);
project.ProjectFields.Add(field);
SetScheduleStatusBasedOnFields(project);
_ = UnitOfWork.GetDbSet <ProjectField>().Add(field);
await UnitOfWork.SaveChangesAsync();
}
public GameFieldEditViewModel(ProjectField field, int currentUserId)
{
CanPlayerView = field.CanPlayerView;
CanPlayerEdit = field.CanPlayerEdit;
DescriptionEditable = field.Description.Contents;
MasterDescriptionEditable = field.MasterDescription.Contents;
DescriptionDisplay = field.Description.ToHtmlString();
MasterDescriptionDisplay = field.MasterDescription.ToHtmlString();
ProjectFieldId = field.ProjectFieldId;
IsPublic = field.IsPublic;
Name = field.FieldName;
ProjectId = field.ProjectId;
MandatoryStatus = (MandatoryStatusViewType)field.MandatoryStatus;
ShowForGroups = field
.GroupsAvailableFor
.Select(c => c.CharacterGroupId)
.PrefixAsGroups()
.ToList();
IncludeInPrint = field.IncludeInPrint;
ValidForNpc = field.ValidForNpc;
ShowForUnApprovedClaim = field.ShowOnUnApprovedClaims;
Price = field.Price;
ProgrammaticValue = field.ProgrammaticValue;
FillNotEditable(field, currentUserId);
}
public async Task AddField(int projectId, ProjectFieldType fieldType, string name, string fieldHint, bool canPlayerEdit, bool canPlayerView, bool isPublic, FieldBoundTo fieldBoundTo, MandatoryStatus mandatoryStatus, List <int> showForGroups, bool validForNpc, bool includeInPrint, bool showForUnapprovedClaims)
{
var project = await ProjectRepository.GetProjectAsync(projectId);
project.RequestMasterAccess(CurrentUserId, acl => acl.CanChangeFields);
var field = new ProjectField
{
FieldName = Required(name),
Description = new MarkdownString(fieldHint),
CanPlayerEdit = canPlayerEdit,
CanPlayerView = canPlayerView,
ValidForNpc = validForNpc,
IsPublic = isPublic,
ProjectId = projectId,
Project = project, //We require it for CreateOrUpdateSpecailGroup
FieldType = fieldType,
FieldBoundTo = fieldBoundTo,
IsActive = true,
MandatoryStatus = mandatoryStatus,
AvailableForCharacterGroupIds = await ValidateCharacterGroupList(projectId, showForGroups),
IncludeInPrint = includeInPrint,
ShowOnUnApprovedClaims = showForUnapprovedClaims
};
CreateOrUpdateSpecialGroup(field);
UnitOfWork.GetDbSet <ProjectField>().Add(field);
await UnitOfWork.SaveChangesAsync();
}
private void CreateOrUpdateSpecialGroup(ProjectField field)
{
if (!field.HasSpecialGroup())
{
return;
}
if (field.CharacterGroup == null)
{
field.CharacterGroup = new CharacterGroup()
{
AvaiableDirectSlots = 0,
HaveDirectSlots = false,
ParentCharacterGroupIds = new[] { field.Project.RootGroup.CharacterGroupId },
ProjectId = field.ProjectId,
IsRoot = false,
IsSpecial = true,
ResponsibleMasterUserId = null,
};
MarkCreatedNow(field.CharacterGroup);
}
foreach (var fieldValue in field.DropdownValues)
{
if (fieldValue.CharacterGroup == null)
{
continue; //We can't convert to LINQ because of RSRP-457084
}
UpdateSpecialGroupProperties(fieldValue);
}
UpdateSpecialGroupProperties(field);
}
private static void CreateOrUpdateSpecialGroup(ProjectField field)
{
if (!field.HasSpecialGroup())
{
return;
}
field.CharacterGroup = field.CharacterGroup ?? new CharacterGroup()
{
AvaiableDirectSlots = 0,
HaveDirectSlots = false,
ParentCharacterGroupIds = new [] { field.Project.RootGroup.CharacterGroupId },
ProjectId = field.ProjectId,
IsRoot = false,
IsSpecial = true,
ResponsibleMasterUserId = null,
};
field.CharacterGroup.IsPublic = field.IsPublic;
foreach (var fieldValue in field.DropdownValues)
{
if (fieldValue.CharacterGroup == null)
{
continue; //We can't convert to LINQ because of RSRP-457084
}
fieldValue.CharacterGroup.IsPublic = field.IsPublic;
fieldValue.CharacterGroup.CharacterGroupName = fieldValue.GetSpecialGroupName();
}
field.CharacterGroup.IsActive = field.IsActive;
field.CharacterGroup.Description = field.Description;
field.CharacterGroup.CharacterGroupName = field.GetSpecialGroupName();
}
private void CreateFieldValueVariantImpl(
[NotNull] ProjectField field,
[NotNull] string label,
[CanBeNull] string description,
[CanBeNull] string masterDescription,
[CanBeNull] string programmaticValue)
{
var fieldValue = new ProjectFieldDropdownValue()
{
Description = new MarkdownString(description),
Label = label,
IsActive = true,
WasEverUsed = false,
ProjectId = field.ProjectId,
ProjectFieldId = field.ProjectFieldId,
Project = field.Project,
ProjectField = field,
MasterDescription = new MarkdownString(masterDescription),
ProgrammaticValue = programmaticValue,
};
CreateOrUpdateSpecialGroup(fieldValue);
field.DropdownValues.Add(fieldValue);
}
public FieldWithPreviousAndNewValue(
ProjectField field,
[CanBeNull] string value,
[CanBeNull] string previousValue) : base(field, value)
{
PreviousValue = previousValue;
}
/// <summary>
/// Deletes field by its object. We assume here that field represents really existed field in really existed project
/// </summary>
/// <param name="field">Field to delete</param>
private async Task DeleteField(ProjectField field)
{
field.RequestMasterAccess(CurrentUserId, acl => acl.CanChangeFields);
if (field.IsName())
{
throw new JoinRpgNameFieldDeleteException(field);
}
if (field.IsDescription())
{
field.Project.Details.CharacterDescription = null;
}
if (field.IsRoomSlot() || field.IsTimeSlot())
{
throw new JoinFieldScheduleUseException(field);
}
foreach (var fieldValueVariant in field.DropdownValues.ToArray()) //Required, cause we modify fields inside.
{
DeleteFieldVariantValueImpl(fieldValueVariant);
}
var characterGroup = field.CharacterGroup; // SmartDelete will nullify all depend properties
if (SmartDelete(field))
{
SmartDelete(characterGroup);
}
else if (characterGroup != null)
{
characterGroup.IsActive = false;
}
await UnitOfWork.SaveChangesAsync();
}
public string CreateDefaultValue(Character character, ProjectField field)
{
return(character != null
? PluginFactory
.GenerateDefaultCharacterFieldValue(character, field)
: null);
}
public GameFieldDropdownValueViewModelBase(ProjectField field)
{
FieldName = field.FieldName;
ProjectId = field.ProjectId;
ProjectFieldId = field.ProjectFieldId;
PlayerSelectable = CanPlayerEditField = field.CanPlayerEdit;
}
public async Task <ProjectField> DeleteField(int projectId, int projectFieldId)
{
ProjectField field = await ProjectRepository.GetProjectField(projectId, projectFieldId);
await DeleteField(field);
return(field);
}
public string GenerateDefaultCharacterFieldValue(Character character, ProjectField field)
{
var operations = GetProjectOperations <IGenerateFieldOperation>(field.Project).HasMapping(field);
return(operations.Select(o => o.CreatePluginInstance()
.GenerateFieldValue(character.ToPluginModel(), new CharacterFieldInfo(field.ProjectFieldId, null, field.FieldName, null)))
.FirstOrDefault(newValue => newValue != null));
}
public FieldRelatedProblem(ClaimProblemType problemType, ProblemSeverity severity, [NotNull] ProjectField field)
: base(problemType, severity, null, field.FieldName)
{
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
Field = field;
}
public static IEnumerable <PluginOperationData <T> > HasMapping <T>(
this IEnumerable <PluginOperationData <T> > operations, ProjectField field)
where T : IPluginOperation, IFieldOperation
{
return(operations
.Where(o => field.Mappings.Any(m => m.MappingName == o.FieldMapping &&
m.PluginFieldMappingType ==
PluginFieldMappingType.GenerateDefault)));
}
public GameFieldDropdownValueCreateViewModel(ProjectField field) : base(field)
{
Label = $"Вариант {field.DropdownValues.Count + 1}";
if (field.IsTimeSlot())
{
var options = field.GetDefaultTimeSlotOptions();
TimeSlotInMinutes = options.TimeSlotInMinutes;
TimeSlotStartTime = options.StartTime;
}
}
public GameFieldDropdownValueEditViewModel(ProjectField field, ProjectFieldDropdownValue value) : base(field)
{
Label = value.Label;
Description = value.Description.Contents;
IsActive = value.IsActive;
Price = value.Price;
ProjectFieldDropdownValueId = value.ProjectFieldDropdownValueId;
PlayerSelectable = value.PlayerSelectable;
ProgrammaticValue = value.ProgrammaticValue;
}
public static bool IsAvailableForTarget([NotNull] this ProjectField field, [CanBeNull] IClaimSource target)
{
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
return(field.IsActive &&
(field.FieldBoundTo == FieldBoundTo.Claim || field.ValidForNpc || !target.IsNpc()) &&
(!field.GroupsAvailableFor.Any() || target.IsPartOfAnyOfGroups(field.GroupsAvailableFor)));
}
/// <summary>
/// Método para realizar todas as validações na criação de um ProjectField
/// </summary>
/// <param name="projectField">ProjectField a ser criado</param>
/// <returns>Retorna true caso todas as validações sejam satisfeitas</returns>
public static bool CreateProjectFieldScopeIsValid(this ProjectField projectField)
{
return(AssertionConcern.IsSatisfiedBy
(
AssertionConcern.AssertNotNull(projectField, "O Objeto não pode ser vazio"),
AssertionConcern.AssertGuidIsNotEmpty(projectField.ProjectFieldId, "O Guid não pode ser vazio"),
AssertionConcern.AssertNotEmpty(projectField.Name, "O Nome do campo não pode ser vazio"),
AssertionConcern.AssertTrue(projectField.OrderPosition >= 0, "A Ordem de processamento deste campo deve ser maior ou igual a 0")
));
}
public ScheduleBuilder(Project project, ICollection <Character> characters)
{
this.characters = characters.Where(ch => ch.IsActive).ToList();
RoomField = project.GetRoomFieldOrDefault();
TimeSlotField = project.GetTimeSlotFieldOrDefault();
if (RoomField is null || TimeSlotField is null)
{
throw new Exception("Schedule not enabled");
}
}
public void FillNotEditable(ProjectField field, int currentUserId)
{
DropdownValues = field.GetOrderedValues()
.Select(fv => new GameFieldDropdownValueListItemViewModel(fv))
.MarkFirstAndLast();
FieldViewType = (ProjectFieldViewType)field.FieldType;
FieldBoundTo = (FieldBoundToViewModel)field.FieldBoundTo;
IsActive = field.IsActive;
HasValueList = field.HasValueList();
CanEditFields = field.HasMasterAccess(currentUserId, acl => acl.CanChangeFields);
}
public ProjectField CreateField(ProjectField field = null)
{
field ??= new ProjectField();
field.Project = Project;
field.ProjectId = Project.ProjectId;
field.ProjectFieldId = Project.ProjectFields.GetNextId();
field.FieldName ??= "test_" + field.ProjectFieldId;
field.AvailableForCharacterGroupIds = Array.Empty <int>();
field.IsActive = true;
Project.ProjectFields.Add(field);
return(field);
}
public static bool HasProblemsForField([NotNull] this Character character, [NotNull] ProjectField field)
{
if (character == null)
{
throw new ArgumentNullException(nameof(character));
}
if (field == null)
{
throw new ArgumentNullException(nameof(field));
}
return(character.GetProblems().OfType <FieldRelatedProblem>().Any(fp => fp.Field == field));
}
private static ProjectFieldDropdownValue GetPreviousVariant([NotNull] this ProjectField field,
[CanBeNull] ProjectFieldDropdownValue variant)
{
if (variant is null)
{
return(field.GetOrderedValues().LastOrDefault());
}
var variants = field.GetOrderedValues().ToList();
var prevPosition = variants.IndexOf(variant) - 1;
return(prevPosition < 0 ? null : variants[prevPosition]);
}
public ScheduleBuilder(Project project, ICollection <Character> characters)
{
this.characters = characters;
var scheduleSettings = project.Details.ScheduleSettings;
if (scheduleSettings is null)
{
throw new Exception("Schedule not enabled");
}
TimeSlotField = scheduleSettings.TimeSlotField;
RoomField = scheduleSettings.RoomField;
}
public TimeSlotOptions GetTimeSlotRequest(ProjectField field, string value)
{
return(field.IsTimeSlot()
? new TimeSlotOptions
{
StartTime = DateTimeOffset.ParseExact(
value,
"yyyy-MM-ddTHH:mmK",
System.Globalization.CultureInfo.InvariantCulture),
TimeSlotInMinutes = TimeSlotInMinutes
}
: null);
}
public ProjectField Create(CreateProjectFieldCommand command)
{
var projectField = new ProjectField(command);
projectField.CreateProjectField(projectField);
_repository.Create(projectField);
if (Commit())
{
return(projectField);
}
return(null);
}
public void FillNotEditable(ProjectField field, int currentUserId)
{
DropdownValues = field.GetOrderedValues()
.Select(fv => new GameFieldDropdownValueListItemViewModel(fv))
.MarkFirstAndLast();
FieldViewType = (ProjectFieldViewType)field.FieldType;
FieldBoundTo = (FieldBoundToViewModel)field.FieldBoundTo;
IsActive = field.IsActive;
HasValueList = field.HasValueList();
WasEverUsed = field.WasEverUsed;
CanEditFields = field.HasMasterAccess(currentUserId, acl => acl.CanChangeFields);
CanDeleteField = CanEditFields && !field.IsName() && !field.IsRoomSlot() && !field.IsTimeSlot();
IsTimeField = field.IsTimeSlot();
SupportsMassAdding = field.SupportsMassAdding();
}
private void UpdateSpecialGroupProperties(ProjectField field)
{
var characterGroup = field.CharacterGroup;
var specialGroupName = field.GetSpecialGroupName();
if (characterGroup.IsPublic != field.IsPublic || characterGroup.IsActive != field.IsActive ||
characterGroup.Description != field.Description ||
characterGroup.CharacterGroupName != specialGroupName)
{
characterGroup.IsPublic = field.IsPublic;
characterGroup.IsActive = field.IsActive;
characterGroup.Description = field.Description;
characterGroup.CharacterGroupName = specialGroupName;
MarkChanged(characterGroup);
}
}
public GameFieldDropdownValueEditViewModel(ProjectField field, ProjectFieldDropdownValue value) : base(field)
{
Label = value.Label;
Description = value.Description.Contents;
IsActive = value.IsActive;
Price = value.Price;
ProjectFieldDropdownValueId = value.ProjectFieldDropdownValueId;
PlayerSelectable = value.PlayerSelectable;
ProgrammaticValue = value.ProgrammaticValue;
if (field.IsTimeSlot())
{
var options = value.GetTimeSlotOptions();
TimeSlotInMinutes = options.TimeSlotInMinutes;
TimeSlotStartTime = options.StartTime;
}
}
