Saxonite/SaxoniteStandardBase/Base/App/SaxSessionData.cs

using Newtonsoft.Json;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Dbas;
using Saxonite.Net.Standard.Base.Bus;
using Saxonite.Net.Standard.Base.App;
using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using Sarand.Net.Standard.Base.Utils;
using Newtonsoft.Json.Converters;
using Sarand.Net.Standard.Base.Helpers;

namespace Saxonite.Net.Standard.Base.App
{
	//=======================================================================
	public abstract class SaxSessionData
	{
		//-------------------------------------------------------------------
		private static long sessionIdxRoot = SacsRandomHelper.GetInt32(1000, 1999);

		//-------------------------------------------------------------------
		// Construction.
		/// <summary>Protected constructor for deserialisation only.</summary>
		protected SaxSessionData(long sessionIdx, int itemIdx, SaxSessionContext sessionContext)
		{
			SessionIdx = sessionIdx;
			ItemIdx = itemIdx;
			SessionContext = sessionContext;
			userData = CreateUserData(SessionContext, null, null);
		}
		/// <summary>
		/// Primary constructor - on user login.
		/// <para>SessionContext and UserAccount must be supplied.</para>
		/// <para>Roles list is optional.</para>
		/// </summary>
		protected SaxSessionData(SaxSessionContext sessionContext, SaxUserAccount userAccount, List<SaxUserRole> userRoles)
		{
			SessionIdx = ++sessionIdxRoot;
			ItemIdx = 1000;
			SessionContext = sessionContext;
			userData = CreateUserData(SessionContext, userAccount, userRoles);
		}

		//-------------------------------------------------------------------
		// Properties.
		// Session and Item indexers.
		public long SessionIdx { get; }
		public int ItemIdx { get; private set; }
		[JsonIgnore]
		public int NextItemIdx { get { return ++ItemIdx; } }
		// Session context.
		public SaxSessionContext SessionContext { get; }
		[JsonIgnore]
		public bool ValidUserSession { get { return SysId.IsValid(User.UserAccountId) && SysId.IsValid(User.UserAccountId); } }
		[JsonIgnore]
		public DbUpdateInfo DbUpdateInfo
		{
			get
			{
				return new DbUpdateInfo(User.UserAccountId, StringUtil.OnEmpty(User.DisplayName, User.EmailAddress), SaxSystem.ComputerName);
			}
		}

		//-------------------------------------------------------------------
		// User.
		public class UserData
		{
			protected UserData() { }
			protected UserData(SaxSessionContext sessionContext, SaxUserAccount userAccount, List<SaxUserRole> userRoles)
			{
				if (userAccount != null)
				{
					UserAccountId = userAccount.Id;
					RefreshUserData(userAccount);
					if (sessionContext.Application == Sax.Application.Admin)
						KeepLoggedIn = userAccount.KeepLoggedIn_Admin;
					else if (sessionContext.Application == Sax.Application.Online)
						KeepLoggedIn = userAccount.KeepLoggedIn_Online;
					else Debugger.Break();

					if (userRoles != null)
					{
						foreach (SaxUserRole userRole in userRoles.FindAll(item => item.IsStatusActive))
							roles.Add(new RoleData(userRole));
					}
				}
			}
			protected UserData(UserData userData)
			{
				UserAccountId = userData.UserAccountId;
				Title = userData.Title;
				FirstName = userData.FirstName;
				LastName = userData.LastName;
				DisplayName = userData.DisplayName;
				EmailAddress = userData.EmailAddress;
				RegionIdCountry = userData.RegionIdCountry;
				RegionIdProvince = userData.RegionIdProvince;
				KeepLoggedIn = userData.KeepLoggedIn;
				roles.AddRange(userData.Roles);
			}
			// Properties.
			public SysId UserAccountId { get; protected set; }
			public String Title { get; protected set; }
			public String FirstName { get; protected set; }
			public String LastName { get; protected set; }
			public String DisplayName { get; protected set; }
			public String EmailAddress { get; protected set; }
			public SysId RegionIdCountry { get; protected set; }
			public SysId RegionIdProvince { get; protected set; }
			public bool KeepLoggedIn { get; protected set; }
			public bool UserAccountSupplied { get; protected set; }
			// Refresh properties.
			protected bool RefreshUserData(SaxUserAccount userAccount)
			{
				// Check that user matches the session.
				if (!SysId.IsValid(UserAccountId) || !SysId.IsValid(userAccount?.Id ?? null) || !UserAccountId.Equals(userAccount.Id)) return false;
				// Refresh properties.
				Title = userAccount.Title;
				FirstName = userAccount.FirstName;
				LastName = userAccount.LastName;
				DisplayName = userAccount.GetDisplayName();
				EmailAddress = userAccount.EmailAddress;
				RegionIdCountry = userAccount.RegionIdCountry;
				RegionIdProvince = userAccount.RegionIdProvince;
				return true;
			}
			// Roles.
			public class RoleData
			{
				public RoleData(SaxUserRole userRole)
				{
					if (userRole != null)
					{
						Role = userRole.UserRole;
						Status = userRole.Status;
					}
				}
				public Sax.UserRole Role { get; protected set; }
				public SaStatus Status { get; protected set; }
			}
			private readonly List<RoleData> roles = new List<RoleData>();
			public List<RoleData> Roles { get { return new List<RoleData>(roles); } protected set { roles.Clear(); roles.AddRange(value); } }
			[JsonIgnore]
			public bool IsJournalist { get { return roles?.Exists(item => item.Role == Sax.UserRole.Journalist) ?? false; } }
		}
		protected abstract UserData CreateUserData(SaxSessionContext sessionContext, SaxUserAccount userAccount, List<SaxUserRole> userRoles);
		private UserData userData;
		public UserData User { get { return userData; } }
		/// <summary>User - JSON deserialisation route.</summary>
		protected void SetUser(UserData user)
		{
			if (this.userData != null && User.UserAccountSupplied)
				throw new NotSupportedException("Session User cannot be replaced.");
			this.userData = user;
		}

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