// GET: Forms/Details/5
public IActionResult Formularz(int?id)
{
if (id == null)
{
return(NotFound());
}
//wyszukanie oraz przekonwertowanie do listy Id pól które są dołączone do formularza
//bierzemy pod uwagę tylko id pól należących do formularza
var fieldsInForm = _context.FormField.Where(ff => ff.IdForm == id).Select(ff => ff.IdField).ToList();
//pobieramy dane pól których id pobrano powyżej
var field = _context.Field.Where(f => fieldsInForm.Contains(f.Id)).ToList();
//przekształcenie do modelu pozwalającego przenoszenie wartości
//czyli dodanie miejsca na wartość "Value" której nie potrzebójemy w bazie danyc
//potrzebne jest jedynie w celu przeniesienia wartości wpisanych w otworzonym formularzu
//do metody POST
List <FieldWithValue> fieldWithValues = new List <FieldWithValue>();
//przepisywanie danych do odpowiedniego modelu. ma ktoś pomysł jak bardziej optymalnie przenosić???
foreach (var key in field)
{
FieldWithValue pom = new FieldWithValue();
pom.TextValue = "";
pom.Field.Id = key.Id;
pom.Field.Name = key.Name;
pom.Field.Type = key.Type;
fieldWithValues.Add(pom);
}
if (field == null)
{
return(NotFound());
}
return(View(fieldWithValues));
}
public static IHtmlString DefaultValue(this FieldWithValue field)
{
var checkboxField = field as CheckboxField;
if (checkboxField != null)
{
return(new HtmlString(checkboxField.Selected ? "true" : "undefined"));
}
var fieldWithFieldValues = field as FieldWithFieldValues;
if (fieldWithFieldValues == null)
{
return(new HtmlString("undefined"));
}
var defaultValues = fieldWithFieldValues.FieldValues.Where(f => f.Selected).ToArray();
if (fieldWithFieldValues.IsMultiSelectEnabled)
{
return(new HtmlString(string.Format("[{0}]", string.Join(",", defaultValues.Select(v => "\"" + HttpUtility.JavaScriptStringEncode(v.Value) + "\"")))));
}
return(new HtmlString(
defaultValues.Any()
? string.Format("\"{0}\"", HttpUtility.JavaScriptStringEncode(defaultValues.First().Value))
: "undefined"
));
}
public void ShouldBeAbleToCalculatePricing(ProjectFieldType projectFieldType)
{
var fieldWithValue = new FieldWithValue(new ProjectField {
FieldType = projectFieldType
}, null);
Should.NotThrow(() => fieldWithValue.GetCurrentFee());
}
public override bool IsMetBy(FieldWithValue fieldValue, IEnumerable <FieldWithValue> allCollectedFieldValues, IPublishedContent content)
{
return((
fieldValue != null && fieldValue.HasSubmittedValue
? fieldValue.SubmittedValue
: string.Empty
).Equals(ExpectedFieldValue ?? string.Empty, StringComparison.InvariantCultureIgnoreCase));
}
public string?GenerateDefaultValue(FieldWithValue field)
{
return(field.Field.FieldBoundTo switch
{
FieldBoundTo.Character => Generator.CreateDefaultValue(Character, field),
FieldBoundTo.Claim => Generator.CreateDefaultValue(Claim, field),
_ => throw new ArgumentOutOfRangeException(),
});
public override bool IsMetBy(FieldWithValue fieldValue, IEnumerable <FieldWithValue> allCollectedFieldValues, IPublishedContent content)
{
if (fieldValue == null)
{
// no such field
return(false);
}
return(fieldValue.HasSubmittedValue && fieldValue.SubmittedValue == ExpectedFieldValue);
}
public override bool IsMetBy(FieldWithValue fieldValue, IEnumerable <FieldWithValue> allCollectedFieldValues, IPublishedContent content)
{
if (fieldValue == null)
{
// no such field - we'll say it's empty :)
return(true);
}
return(fieldValue.HasSubmittedValue == false);
}
public override bool IsMetBy(FieldWithValue fieldValue, IEnumerable <FieldWithValue> allCollectedFieldValues, IPublishedContent content)
{
var fieldSubmittedValue = fieldValue != null && fieldValue.HasSubmittedValue ? fieldValue.SubmittedValue : string.Empty;
var otherFieldValue = allCollectedFieldValues.FirstOrDefault(f => f.Name == OtherFieldName);
var otherFieldSubmittedValue = otherFieldValue != null && otherFieldValue.HasSubmittedValue ? otherFieldValue.SubmittedValue : string.Empty;
// condition is met if the two submitted values do not match
return(fieldSubmittedValue.Equals(otherFieldSubmittedValue, StringComparison.InvariantCultureIgnoreCase) == false);
}
private static FieldData ToFieldData(FieldWithValue f)
{
return(new FieldData
{
Name = f.Name,
FormSafeName = f.FormSafeName,
SubmittedValue = f.SubmittedValue,
Invalid = f.Invalid
});
}
public static bool HasDefaultValue(this FieldWithValue field)
{
if (field is CheckboxField)
{
return(true);
}
var fieldWithFieldValues = field as FieldWithFieldValues;
return(fieldWithFieldValues != null && fieldWithFieldValues.FieldValues.Any(f => f.Selected));
}
public FieldValueViewModel(CustomFieldsViewModel model, [NotNull] FieldWithValue ch, ILinkRenderer renderer)
{
if (ch == null)
{
throw new ArgumentNullException(nameof(ch));
}
Value = ch.Value;
if (ch.Field.SupportsMarkdown())
{
DisplayString = new MarkdownString(ch.DisplayString).ToHtmlString(renderer);
}
else
{
DisplayString = ch.DisplayString.SanitizeHtml();
}
FieldViewType = (ProjectFieldViewType)ch.Field.FieldType;
FieldName = ch.Field.FieldName;
Description = ch.Field.Description.ToHtmlString();
IsPlayerVisible = ch.Field.CanPlayerView;
IsDeleted = !ch.Field.IsActive;
HasValue = ch.HasValue || !ch.Field.CanHaveValue();
var hasViewAccess = ch.Field.IsPublic ||
model.HasMasterAccess
||
(model.HasPlayerAccessToCharacter && ch.Field.CanPlayerView &&
ch.Field.FieldBoundTo == FieldBoundTo.Character)
||
(model.HasPlayerClaimAccess && ch.Field.CanPlayerView &&
ch.Field.FieldBoundTo == FieldBoundTo.Claim);
CanView = hasViewAccess &&
(ch.HasValue || (!ch.Field.CanHaveValue() && ch.Field.IsAvailableForTarget(model.Target)));
CanEdit = model.EditAllowed &&
ch.HasEditAccess(
model.HasMasterAccess,
model.HasPlayerAccessToCharacter,
model.HasPlayerClaimAccess,
model.Target);
if (ch.Field.HasValueList())
{
ValueList = ch.GetDropdownValues().ToArray();
PossibleValueList = ch.GetPossibleValues();
}
ProjectFieldId = ch.Field.ProjectFieldId;
FieldBound = (FieldBoundToViewModel)ch.Field.FieldBoundTo;
MandatoryStatus = IsDeleted ? MandatoryStatusViewType.Optional : (MandatoryStatusViewType)ch.Field.MandatoryStatus;
}
// test if the condition is met by a submitted field value
public override bool IsMetBy(FieldWithValue fieldValue, IEnumerable <FieldWithValue> allCollectedFieldValues, IPublishedContent content)
{
if (fieldValue == null || fieldValue.HasSubmittedValue == false)
{
// no such field or no submitted field value - the condition is met (LessThan will always be >= 1)
return(true);
}
// the condition is met if the length of the submitted value is less than the value defined for LessThan
return(fieldValue.SubmittedValue.Length < LessThan);
}
private static IEnumerable <ClaimProblem> CheckField(IClaimSource target, FieldWithValue fieldWithValue)
{
if (!fieldWithValue.Field.CanHaveValue())
{
yield break;
}
var isAvailableForTarget = fieldWithValue.Field.IsAvailableForTarget(target);
var hasValue = fieldWithValue.HasValue;
if (hasValue)
{
if (isAvailableForTarget)
{
yield break;
}
if (!fieldWithValue.Field.IsActive)
{
yield return(FieldProblem(ClaimProblemType.DeletedFieldHasValue, ProblemSeverity.Hint, fieldWithValue));
}
else
{
yield return(FieldProblem(ClaimProblemType.FieldShouldNotHaveValue, ProblemSeverity.Hint, fieldWithValue));
}
}
else
{
if (!isAvailableForTarget)
{
yield break;
}
switch (fieldWithValue.Field.MandatoryStatus)
{
case MandatoryStatus.Optional:
break;
case MandatoryStatus.Recommended:
yield return(FieldProblem(ClaimProblemType.FieldIsEmpty, ProblemSeverity.Hint, fieldWithValue));
break;
case MandatoryStatus.Required:
yield return(FieldProblem(ClaimProblemType.FieldIsEmpty, ProblemSeverity.Warning, fieldWithValue));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
public static bool HasDefaultValue(this FieldWithValue field)
{
if (field is IDefaultSelectableField)
{
return(true);
}
if (field.HasSubmittedValue)
{
return(true);
}
return(field is FieldWithFieldValues fieldWithFieldValues && fieldWithFieldValues.FieldValues.Any(f => f.Selected));
}
public void EnsureEditAccess(FieldWithValue field)
{
var accessArguments = Character != null
? new AccessArguments(Character, CurrentUserId)
: new AccessArguments(Claim, CurrentUserId);
var editAccess = field.HasEditAccess(accessArguments);
if (!editAccess)
{
throw new NoAccessToProjectException(Project, CurrentUserId);
}
}
private static string NormalizeValueBeforeAssign(FieldWithValue field, string toAssign)
{
switch (field.Field.FieldType)
{
case ProjectFieldType.Checkbox:
return(toAssign?.StartsWith(FieldWithValue.CheckboxValueOn) == true
? FieldWithValue.CheckboxValueOn
: "");
default:
return(string.IsNullOrEmpty(toAssign) ? null : toAssign);
}
}
public void EnsureEditAccess(FieldWithValue field)
{
var hasMasterAccess = Project.HasMasterAccess(CurrentUserId);
var characterAccess = Character?.HasPlayerAccess(CurrentUserId) ?? false;
var hasPlayerAccesToClaim = Claim?.HasPlayerAccesToClaim(CurrentUserId) ?? false;
var editAccess = field.HasEditAccess(hasMasterAccess,
characterAccess, hasPlayerAccesToClaim, Character ?? Claim.GetTarget());
if (!editAccess)
{
throw new NoAccessToProjectException(Project, CurrentUserId);
}
}
/// <summary>
/// Creates field value view object
/// </summary>
private FieldValueViewModel CreateFieldValueView(FieldWithValue fv, ILinkRenderer renderer)
{
FieldValueViewModel result = new FieldValueViewModel(this, fv, renderer);
// Here is the point to calculate total fee
if (result.HasPrice)
{
FieldsFee[result.FieldBound] += result.Fee;
FieldWithFeeCount[result.FieldBound]++;
HasFieldsWithFee = true;
}
return(result);
}
/// <summary>
/// Returns true is the value has changed
/// </summary>
public bool AssignFieldValue(FieldWithValue field, string newValue)
{
if (field.Value == newValue)
{
return(false);
}
UpdatedFields.Add(new FieldWithPreviousAndNewValue(field.Field, newValue, field.Value));
field.Value = newValue;
field.MarkUsed();
return(true);
}
public string CreateDefaultValue(Character character, FieldWithValue field)
{
if (field.IsName && character != null)
{
return(character.CharacterName);
// It helps battle akward situations where names was re-bound to some new field
// and empty values start overwriting names
}
return(character != null
? PluginFactory
.GenerateDefaultCharacterFieldValue(character, field.Field)
: null);
}
private string FormatForIndexAndSanitize(FieldWithValue field, IPublishedContent content, Guid rowId)
{
var value = field.FormatSubmittedValueForIndex(content, rowId);
if (string.IsNullOrWhiteSpace(value) || StripHtml == false || field.SupportsStripHtml == false)
{
return(value);
}
var doc = new HtmlAgilityPack.HtmlDocument {
OptionAutoCloseOnEnd = true
};
doc.LoadHtml(value);
return(doc.DocumentNode.InnerText);
}
public override bool IsMetBy(FieldWithValue fieldValue, IEnumerable <FieldWithValue> allCollectedFieldValues, IPublishedContent content)
{
if (fieldValue == null)
{
// no such field
return(false);
}
var otherFieldValue = allCollectedFieldValues.FirstOrDefault(f => f.Name == OtherFieldName);
if (otherFieldValue == null)
{
// no such field
return(false);
}
return(fieldValue.HasSubmittedValue && fieldValue.SubmittedValue.Equals(otherFieldValue.SubmittedValue, StringComparison.InvariantCultureIgnoreCase) == false);
}
public string?CreateDefaultValue(Character?character, FieldWithValue field)
{
if (field.IsName && character != null)
{
return(character.CharacterName);
// It helps battle akward situations where names was re-bound to some new field
// and empty values start overwriting names
}
if (field.Field.FieldType == ProjectFieldType.PinCode)
{
var random = new Random();
return(random.Next(9999).ToString("D4"));
}
return(null);
}
public void NonPublicFieldsShouldNotBeShownOnCharacters()
{
var field = Mock.CreateField(new ProjectField()
{
IsPublic = false, CanPlayerEdit = false
});
var value = new FieldWithValue(field, "xxx");
Mock.Character.JsonData = new[] { value }.SerializeFields();
var vm = AddClaimViewModel.Create(Mock.Character, Mock.Player.UserId);
var fieldView = vm.Fields.Field(field);
_ = fieldView.ShouldNotBeNull();
fieldView.ShouldBeHidden();
fieldView.ShouldBeReadonly();
}
private void SetFieldLabels(FieldWithValue ch)
{
void AddLabelIf(FieldSpecialLabelView label, bool predicate)
{
if (predicate)
{
Labels.Add(label);
}
}
AddLabelIf(FieldSpecialLabelView.ForClaim, ch.Field.FieldBoundTo == FieldBoundTo.Claim);
AddLabelIf(FieldSpecialLabelView.Name, ch.IsName);
AddLabelIf(FieldSpecialLabelView.Description, ch.IsDescription);
AddLabelIf(FieldSpecialLabelView.ScheduleTime, ch.IsTimeSlot);
AddLabelIf(FieldSpecialLabelView.SchedulePlace, ch.IsRoomSlot);
}
public static IHtmlString DefaultValue(this FieldWithValue field)
{
if (field is IDefaultSelectableField defaultSelectableField)
{
return(new HtmlString(defaultSelectableField.Selected ? "true" : "undefined"));
}
var fieldWithFieldValues = field as FieldWithFieldValues;
if (field.HasSubmittedValue)
{
if (field is DateField)
{
return(new HtmlString($"new Date(\"{HttpUtility.JavaScriptStringEncode(field.SubmittedValue)}\")"));
}
if (fieldWithFieldValues != null)
{
if (fieldWithFieldValues.IsMultiSelectEnabled)
{
return(new HtmlString($"[{string.Join(",", fieldWithFieldValues.SubmittedValues.Select(v => "\"" + HttpUtility.JavaScriptStringEncode(v) + "\""))}]"));
}
return(new HtmlString(
fieldWithFieldValues.SubmittedValues.Any()
? $"\"{HttpUtility.JavaScriptStringEncode(fieldWithFieldValues.SubmittedValues.First())}\""
: "undefined"
));
}
return(new HtmlString($"\"{HttpUtility.JavaScriptStringEncode(field.SubmittedValue)}\""));
}
if (fieldWithFieldValues == null)
{
return(new HtmlString("undefined"));
}
var defaultValues = fieldWithFieldValues.FieldValues.Where(f => f.Selected).ToArray();
if (fieldWithFieldValues.IsMultiSelectEnabled)
{
return(new HtmlString($"[{string.Join(",", defaultValues.Select(v => "\"" + HttpUtility.JavaScriptStringEncode(v.Value) + "\""))}]"));
}
return(new HtmlString(
defaultValues.Any()
? $"\"{HttpUtility.JavaScriptStringEncode(defaultValues.First().Value)}\""
: "undefined"
));
}
public FieldValueViewModel(
CustomFieldsViewModel model,
[NotNull] FieldWithValue ch,
ILinkRenderer renderer)
{
if (ch == null)
{
throw new ArgumentNullException(nameof(ch));
}
Value = ch.Value;
DisplayString = ch.Field.SupportsMarkdown()
? new MarkdownString(ch.DisplayString).ToHtmlString(renderer)
: ch.DisplayString.SanitizeHtml();
FieldViewType = (ProjectFieldViewType)ch.Field.FieldType;
FieldName = ch.Field.FieldName;
Description = ch.Field.Description.ToHtmlString();
IsPlayerVisible = ch.Field.CanPlayerView;
IsDeleted = !ch.Field.IsActive;
HasValue = ch.HasViewableValue;
var hasViewAccess = ch.HasViewableValue &&
ch.HasViewAccess(model.AccessArguments);
CanView = hasViewAccess && (ch.HasEditableValue || ch.Field.IsAvailableForTarget(model.Target));
CanEdit = model.EditAllowed &&
ch.HasEditAccess(model.AccessArguments, model.Target) &&
(ch.HasEditableValue || ch.Field.IsAvailableForTarget(model.Target));
//if not "HasValues" types, will be empty
ValueList = ch.GetDropdownValues().Select(v => new FieldPossibleValueViewModel(v)).ToArray();
PossibleValueList = ch.GetPossibleValues().Select(v => new FieldPossibleValueViewModel(v)).ToList();
ProjectFieldId = ch.Field.ProjectFieldId;
FieldBound = (FieldBoundToViewModel)ch.Field.FieldBoundTo;
MandatoryStatus = IsDeleted ? MandatoryStatusViewType.Optional : (MandatoryStatusViewType)ch.Field.MandatoryStatus;
ProjectId = ch.Field.ProjectId;
}
public string GenerateDefaultValue(FieldWithValue field)
{
string newValue;
switch (field.Field.FieldBoundTo)
{
case FieldBoundTo.Character:
newValue = Generator.CreateDefaultValue(Character, field.Field);
break;
case FieldBoundTo.Claim:
newValue = Generator.CreateDefaultValue(Claim, field.Field);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(newValue);
}
public void PublicCharactersFieldValueOnAddClaimAreReadonlyIfNotShowForUnApprovedClaims()
{
var field = Mock.CreateField(new ProjectField()
{
IsPublic = true, CanPlayerEdit = true, ShowOnUnApprovedClaims = false
});
var value = new FieldWithValue(field, "xxx");
Mock.Character.JsonData = new[] { value }.SerializeFields();
var vm = new CustomFieldsViewModel(Mock.Player.UserId, (IClaimSource)Mock.Character);
var characterField = vm.Field(field);
characterField.ShouldNotBeNull();
characterField.ShouldBeVisible();
characterField.Value.ShouldBe("xxx");
characterField.ShouldBeReadonly();
}
public void MasterHiddenChangeTest()
{
_original = new MockedProject();
_generator = new MockedFieldDefaultValueGenerator();
var mock = new MockedProject();
var publicField = new FieldWithValue(mock.PublicField, "Public");
MockedProject.AssignFieldValues(mock.Character, publicField);
FieldSaveHelper.SaveCharacterFields(
mock.Master.UserId,
mock.Character,
new Dictionary <int, string>()
{
{ mock.HideForUnApprovedClaim.ProjectFieldId, "test" },
{ mock.CharacterField.ProjectFieldId, null },
},
_generator);
mock.Character.FieldValuesShouldBe(new FieldWithValue(mock.HideForUnApprovedClaim, "test"), publicField);
}
