Saxonite/Workspace/SaxoniteStandardBase/Base/Mgr/SaxAccountMgr-UserEligibility.cs

using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Dbas;
using Sarand.Net.Standard.Base.Utils;
using Saxonite.Base.App;
using Saxonite.Net.Standard.Base.App;
using Saxonite.Net.Standard.Base.Bus;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Saxonite.Net.Standard.Base.Mgr
{
	//=======================================================================
	partial class SaxAccountMgr
	{
		//*******************************************************************
		// Account Mgr - User Eligibility
		//*******************************************************************
		// Utilities.
		public bool UserRegionHasEligibility(SysId userAccountId, SysId regionId, DateTime validOn, SaxUserEligibility.StatusCat statusCat = SaxUserEligibility.StatusCat.ActiveOnly)
		{
			if (!SysId.IsValid(userAccountId) || !SysId.IsValid(regionId)) return false;
			SaxUserEligibility.Params prmEligibilityType = new SaxUserEligibility.Params();
			prmEligibilityType.UserAccountIdsIncluded.Add(userAccountId);
			prmEligibilityType.RegionIdsIncluded.Add(regionId);
			prmEligibilityType.ValidOn = validOn;
			prmEligibilityType.StatusCat = statusCat;
			return GetUserEligibilityCount(prmEligibilityType) > 0;
		}
		/// <summary>
		/// Retrievethe eligibility entries for the specified user.
		/// <para>- Optional region can be supplied to restrict results.</para>
		/// <para>- Optional valid on date can be supplied to restrict results.</para>
		/// <para>- Eligibility status defaults to active.</para>
		/// </summary>
		/// <param name="userAccountId">User account</param>
		/// <param name="regionId"></param>
		/// <param name="statusCat"></param>
		/// <returns></returns>
		public List<SaxUserEligibility> GetUserEligibility(SysId userAccountId, SysId regionId = null, DateTime? validOn = null, SaxUserEligibility.StatusCat statusCat = SaxUserEligibility.StatusCat.ActiveOnly)
		{
			if (!SysId.IsValid(userAccountId)) return new List<SaxUserEligibility>();
			SaxUserEligibility.Params prmEligibilityType = new SaxUserEligibility.Params();
			prmEligibilityType.UserAccountIdsIncluded.Add(userAccountId);
			if (SysId.IsValid(regionId))
				prmEligibilityType.RegionIdsIncluded.Add(regionId);
			if (DateUtil.IsValid(validOn))
				prmEligibilityType.ValidOn = (DateTime)validOn;
			prmEligibilityType.StatusCat = statusCat;
			return GetUserEligibilityList(prmEligibilityType);
		}

		//-------------------------------------------------------------------
		// Create item.
		public abstract SaxUserEligibility CreateUserEligibility(SysId userAccountId, SysId regionId, Sax.EligibilityType userEligibility);

		//-------------------------------------------------------------------
		// Item exists.
		public bool UserEligibilityExistsById(SysId id)
		{
			ClearErrorState();
			if (!SysId.IsValid(id)) return false;
			SaxUserEligibility.Params prmEligibilityType = new SaxUserEligibility.Params();
			prmEligibilityType.IdsIncluded.Add(id);
			prmEligibilityType.StatusCat = SaxUserEligibility.StatusCat.Any;
			return GetUserEligibilityCount(prmEligibilityType) == 1;
		}

		//-------------------------------------------------------------------
		// Retrieve individual items.
		public abstract SaxUserEligibility GetUserEligibility(SaxUserEligibility.Params prmEligibilityType);
		public SaxUserEligibility GetUserEligibilityById(SysId id)
		{
			ClearErrorState();
			if (!SysId.IsValid(id)) return null;
			SaxUserEligibility.Params prmEligibilityType = new SaxUserEligibility.Params();
			prmEligibilityType.IdsIncluded.Add(id);
			prmEligibilityType.StatusCat = SaxUserEligibility.StatusCat.Any;
			return GetUserEligibility(prmEligibilityType);
		}

		//-------------------------------------------------------------------
		// Validate item data.
		public bool IsValidUserEligibility(SaxUserEligibility userEligibility)
		{
			ClearErrorState();
			if (userEligibility == null) return SetErrorState(ErrorMessage.ItemNotSpecified);
			return IsValidUserEligibilityData(userEligibility.GetData(), new SaxUserEligibility.ErrField());
		}
		public virtual bool IsValidUserEligibilityData(SaxUserEligibility.Data data, SaxUserEligibility.ErrField errField)
		{
			ClearErrorState();

			// User Account.
			if (errField.UserAccountId != SacsHierarchyItem.ValidValue.Ignore && !SysId.IsValid(data.UserAccountId))
			{
				errField.UserAccountId = SacsHierarchyItem.ValidValue.Invalid;
				return SetErrorState("User Account Id must be specified");
			}

			// Region.
			if (errField.RegionId != SacsHierarchyItem.ValidValue.Ignore && !SysId.IsValid(data.RegionId))
			{
				errField.RegionId = SacsHierarchyItem.ValidValue.Invalid;
				return SetErrorState("Region Id must be specified");
			}

			// Eligibility Type.
			if (errField.EligibilityType != SacsHierarchyItem.ValidValue.Ignore && (int)data.EligibilityType < 1)
			{
				errField.EligibilityType = SacsHierarchyItem.ValidValue.Invalid;
				return SetErrorState("User Eligibility must be specified");
			}

			// Info.
			if (errField.Info != SacsHierarchyItem.ValidValue.Ignore && !IsValidValue(data.Info, "info", (long)SaxDbDfn_Core.GetColTextLen(SaxDbDfn_Core.ColumnIdx.UserEligibility_Info)))
			{
				errField.Info = SacsHierarchyItem.ValidValue.Invalid;
				return false;
			}

			// Expires on.
			if (errField.ExpiresOn != SacsHierarchyItem.ValidValue.Ignore)
			{
			}

			//---------------------------------------------------------------
			// Common properties.
			if (errField.Notes != SacsHierarchyItem.ValidValue.Ignore && !IsValidValue(data.Notes, "notes", (long)SaxDbDfn_Core.GetColTextLen(SaxDbDfn_Core.ColumnIdx.UserEligibility_Notes)))
			{
				errField.Notes = SacsHierarchyItem.ValidValue.Invalid;
				return false;
			}
			if (errField.Status != SacsHierarchyItem.ValidValue.Ignore)
			{
				if (!IsValidValue(data.StatusCode, "status", (long)SaxDbDfn_Core.GetColTextLen(SaxDbDfn_Core.ColumnIdx.UserEligibility_Status), true, true))
				{
					errField.Status = SacsHierarchyItem.ValidValue.Invalid;
					return false;
				}
				if (!SaxUserEligibility.ValidStatuses.Contains(data.Status))
				{
					errField.Status = SacsHierarchyItem.ValidValue.Invalid;
					return SetErrorState(ErrorMessage.InvalidStatus);
				}
			}

			//---------------------------------------------------------------
			// User & Eligibility combination must be unique.
			if (errField.UserAccountId != SacsHierarchyItem.ValidValue.Ignore && errField.RegionId != SacsHierarchyItem.ValidValue.Ignore && errField.EligibilityType != SacsHierarchyItem.ValidValue.Ignore)
			{
				if (SysId.IsValid(data.UserAccountId) && SysId.IsValid(data.RegionId) && data.EligibilityType > 0)
				{
					SaxUserEligibility.Params prmEligibilityType = new SaxUserEligibility.Params();
					if (SysId.IsValid(data.Id))
						prmEligibilityType.IdsExcluded.Add(data.Id);
					prmEligibilityType.UserAccountIdsIncluded.Add(data.UserAccountId);
					prmEligibilityType.RegionIdsIncluded.Add(data.RegionId);
					prmEligibilityType.EligibilityTypesIncluded.Add(data.EligibilityType);
					prmEligibilityType.StatusCat = SaxUserEligibility.StatusCat.Any;
					if (GetUserEligibilityCount(prmEligibilityType) > 0)
					{
						errField.EligibilityType = SacsHierarchyItem.ValidValue.Invalid;
						return SetErrorState("Eligibility must be unique for user, region and type");
					}
				}
			}

			//---------------------------------------------------------------
			return true;
		}

		//-------------------------------------------------------------------
		// Item database interface.
		public abstract bool InsertUserEligibility(SaxUserEligibility userEligibility, DbUpdateInfo dbUpdateInfo);
		public abstract bool UpdateUserEligibility(SaxUserEligibility userEligibility, DbUpdateInfo dbUpdateInfo);
		public virtual bool UserEligibilityCanBeDeleted(SaxUserEligibility userEligibility)
		{
			ClearErrorState();
			return true;
		}
		public abstract bool DeleteUserEligibility(SaxUserEligibility userEligibility, DbUpdateInfo dbUpdateInfo);

		//-------------------------------------------------------------------
		// Item list.
		public abstract ColumnDfn GetUserEligibilityColumnDfn(SaxUserEligibility.Column columnId, String caption = "", int width = 0);
		public abstract List<String> GetUserEligibilityQueryFilter(SaxUserEligibility.Params prmEligibilityType);
		public abstract long GetUserEligibilityCount(SaxUserEligibility.Params prmEligibilityType);
		public abstract List<SaxUserEligibility> GetUserEligibilityList(SaxUserEligibility.Params prmEligibilityType);
		public abstract DbResultSet ExecuteUserEligibilityQuery(List<ColumnDfn> columns, SaxUserEligibility.Params prmEligibilityType);

		//-------------------------------------------------------------------
		/// <summary>
		/// Extract and format result set data value where specific handling is required.
		/// <para>Where response is an invalid data value, format value using column.FormatValue(values).</para>
		/// </summary>
		public virtual DataValue GetUserEligibilityDataValue(ColumnDfn column, NamedValue.Map values)
		{
			DataValue value = new DataValue();
			switch ((SaxUserEligibility.Column)column.Id)
			{
				//-----------------------------------------------------------
				// Eligibility Type.
				case SaxUserEligibility.Column.EligibilityType_Desc:
					{
						Sax.EligibilityType eligibilityType = (Sax.EligibilityType)values.GetValue(column.DataName).AsLong();
						value = new DataValue(EligibilityTypeCodes.GetDescForType(eligibilityType));
					}
					break;

				//-----------------------------------------------------------
				// Region Type.
				case SaxUserEligibility.Column.Region_Type_Desc:
					{
						Sax.RegionType regionType = (Sax.RegionType)values.GetValue(column.DataName).AsLong();
						value = new DataValue(RegionTypeCodes.GetDescForType(regionType));
					}
					break;

				//-----------------------------------------------------------
				// Notes.
				case SaxUserEligibility.Column.Notes:
					{
						value = new DataValue(SacsHierarchyItem.FormatForDisplay(values.GetValue(column.DataName).ToString(), 200));
					}
					break;

				//-----------------------------------------------------------
				// Status.
				case SaxUserEligibility.Column.Status_Desc:
				case SaxUserEligibility.Column.Status_Ind:
					{
						String statusCode = values.GetValue(column.DataName).ToString();
						SaStatus status = SacsSystem.GetStatusForCode(statusCode);
						if (column.Id == (int)SaxUserEligibility.Column.Status_Desc)
							value = new DataValue(SacsSystem.GetStatusDesc(status));
						else if (column.Id == (int)SaxUserEligibility.Column.Status_Ind)
							value = new DataValue(SaxUserEligibility.GetStatusTriState(status));
					}
					break;

				//-----------------------------------------------------------
				default:
					value = values.GetValue(column.DataName);
					break;

			}
			return value;
		}

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