ScriptTextParameterNode.cs

using System;
using System.Threading.Tasks;
using Waher.Content;
using Waher.Content.Text;
using Waher.Networking.XMPP.Concentrator;
using Waher.Networking.XMPP.DataForms;
using Waher.Networking.XMPP.DataForms.DataTypes;
using Waher.Networking.XMPP.DataForms.FieldTypes;
using Waher.Networking.XMPP.DataForms.Layout;
using Waher.Networking.XMPP.DataForms.ValidationMethods;
using Waher.Runtime.Language;
using Waher.Script;
using Waher.Things.Attributes;
 
namespace Waher.Things.Script.Parameters
{
    public class ScriptTextParameterNode : ScriptParameterNodeWithOptions
    {
        private string contentType;
 
        public ScriptTextParameterNode()
            : base()
        {
        }
 
        [Page(2, "Script", 100)]
        [Header(63, "Content-Type:")]
        [ToolTip(64, "Content-Type of text.")]
        [Required]
        public string ContentType
        {
            get => this.contentType;
            set
            {
                if (!string.IsNullOrEmpty(value) && (
                    !InternetContent.IsAccepted(value, InternetContent.CanDecodeContentTypes) ||
                    !InternetContent.IsAccepted(value, InternetContent.CanEncodeContentTypes)))
                {
                    throw new NotSupportedException("Content-Type not supported.");
                }
 
                this.contentType = value;
            }
        }
 
        [Page(2, "Script", 100)]
        [Header(29, "Default value:")]
        [ToolTip(30, "Default value presented to user.")]
        [DynamicContentType("GetContentType")]
        public string[] DefaultValue { get; set; }
 
        [Page(2, "Script", 100)]
        [Header(68, "Minimum Count:")]
        [ToolTip(69, "The smallest amount of items accepted.")]
        public ushort? MinCount { get; set; }
 
        [Page(2, "Script", 100)]
        [Header(70, "Maximum Count:")]
        [ToolTip(71, "The largest amount of items accepted.")]
        public ushort? MaxCount { get; set; }
 
        public string GetContentType()
        {
            return string.IsNullOrEmpty(this.contentType) ? PlainTextCodec.DefaultContentType : this.contentType;
        }
 
        public override Task<string> GetTypeNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ScriptNode), 65, "Text-valued parameter");
        }
 
        public override async Task PopulateForm(DataForm Parameters, Language Language, object Value)
        {
            ValidationMethod Validation = new BasicValidation();
            Field Field;
 
            if (this.MinCount.HasValue || this.MaxCount.HasValue)
                Validation = new ListRangeValidation(Validation, this.MinCount ?? 0, this.MaxCount ?? ushort.MaxValue);
 
            if (this.RestrictToOptions)
            {
                Field = new ListMultiField(Parameters, this.ParameterName, this.Label, this.Required,
                    this.DefaultValue, await this.GetOptions(), this.Description, StringDataType.Instance, Validation, string.Empty,
                    false, false, false);
            }
            else
            {
                Field = new TextMultiField(Parameters, this.ParameterName, this.Label, this.Required,
                    this.DefaultValue, await this.GetOptions(), this.Description, StringDataType.Instance, Validation, string.Empty,
                    false, false, false, this.GetContentType());
            }
 
            Parameters.Add(Field);
 
            Page Page = Parameters.GetPage(this.Page);
            Page.Add(Field);
        }
 
        public override async Task SetParameter(DataForm Parameters, Language Language, bool OnlySetChanged, Variables Values,
            SetEditableFormResult Result)
        {
            Field Field = Parameters[this.ParameterName];
            if (Field is null)
            {
                if (this.Required)
                    Result.AddError(this.ParameterName, await Language.GetStringAsync(typeof(ScriptNode), 42, "Required parameter."));
 
                Values[this.ParameterName] = null;
            }
            else
            {
                string[] s = Field.ValueStrings;
 
                if (s is null || s.Length == 0)
                {
                    if (this.Required)
                        Result.AddError(this.ParameterName, await Language.GetStringAsync(typeof(ScriptNode), 42, "Required parameter."));
 
                    Values[this.ParameterName] = null;
                }
                else
                {
                    Values[this.ParameterName] = s;
 
                    if (this.MinCount.HasValue && s.Length < this.MinCount.Value)
                        Result.AddError(this.ParameterName, await Language.GetStringAsync(typeof(ScriptNode), 72, "Too few rows."));
                    else if (this.MaxCount.HasValue && s.Length > this.MaxCount.Value)
                        Result.AddError(this.ParameterName, await Language.GetStringAsync(typeof(ScriptNode), 73, "Too many rows."));
                }
            }
        }
 
    }
}