Pre release v3.0.0 beta.4

src/UDS.Net.Data/DataAnnotations/CurrentYearRangeAttribute.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace UDS.Net.Data.DataAnnotations
+{
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
+    public class CurrentYearRangeAttribute : ValidationAttribute
+    {
+        private string PropertyName { get; set; }
+        private int YearMin;
+        private int YearMax;
+        private int YearUnknown;
+
+        /// <summary>
+        /// Property when condition asserts true.
+        /// </summary>
+        /// <param name="propertyName"></param>
+        /// <param name="assertion"></param>
+        public CurrentYearRangeAttribute(string propertyName, int yearMin, int yearUnknown)
+        {
+            PropertyName = propertyName;
+            YearMin = yearMin;
+            YearMax = DateTime.Now.Year;
+            YearUnknown = yearUnknown;
+        }
+
+        public CurrentYearRangeAttribute(string ErrorMessage)
+        {
+            this.ErrorMessage = ErrorMessage;
+        }
+
+        protected override ValidationResult IsValid(object propertyValue, ValidationContext propertyToValidate)
+        {
+            var instance = propertyToValidate.ObjectInstance;
+            var instanceType = instance.GetType();
+            if(propertyValue is null)
+            {
+                return ValidationResult.Success;
+            }
+
+            int? value = (int)propertyValue;
+
+
+            var formStatus = instanceType.GetProperty("FormStatus");
+            if (formStatus != null)
+            {
+                var formStatusValue = formStatus.GetValue(instance, null);
+                if (formStatusValue.ToString() != "Complete")
+                {
+                    return ValidationResult.Success;
+                }
+            }
+
+            if (value >= 0)
+            {
+                if(value >= YearMin && value <= YearMax) return ValidationResult.Success;
+
+                if(value == YearUnknown) return ValidationResult.Success;
+
+            } else {
+                //the value was null, but the a3 form must allow null valid date inputs
+                return ValidationResult.Success;
+            }
+
+            //Year was not matched with conditions and is not valid
+            return new ValidationResult(ErrorMessage);
+        }
+    }
+}
+

src/UDS.Net.Data/DataAnnotations/InvalidRangeAttribute.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace UDS.Net.Data.DataAnnotations
+{
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
+    public class InvalidRangeAttribute : ValidationAttribute
+    {
+        private string PropertyName { get; set; }
+        private int InvalidRangeMin;
+        private int InvalidRangeMax;
+
+        /// <summary>
+        /// Property when condition asserts true.
+        /// </summary>
+        /// <param name="propertyName"></param>
+        /// <param name="assertion"></param>
+        public InvalidRangeAttribute(string propertyName, int invalidRangeMin, int invalidRangeMax, string errorMessage = "")
+        {
+            PropertyName = propertyName;
+            InvalidRangeMax = invalidRangeMax;
+            InvalidRangeMin = invalidRangeMin;
+        }
+
+        public InvalidRangeAttribute(string ErrorMessage)
+        {
+            this.ErrorMessage = ErrorMessage;
+        }
+
+        protected override ValidationResult IsValid(object value, ValidationContext context)
+        {
+            var instance = context.ObjectInstance;
+            var type = instance.GetType();
+
+            var propertyValue = type.GetProperty(PropertyName).GetValue(instance);
+
+            var formStatus = type.GetProperty("FormStatus");
+            if (formStatus != null)
+            {
+                var formStatusValue = formStatus.GetValue(instance, null);
+                if (formStatusValue.ToString() != "Complete")
+                {
+                    return ValidationResult.Success; // if the annotation is on a form and it is not being completed, don't run validation
+                }
+            }
+
+            var invalidMinValue = InvalidRangeMin;
+            var invalidMaxValue = InvalidRangeMax;
+
+            if (propertyValue != null) // we're allowing nulls in some cases, so the watched property won't always have a value
+            {
+                while (invalidMinValue <= invalidMaxValue)
+                {
+                    if (propertyValue.ToString() == invalidMinValue.ToString() || value == null)
+                    {
+                        return new ValidationResult(ErrorMessage);
+                    }
+
+                    invalidMinValue++;
+                }
+            }
+
+            return ValidationResult.Success;
+        }
+    }
+}
+

src/UDS.Net.Data/DataAnnotations/RequiredIfAttribute.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace UDS.Net.Data.DataAnnotations
+{
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
+    public class RequiredIfAttribute : ValidationAttribute
+    {
+        private string PropertyName { get; set; }
+        private object AssertionValue { get; set; }
+
+        /// <summary>
+        /// Property when condition asserts true.
+        /// </summary>
+        /// <param name="propertyName"></param>
+        /// <param name="assertion"></param>
+        public RequiredIfAttribute(string propertyName, object assertion, string errorMessage = "")
+        {
+            PropertyName = propertyName;
+            AssertionValue = assertion;
+            ErrorMessage = errorMessage;
+        }
+
+        public RequiredIfAttribute(string ErrorMessage)
+        {
+            this.ErrorMessage = ErrorMessage;
+        }
+
+        protected override ValidationResult IsValid(object value, ValidationContext context)
+        {
+            var instance = context.ObjectInstance;
+            var type = instance.GetType();
+
+            var propertyValue = type.GetProperty(PropertyName).GetValue(instance, null);
+
+            var formStatus = type.GetProperty("FormStatus");
+            if (formStatus != null)
+            {
+                var formStatusValue = formStatus.GetValue(instance, null);
+                if (formStatusValue.ToString() != "Complete")
+                {
+                    return ValidationResult.Success; // if the annotation is on a form and it is not being completed, don't run validation
+                }
+            }
+
+            if (propertyValue != null) // we're allowing nulls in some cases, so the watched property won't always have a value
+            {
+                if (propertyValue.ToString() == AssertionValue.ToString() && value == null)
+                {
+                    return new ValidationResult(ErrorMessage);
+                }
+            }
+
+            return ValidationResult.Success;
+        }
+
+    }
+}
+

src/UDS.Net.Data/DataAnnotations/RequiredIfImpairedAttribute.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace UDS.Net.Data.DataAnnotations
+{
+    /// <summary>
+    /// This annotation was made specifically for handling special cases in
+    /// ClinicianDiagnosis.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
+    public class RequiredIfImpairedAttribute : ValidationAttribute
+    {
+        private string PropertyName { get; set; }
+        private object AssertionValue { get; set; }
+
+        /// <summary>
+        /// Property when condition asserts true.
+        /// </summary>
+        /// <param name="propertyName"></param>
+        /// <param name="assertion"></param>
+        public RequiredIfImpairedAttribute(string propertyName, object assertion, string errorMessage = "")
+        {
+            PropertyName = propertyName;
+            AssertionValue = assertion;
+            ErrorMessage = errorMessage;
+        }
+
+        public RequiredIfImpairedAttribute(string ErrorMessage)
+        {
+            this.ErrorMessage = ErrorMessage;
+        }
+
+        protected override ValidationResult IsValid(object value, ValidationContext context)
+        {
+            var instance = context.ObjectInstance;
+            var type = instance.GetType();
+
+            var propertyValue = type.GetProperty(PropertyName).GetValue(instance, null);
+
+            var formStatus = type.GetProperty("FormStatus");
+            var hasNormalCognition = type.GetProperty("HasNormalCognition");
+            if (formStatus != null && hasNormalCognition != null)
+            {
+                var formStatusValue = formStatus.GetValue(instance, null);
+                var hasNormalCognitionValue = hasNormalCognition.GetValue(instance, null);
+                if (formStatusValue.ToString() != "Complete")
+                {
+                    return ValidationResult.Success; // if the annotation is on a form and it is not being completed, don't run validation
+                }
+                else
+                {
+                    // form status is complete
+                    string test = hasNormalCognitionValue.ToString();
+                    if (hasNormalCognitionValue.ToString() == "True")
+                    {
+                        // cognition is normal (not impaired), so don't require
+                        return ValidationResult.Success;
+                    }
+                }
+            }
+
+            if (propertyValue != null) // we're allowing nulls in some cases, so the watched property won't always have a value
+            {
+                if (propertyValue.ToString() == AssertionValue.ToString() && value == null)
+                {
+                    return new ValidationResult(ErrorMessage);
+                }
+            }
+
+            return ValidationResult.Success;
+        }
+
+    }
+}
+
+

src/UDS.Net.Data/DataAnnotations/RequiredIfRangeAttribute.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+
+namespace UDS.Net.Data.DataAnnotations
+{
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
+    public class RequiredIfRangeAttribute : ValidationAttribute
+    {
+        private string PropertyName { get; set; }
+        private int StartAssertionValue;
+        private int EndAssertionValue;
+
+        /// <summary>
+        /// Property when condition asserts true.
+        /// </summary>
+        /// <param name="propertyName"></param>
+        /// <param name="assertion"></param>
+        public RequiredIfRangeAttribute(string propertyName, int startAssertionValue, int endAssertionValue, string errorMessage = "")
+        {
+            PropertyName = propertyName;
+            StartAssertionValue = startAssertionValue;
+            EndAssertionValue = endAssertionValue;
+            ErrorMessage = errorMessage;
+        }
+
+        public RequiredIfRangeAttribute(string ErrorMessage)
+        {
+            this.ErrorMessage = ErrorMessage;
+        }
+
+        protected override ValidationResult IsValid(object value, ValidationContext context)
+        {
+            var instance = context.ObjectInstance;
+            var type = instance.GetType();
+
+            var propertyValue = type.GetProperty(PropertyName).GetValue(instance, null);
+
+            var formStatus = type.GetProperty("FormStatus");
+            if (formStatus != null)
+            {
+                var formStatusValue = formStatus.GetValue(instance, null);
+                if (formStatusValue.ToString() != "Complete")
+                {
+                    return ValidationResult.Success; // if the annotation is on a form and it is not being completed, don't run validation
+                }
+            }
+
+            var startValue = StartAssertionValue;
+            var endValue = EndAssertionValue;
+
+            if (propertyValue != null) // we're allowing nulls in some cases, so the watched property won't always have a value
+            {
+                while (startValue <= endValue)
+                {
+                    if (propertyValue.ToString() == startValue.ToString() && value == null)
+                    {
+                        return new ValidationResult(ErrorMessage);
+                    }
+
+                    startValue++;
+                }
+            }
+
+            return ValidationResult.Success;
+        }
+
+    }
+}
+

src/UDS.Net.Data/Dtos/PreviousValueDto.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace UDS.Net.Data.Dtos
+{
+    public class PreviousValueDto
+    {
+        public string Name { get; set; }
+        public string Text { get; set; }
+    }
+}

src/UDS.Net.Data/Entities/A1_ParticipantDemographics.cs

@@ -1,7 +1,7 @@
 using System;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
-using COA.Components.Web.DataAnnotations;
+using UDS.Net.Data.DataAnnotations;
 using Microsoft.EntityFrameworkCore;
 using UDS.Net.Data.Enums;
 

src/UDS.Net.Data/Entities/A2_CoParticipantDemographics.cs

@@ -1,7 +1,7 @@
 using System;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
-using COA.Components.Web.DataAnnotations;
+using UDS.Net.Data.DataAnnotations;
 using Microsoft.EntityFrameworkCore;
 using UDS.Net.Data.Enums;