Saxonite/SaxoniteCoreWebAdmin/Admin/Models/Model_User.cs

using Microsoft.AspNetCore.Mvc.Rendering;
using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Helpers;
using Sarand.Net.Standard.Base.Utils;
using Saxonite.Base.App;
using Saxonite.Net.Core.Web.Base.App;
using Saxonite.Net.Core.Web.Base.Controllers;
using Saxonite.Net.Core.Web.Base.Models;
using Saxonite.Net.Standard.Base.App;
using Saxonite.Net.Standard.Base.Bus;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;

namespace Saxonite.Net.Core.Web.Admin.Models
{
	//=======================================================================
	public class Model_User : SaxModel_Admin
	{
		//-------------------------------------------------------------------
		// Construction.
		public Model_User(SaxLocaliser localiser) :
			base(localiser)
		{
			AdditionalFiles_JS.Add("js/sax-user.js");
		}

		//-------------------------------------------------------------------
		// User filter properties.
		public class FilterData
		{
			public String User { get; set; }
			public String UserSportId { get; set; }
			public String UserRegionId { get; set; }
			public String UserStatusCategoryCode { get; set; }
		}
		public FilterData Filter { get; } = new FilterData();
		public SaxUserAccount.StatusCat FilterUserStatusCategory
		{
			get { return EnumUtil.ParseEnum(Filter.UserStatusCategoryCode, SaxUserAccount.StatusCat.Any); }
		}
		/// <summary>User Status Categories for filter.</summary>
		public IEnumerable<SelectListItem> UserFilterStatusCategoriesForSelect
		{
			get
			{
				List<CodeDesc> statusCategories = new List<CodeDesc>();
				statusCategories.Add(SaxUserAccount.StatusCat.Any.ToString(), Localiser["label.any"]);
				statusCategories.Add(SaxUserAccount.StatusCat.AwaitingOnly.ToString(), "Awaiting");
				statusCategories.Add(SaxUserAccount.StatusCat.ActiveOnly.ToString(), "Active");
				statusCategories.Add(SaxUserAccount.StatusCat.InactiveOnly.ToString(), "Inactive");
				statusCategories.Add(SaxUserAccount.StatusCat.NotDeleted.ToString(), "Not deleted");
				statusCategories.Add(SaxUserAccount.StatusCat.DeletedOnly.ToString(), "Deleted");
				return new SelectList(statusCategories, "Code", "Desc", SaxUserAccount.StatusCat.Any.ToString());
			}
		}

		//-------------------------------------------------------------------
		// User properties.
		public String UserAccountId { get; set; }
		[EmailAddress]
		public String UserEmailAddress { get; set; }
		public String UserTitle { get; set; }
		public String UserFirstName { get; set; }
		public String UserLastName { get; set; }
		public String UserRegionIdCountry { get; set; }
		public String UserRegionIdProvince { get; set; }
		public String UserRoleCodeDelim = ",";
		public new List<String> UserRoleCodes { get; set; }
		public List<String> GetUserRoleCodes()
		{
			List<String> codes = new List<string>();
			foreach (String code in UserRoleCodes)
			{
				if (StringUtil.IsEmpty(code)) continue;
				codes.AddRange(code.Split(UserRoleCodeDelim));
			}
			return codes;
		}
		public String UserStatusCode { get; set; }
		public SaStatus UserStatus { get { return SacsSystem.GetStatusForCode(UserStatusCode); } }
		// User emails.
		public String UserEmailAcountActivationOnline { get; set; }
		public String UserEmailRequestPasswordOnline { get; set; }
		public String UserEmailRequestPasswordAdmin { get; set; }

		//-------------------------------------------------------------------
		// Validation.
		//-------------------------------------------------------------------
		// User.
		public bool ValidateUserData(SaxController_Base.AjaxResponse_Data responseData)
		{
			String fn = GetType().Name + ".ValidateUserData";

			// Record disposable items as they are created so all can be disposed when needed.
			using (DisposableCollection<SacsHierarchyItem> disposableItems = new DisposableCollection<SacsHierarchyItem>())
			{

				// User email.
				if (UserEmailAddress != null)
				{
					UserEmailAddress = UserEmailAddress.ToLowerInvariant();
					responseData.SetControlValue(nameof(UserEmailAddress), UserEmailAddress);
					if (StringUtil.IsEmpty(UserEmailAddress))
						responseData.SetControlError(nameof(UserEmailAddress), Localiser["msg.validation.mandatory.value"]);
					else if (StringUtil.GetLength(UserEmailAddress) > GetControlMaxLength(SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress))
						responseData.SetControlError(nameof(UserEmailAddress), Localiser["msg.validation.maximum.length", GetControlMaxLength(SaxDbDfn_Core.ColumnIdx.UserAccount_EmailAddress)]);
					else if (!SacsDataValidationHelper.IsValidEmailAddress(UserEmailAddress))
						responseData.SetControlError(nameof(UserEmailAddress), Localiser["msg.validation.invalid.value"]);
					else
					{
						// Check for duplicate email address.
						SaxUserAccount.Params prmUserAccount = new SaxUserAccount.Params();
						SysId userAccountId = UserAccountId.ToSysId();
						if (SysId.IsValid(userAccountId))
							prmUserAccount.IdsExcluded.Add(userAccountId);
						prmUserAccount.EmailAddress = UserEmailAddress;
						prmUserAccount.StatusCat = SaxUserAccount.StatusCat.Any;
						if (AccountMgr.GetUserAccountCount(prmUserAccount) > 0)
							responseData.SetControlError(nameof(UserEmailAddress), Localiser["msg.validation.duplicate.value"]);
					}
				}

				// User title.
				if (UserTitle != null)
				{
				}

				// User first name.
				if (UserFirstName != null)
				{
					responseData.SetControlValue(nameof(UserFirstName), UserFirstName);
					if (StringUtil.IsEmpty(UserFirstName))
						responseData.SetControlError(nameof(UserFirstName), Localiser["msg.validation.mandatory.value"]);
					else if (StringUtil.GetLength(UserFirstName) > GetControlMaxLength(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName))
						responseData.SetControlError(nameof(UserFirstName), Localiser["msg.validation.maximum.length", GetControlMaxLength(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName)]);
				}

				// User last name.
				if (UserLastName != null)
				{
					responseData.SetControlValue(nameof(UserLastName), UserLastName);
					if (StringUtil.IsEmpty(UserLastName))
						responseData.SetControlError(nameof(UserLastName), Localiser["msg.validation.mandatory.value"]);
					else if (StringUtil.GetLength(UserLastName) > GetControlMaxLength(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName))
						responseData.SetControlError(nameof(UserLastName), Localiser["msg.validation.maximum.length", GetControlMaxLength(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName)]);
				}

				// Country region.
				SaxRegion regionCountry = null;
				if (UserRegionIdCountry != null)
				{
					if (!SysId.IsValid(UserRegionIdCountry.ToSysId()))
						responseData.SetControlError(nameof(UserRegionIdCountry), Localiser["msg.validation.mandatory.value"]);
					else
					{
						regionCountry = ReferenceMgr.GetRegionById(UserRegionIdCountry.ToSysId());
						disposableItems.Add(regionCountry);
						if (regionCountry != null)
						{
							if (regionCountry.RegionType != Sax.RegionType.Country)
							{
								SaLogger.Warn(fn + " Invalid region type. Expected: Country. Found: " + regionCountry.RegionType.ToString());
								responseData.SetControlError(nameof(UserRegionIdCountry), Localiser["msg.validation.invalid.value"]);
							}
						}
						else
						{
							SaLogger.Warn(fn + " Failed to retrieve region for Id: " + UserRegionIdCountry);
							responseData.SetControlError(nameof(UserRegionIdCountry), Localiser["msg.validation.invalid.value"]);
						}
					}
				}

				// Province region.
				SaxRegion regionProvince = null;
				if (UserRegionIdProvince != null)
				{
					if (!UserRegionIdProvince.IsEmpty())
					{
						regionProvince = ReferenceMgr.GetRegionById(UserRegionIdProvince.ToSysId());
						disposableItems.Add(regionProvince);
						if (regionProvince != null)
						{
							if (regionProvince.RegionType != Sax.RegionType.Province)
							{
								SaLogger.Warn(fn + " Invalid region type. Expected: Province . Found: " + regionCountry.RegionType.ToString());
								responseData.SetControlError(nameof(UserRegionIdProvince), Localiser["msg.validation.invalid.value"]);
							}
							else if (regionCountry != null && !regionProvince.RegionIdParent.Equals(regionCountry.Id))
							{
								SaLogger.Warn(fn + " Invalid province region parent. Expected: " + regionCountry.Id.ToString() + " . Found: " + regionCountry.RegionIdParent.ToString());
								responseData.SetControlError(nameof(UserRegionIdProvince), Localiser["msg.validation.invalid.value"]);
							}
						}
						else
						{
							SaLogger.Warn(fn + " Failed to retrieve region for Id: " + UserRegionIdProvince);
							responseData.SetControlError(nameof(UserRegionIdProvince), Localiser["msg.validation.invalid.value"]);
						}
					}
				}

				// User status.
				if (UserStatusCode != null)
				{
					if (StringUtil.IsEmpty(UserStatusCode))
						responseData.SetControlError(nameof(UserStatus), Localiser["msg.validation.mandatory.value"]);
					else if (!SaxUserAccount.ValidStatuses.Contains(UserStatus))
						responseData.SetControlError(nameof(UserStatus), Localiser["msg.validation.invalid.value"]);
				}

			}

			return !responseData.HasControlErrors();
		}

		//-------------------------------------------------------------------
	}
	//=======================================================================
}