Saxonite/SaxoniteCoreWebOnline/Online/Models/SaxModel_Online.cs

using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Helpers;
using Sarand.Net.Standard.Base.Utils;
using Saxonite.Net.Core.Web.Base.App;
using Saxonite.Net.Core.Web.Base.Controllers;
using Saxonite.Net.Core.Web.Base.Models;
using Saxonite.Net.Core.Web.Online.App;
using Saxonite.Net.Standard.Base.App;
using Saxonite.Net.Standard.Base.Bus;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Threading.Tasks;

namespace Saxonite.Net.Core.Web.Online.Models
{
	//=======================================================================
	public class SaxModel_Online : SaxModel_Base
	{
		//-------------------------------------------------------------------
		// Data members.
		private bool? userCanManageOrganisationMembers = null;
		private bool? userCanManageOrganisationArticles = null;
		private bool? userCanManageOrganisationOpportunities = null;

		//-------------------------------------------------------------------
		// Protected construction.
		protected SaxModel_Online(SaxLocaliser localiser) :
			base(localiser)
		{
		}

		//-------------------------------------------------------------------
		// Session.
		//-------------------------------------------------------------------
		public SaxSessionData_Online SessionData_Online { get { return SessionData as SaxSessionData_Online; } }
		// Menu options.
		public bool MembersAllowed { get { return UserCanManageOrganisationMembers; } }
		public bool ArticlesAllowed { get { return UserIsJournalist || UserCanManageOrganisationArticles; } }
		public bool OpportunitiesAllowed { get { return UserCanManageOrganisationOpportunities; } }
		// Security profile.
		public bool UserIsJournalist { get { return SessionData != null && SessionData.User != null && SessionData.User.IsJournalist; } }
		public bool UserCanManageOrganisationMembers
		{
			get
			{
				if (userCanManageOrganisationMembers  == null && ValidUserSession)
				{
					SaxUserOrganisation.Params prmUserOrganisation = new SaxUserOrganisation.Params();
					prmUserOrganisation.UserAccountIdsIncluded.Add(SessionData.User.UserAccountId);
					prmUserOrganisation.OrganisationMembersOnly = true;
					prmUserOrganisation.OrganisationRoles.Add(Sax.OrganisationRole.OpportunityAdmin);
					prmUserOrganisation.StatusCat = SaxUserOrganisation.StatusCat.ActiveOnly;
					userCanManageOrganisationMembers = (AccountMgr.GetUserOrganisationCount(prmUserOrganisation) > 0);
				}
				return userCanManageOrganisationMembers == true ? true : false;
			}
		}
		public bool UserCanManageOrganisationArticles
		{
			get
			{
				if (userCanManageOrganisationArticles == null && ValidUserSession)
				{
					SaxUserOrganisation.Params prmUserOrganisation = new SaxUserOrganisation.Params();
					prmUserOrganisation.UserAccountIdsIncluded.Add(SessionData.User.UserAccountId);
					prmUserOrganisation.OrganisationMembersOnly = true;
					prmUserOrganisation.OrganisationRoles.Add(Sax.OrganisationRole.ArticleAdmin);
					prmUserOrganisation.StatusCat = SaxUserOrganisation.StatusCat.ActiveOnly;
					userCanManageOrganisationArticles = (AccountMgr.GetUserOrganisationCount(prmUserOrganisation) > 0);
				}
				return userCanManageOrganisationArticles == true ? true : false;
			}
		}
		public bool UserCanManageOrganisationOpportunities
		{
			get
			{
				if (userCanManageOrganisationOpportunities == null && ValidUserSession)
				{
					SaxUserOrganisation.Params prmUserOrganisation = new SaxUserOrganisation.Params();
					prmUserOrganisation.UserAccountIdsIncluded.Add(SessionData.User.UserAccountId);
					prmUserOrganisation.OrganisationMembersOnly = true;
					prmUserOrganisation.OrganisationRoles.Add(Sax.OrganisationRole.OpportunityAdmin);
					prmUserOrganisation.StatusCat = SaxUserOrganisation.StatusCat.ActiveOnly;
					userCanManageOrganisationOpportunities = (AccountMgr.GetUserOrganisationCount(prmUserOrganisation) > 0);
				}
				return userCanManageOrganisationOpportunities == true ? true : false;
			}
		}

		//-------------------------------------------------------------------
		// Item Id Obfuscation.
		//-------------------------------------------------------------------
		public SysId ExtractSysId(String idx)
		{
			String fn = GetType().Name + ".ExtractSysId";
			if (StringUtil.IsEmpty(idx)) return null;

			// Numeric values are assumed to be unencrypted Ids.
			if (StringUtil.IsNumeric(idx))
				return idx.ToSysId();

			try
			{
				// Attempt to decrypt.
				SysId id = DecryptId(idx);
				if (SysId.IsValid(id))
					return id;
			}
			catch (Exception exc)
			{
				SaLogger.Warn(fn + " " + ExceptionUtil.GetErrorStateMessage(exc));
			}

			return null;
		}

		//-------------------------------------------------------------------
		// Id encryption.
		// To obfuscate Id values that are sent to and from the browser.
		// NB IV value can be reset evert time the application restarts.
		public static String Base64Key_IdObfuscation = SacsEncryptionHelper.EncodePlainKey("|SaxOnIte.Onl1n3-iD+0bfuscAtion|", SacsEncryptionHelper.KeyLength);
		public static String Base64IV_IdObfuscation = SacsEncryptionHelper.InitSymmetricEncryptionIV(Base64Key_IdObfuscation);
		public static String ParamName_IdObfuscation_Id { get; } = "iob";
		public String EncryptId(SysId id)
		{
			NameValueCollection idObfuscationParams = new NameValueCollection();
			idObfuscationParams.Add(ParamName_IdObfuscation_Id, SysId.ToString(id));
			return SaxController_Base.EncryptParameters(idObfuscationParams, Base64IV_IdObfuscation, Base64Key_IdObfuscation);
		}
		public SysId DecryptId(String encryptedId)
		{
			if (StringUtil.IsNumeric(encryptedId))
				return encryptedId.ToSysId();
			NameValueCollection idObfuscationParams = SaxController_Base.DecryptParameters(encryptedId, Base64IV_IdObfuscation, Base64Key_IdObfuscation);
			return idObfuscationParams.Get(ParamName_IdObfuscation_Id).ToSysId();
		}

		//-------------------------------------------------------------------
		// Reference Data.
		//-------------------------------------------------------------------
		// Regions.
		/// <summary>Region Data class - to be JSON serialised in Ajax responses.</summary>
		public class RegionData
		{
			public String Id { get; set; }
			public int RegionType { get; set; }
			public String RegionTypeCode { get; set; }
			public String RegionTypeDesc { get; set; }
			public String Name { get; set; }
			public String ParentId { get; set; }
			public String StatusCode { get; set; }
			public String StatusDesc { get; set; }
		}
		public List<RegionData> GetRegionDataList_Active()
		{
			List<RegionData> regions = new List<RegionData>();
			foreach (SaxRegion region in DataCacheConsole.GetActiveRegions())
			{
				RegionData regionData = new RegionData()
				{
					Id = SysId.ToString(region.Id),
					RegionType = (int)region.RegionType,
					RegionTypeCode = region.RegionType.ToString(),
					RegionTypeDesc = Localiser.GetRegionTypeCaption(region.RegionType),
					Name = GetRegionCaption(region),
					ParentId = SysId.ToString(region.RegionIdParent),
					StatusCode = region.StatusCode,
					StatusDesc = Localiser.GetStatusCaption(region.Status)
				};
				regions.Add(regionData);
			}
			return regions;
		}
		public String GetRegionCaption(SysId regionId)
		{
			SaxRegion region = DataCacheConsole.GetActiveRegions().Find(item => item.Id.Equals(regionId));
			return Localiser.GetRegionName(region);
		}
		public String GetRegionCaption(SaxRegion region)
		{
			return Localiser.GetRegionName(region);
		}

		//-------------------------------------------------------------------
		// Sports.
		public class SportData
		{
			public Int32 Id { get; set; }
			public String Name { get; set; }
			public String StatusCode { get; set; }
			public String StatusDesc { get; set; }
		}
		public List<SportData> GetSportDataList_Active()
		{
			List<SportData> sports = new List<SportData>();
			foreach (SaxSport sport in DataCacheConsole.GetActiveSports())
			{
				SportData sportData = new SportData()
				{
					Id = SysId.ToInt(sport.Id),
					Name = GetSportCaption(sport),
					StatusCode = sport.StatusCode,
					StatusDesc = Localiser.GetStatusCaption(sport.Status)
				};
				sports.Add(sportData);
			}
			return sports;
		}
		public String GetSportCaption(SysId sportId)
		{
			SaxSport sport = DataCacheConsole.GetActiveSports().Find(item => item.Id.Equals(sportId));
			return Localiser.GetSportName(sport);
		}
		public String GetSportCaption(SaxSport sport)
		{
			return Localiser.GetSportName(sport);
		}

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