Saxonite/SaxoniteCoreWebOnline/Online/Controllers/AccountController-Ajax-Sports.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Saxonite.Net.Core.Web.Online.Models;
using Saxonite.Net.Core.Web.Base.App;
using Saxonite.Net.Core.Web.Base.Controllers;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using Saxonite.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.App;
using Sarand.Net.Standard.Base.Bus;
using Sarand.Net.Standard.Base.Utils;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Dbas;
using Saxonite.Net.Standard.Base.App;
using static Saxonite.Net.Standard.Base.App.Sax.Config;
using static Saxonite.Net.Standard.Base.Bus.SaxArticle;

namespace Saxonite.Net.Core.Web.Online.Controllers
{
	//=======================================================================
	// Online Account Controller - Sports - Ajax actions.
	//=======================================================================
	partial class AccountController
	{
		//-------------------------------------------------------------------
		// Data definitions.
		private class ProfileSportResponseListData : AjaxResponse_Data.ItemData_Base
		{
			public String SportId { get; set; }
			public String SportName { get; set; }
			public String SportSpecialityLabel { get; set; }
			public String SportParticipating { get; set; }
			public String SportPreparing { get; set; }
			public String SportOfficiating { get; set; }
		}
		private class ProfileSportResponseItemData : ProfileSportResponseListData
		{
			public String SportAbout { get; set; }
			public List<SportContactData> Contacts { get; set; }
			public String SportParticipatingCode { get; set; }
			public String SportPreparingCode { get; set; }
			public String SportOfficiatingCode { get; set; }
		}
		public class SportContactData
		{
			public String ContactType { get; set; }
			public String ContactTypeDesc { get; set; }
			public String Title { get; set; }
			public String FirstName { get; set; }
			public String LastName { get; set; }
			public String EmailAddress { get; set; }
			public String Phone { get; set; }
		}
		private void PopulateProfileSportResponseListData(Model_Account model, SaxUserSport userSport, SaxSport sport, ProfileSportResponseListData data)
		{
			data.Id = model.EncryptId(userSport.Id);
			data.SportId = model.GetEncryptedSportId(userSport.SportId);
			data.SportName = sport.Name;
			data.SportSpecialityLabel = model.GetSportSpecialityLabel(userSport.SportId);
			data.SportParticipating = Localiser.GetSportParticipatingCaption(userSport.Participating);
			data.SportPreparing = Localiser.GetSportPreparingCaption(userSport.Preparing);
			data.SportOfficiating = Localiser.GetSportOfficiatingCaption(userSport.Officiating);
		}
		private void PopulateProfileSportResponseItemData(Model_Account model, SaxUserSport userSport, SaxSport sport, ProfileSportResponseItemData data)
		{
			PopulateProfileSportResponseListData(model, userSport, sport, data);
			data.SportAbout = userSport.About;
			// Sport Contacts.
			SaxSportContactsData sportContacts = new SaxSportContactsData(userSport.ContactsData);
			foreach (Sax.SportContactType contactType in sportContacts.ContactTypes)
			{
				if (data.Contacts == null) data.Contacts = new List<SportContactData>();
				SportContactData sportContact =
				new SportContactData()
				{
					ContactType = SportContactTypeCodes.GetCodeForType(contactType),
					ContactTypeDesc = Localiser.GetSportContactTypeCaption(contactType),
					Title = sportContacts.GetContactTitle(contactType),
					FirstName = sportContacts.GetContactFirstName(contactType),
					LastName = sportContacts.GetContactLastName(contactType),
					EmailAddress = sportContacts.GetContactEmailAddress(contactType),
					Phone = sportContacts.GetContactPhone(contactType),
				};
				data.Contacts.Add(sportContact);
			}
			data.SportParticipatingCode = SportParticipatingCodes.GetCodeForType(userSport.Participating);
			data.SportPreparingCode = SportPreparingCodes.GetCodeForType(userSport.Preparing);
			data.SportOfficiatingCode = SportOfficiatingCodes.GetCodeForType(userSport.Officiating);
			data.CreatedOnFmt = model.FormatDateForDisplay(userSport.CreateStamp.On);
			data.StatusCode = userSport.StatusCode;
			data.StatusDesc = userSport.StatusDesc;
		}

		//-------------------------------------------------------------------
		// Account - Get Profile Sports.
		//-------------------------------------------------------------------
		private class AjaxResponse_ProfileSportsData : AjaxResponse_Data
		{
			// Construction.
			public AjaxResponse_ProfileSportsData(SaxModel_Online model) : base(model) { }
			// Reference data.
			public List<ItemCodeDesc> ContactTypes { get; } = new List<ItemCodeDesc>();
			public List<ItemCodeDesc> Titles { get; } = new List<ItemCodeDesc>();
			// Sport list.
			public List<ProfileSportResponseListData> Sports { get; } = new List<ProfileSportResponseListData>();
		}
		// Ajax request.
		[HttpPost]
		[Route("Account/Ajax/GetProfileSports")]
		public IActionResult GetProfileSports(Model_Account model)
		{
			String fn = GetType().Name + ".GetProfileSports";
			AjaxResponse_ProfileSportsData responseData = new AjaxResponse_ProfileSportsData(model);
			String messageTitle = Localiser["account.caption.profile.sports"];

			// Validate session and referrer.
			if (!ValidReferer) return Forbid();
			if (!ValidUserSession) return GetAjaxResult_InvalidSession(responseData);
			RefreshModel(model);

			// Reference data - Contact types.
			List<Sax.SportContactType> validContactTypes = new List<Sax.SportContactType>(EnumUtil.GetValues<Sax.SportContactType>());
			foreach (TypeCodeDesc contactType in SportContactTypeCodes)
			{
				if (!validContactTypes.Contains((Sax.SportContactType)contactType.Type)) continue;
				responseData.ContactTypes.Add(new AjaxResponse_Data.ItemCodeDesc() { Code = contactType.Code, Desc = Localiser.GetSportContactTypeCaption((Sax.SportContactType)contactType.Type) });
			}

			// Reference data - Titles.
			foreach (var title in model.TitlesForSelect)
				responseData.Titles.Add(new AjaxResponse_Data.ItemCodeDesc() { Code = title.Value, Desc = title.Text });

			// Item filter.
			SaxUserSport.Params prmUserSport = new SaxUserSport.Params();
			prmUserSport.UserAccountIdsIncluded.Add(SessionUserAccountId);
			prmUserSport.StatusCat = SaxUserSport.StatusCat.NotDeleted;
			model.Paging.ItemTotal = (ulong)AccountMgr.GetUserSportCount(prmUserSport);
			model.PopulatePagingTo(prmUserSport.ResultsPaging);

			// Item columns.
			ColumnDfn colId = AccountMgr.GetUserSportColumnDfn(SaxUserSport.Column.Id);
			ColumnDfn colSportId = AccountMgr.GetUserSportColumnDfn(SaxUserSport.Column.SportId);
			ColumnDfn colSportName = AccountMgr.GetUserSportColumnDfn(SaxUserSport.Column.Sport_Name);
			ColumnDfn colParticipating = AccountMgr.GetUserSportColumnDfn(SaxUserSport.Column.SportParticipating);
			ColumnDfn colPreparing = AccountMgr.GetUserSportColumnDfn(SaxUserSport.Column.SportPreparing);
			ColumnDfn colOfficiating = AccountMgr.GetUserSportColumnDfn(SaxUserSport.Column.SportOfficiating);
			ColumnDfn colStatus = AccountMgr.GetUserSportColumnDfn(SaxUserSport.Column.Status);
			List<ColumnDfn> columns = new List<ColumnDfn>()
			{
				colId,
				colSportId, colSportName,
				colParticipating, colPreparing, colOfficiating,
				colStatus,
			};

			// Sort columns.
			prmUserSport.SortColumns.Add(colSportName);

			// Query items.
			using (DbResultSet resultSet = AccountMgr.ExecuteUserSportQuery(columns, prmUserSport))
			{
				while (resultSet != null && resultSet.HasRows && resultSet.NextRecord())
				{
					NamedValue.Map values = resultSet.GetRecordValues();
					SysId sportId = new SysId(values.GetLong(colSportId.DataName));
					ProfileSportResponseListData userSportData = new ProfileSportResponseListData()
					{
						Id = model.EncryptId(new SysId(values.GetLong(colId.DataName))),
						SportId = model.GetEncryptedSportId(sportId),
						SportName = values.GetString(colSportName.DataName),
						SportSpecialityLabel = model.GetSportSpecialityLabel(sportId),
						SportParticipating = Localiser.GetSportParticipatingCaption((Sax.SportParticipating)values.GetLong(colParticipating.DataName)),
						SportPreparing = Localiser.GetSportPreparingCaption((Sax.SportPreparing)values.GetLong(colPreparing.DataName)),
						SportOfficiating = Localiser.GetSportOfficiatingCaption((Sax.SportOfficiating)values.GetLong(colOfficiating.DataName)),
						StatusCode = values.GetString(colStatus.DataName),
						StatusDesc = SacsSystem.GetStatusDescForCode(values.GetString(colStatus.DataName))
					};
					responseData.Sports.Add(userSportData);
				}
			}
			if (model.Paging.IsPaged)
				model.Paging.ItemCount = (ushort)responseData.Sports.Count;

			// Complete response.
			responseData.SetPaging(model);
			responseData.Success = true;
			return Json(responseData);
		}

		//-------------------------------------------------------------------
		// Get Profile Sport ajax request.
		//-------------------------------------------------------------------
		private class AjaxResponse_ProfileSport : AjaxResponse_Data
		{
			// Construction.
			public AjaxResponse_ProfileSport(SaxModel_Online model) : base(model) { }
			// Sport details.
			public ProfileSportResponseItemData Sport { get; } = new ProfileSportResponseItemData();
		}
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("Account/Ajax/GetProfileSport")]
		public IActionResult Ajax_GetProfileSport(Model_Account model)
		{
			String fn = GetType().Name + ".Ajax_GetProfileSport";
			String messageTitle = Localiser["account.caption.profile.sport"];
			AjaxResponse_ProfileSport responseData = new AjaxResponse_ProfileSport(model);

			// Validate session and referrer.
			if (!ValidReferer) return Forbid();
			if (!ValidUserSession) return GetAjaxResult_InvalidSession(responseData);
			RefreshModel(model);

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

				// Identify item.
				SysId userSportId = model.ExtractSysId(model.UserSportId);
				if (!SysId.IsValid(userSportId))
					return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.id.not.specified"]));

				// Retrieve item.
				SaxUserSport userSport = AccountMgr.GetUserSportById(userSportId);
				disposableItems.Add(userSport);
				if (userSport == null)
				{
					SaLogger.Warn(fn + " Failed to retrieve User Sport for Id: '" + model.UserSportId + "'");
					return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.id.not.found"]));
				}

				// Retrieve sport.
				SaxSport sport = ReferenceMgr.GetSportById(userSport.SportId);
				disposableItems.Add(sport);
				if (sport == null)
				{
					SaLogger.Warn(fn + " Failed to retrieve Sport for Id: '" + userSport.SportId + "'");
					return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.id.not.found"]));
				}

				// Construct response.
				PopulateProfileSportResponseItemData(model, userSport, sport, responseData.Sport);
				responseData.Success = true;
			}
			return Json(responseData);
		}

		//-------------------------------------------------------------------
		// Validate Profile Sport Contact ajax request.
		//-------------------------------------------------------------------
		private class AjaxResponse_ProfileSportContact : AjaxResponse_Data
		{
			// Construction.
			public AjaxResponse_ProfileSportContact(SaxModel_Online model) : base(model) { }
		}
		[HttpPost]
		[Route("Account/Ajax/ValidateProfileSportContact")]
		public IActionResult Ajax_ValidateProfileSportContact(Model_UserSportContact model)
		{
			String fn = GetType().Name + ".Ajax_ValidateProfileSportContact";
			String messageTitle = Localiser["account.caption.profile.sport.contact"];
			AjaxResponse_ProfileSportContact responseData = new AjaxResponse_ProfileSportContact(model);

			// Validate session and referrer.
			if (!ValidReferer) return Forbid();
			if (!ValidUserSession) return GetAjaxResult_InvalidSession(responseData);
			RefreshModel(model);

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

				// Validate item properties.
				model.ValidateUserSportContactData(responseData);
				if (responseData.HasControlErrors())
					return Json(responseData);

				// Construct response.
				responseData.Success = true;
			}
			return Json(responseData);
		}

		//-------------------------------------------------------------------
		// Store Profile Sport ajax request.
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("Account/Ajax/StoreProfileSport")]
		public IActionResult Ajax_StoreProfileSport(Model_Account model)
		{
			String fn = GetType().Name + ".Ajax_StoreProfileSport";
			String messageTitle = Localiser["account.caption.profile.sport"];
			AjaxResponse_ProfileSport responseData = new AjaxResponse_ProfileSport(model);

			// Validate session and referrer.
			if (!ValidReferer) return Forbid();
			if (!ValidUserSession) return GetAjaxResult_InvalidSession(responseData);
			RefreshModel(model);

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

				// Validate item properties.
				model.ValidateProfileSportData(responseData);
				if (responseData.HasControlErrors())
					return Json(responseData);

				// Validate Profile Sport Id against 'Exists' flag.
				SysId userSportId = model.ExtractSysId(model.UserSportId);
				bool profileSportExists = StringUtil.ToBool(model.ProfileSportExists);
				if (profileSportExists && !SysId.IsValid(userSportId))
				{
					SaLogger.Warn(fn + " Id not specified for existing Profile Sport.");
					return Json(responseData.SetGoHome(messageTitle, Localiser["msg.error.system"]));
				}
				if (!profileSportExists && SysId.IsValid(userSportId))
				{
					SaLogger.Warn(fn + " Id specified for new Profile Sport: '" + model.UserSportId + "'");
					return Json(responseData.SetGoHome(messageTitle, Localiser["msg.error.system"]));
				}

				// Retrieve the sport.
				SysId sportId = model.ExtractSysId(model.ProfileSportId);
				SaxSport sport = ReferenceMgr.GetSportById(sportId);
				disposableItems.Add(sport);
				if (sport == null)
				{
					SaLogger.Warn(fn + " Failed to retrieve Sport for Id: " + sportId);
					return Json(responseData.SetGoHome(messageTitle, Localiser["msg.error.system"]));
				}

				// Retrieve existing item.
				SaxUserSport userSport = AccountMgr.GetUserSportById(userSportId);
				disposableItems.Add(userSport);
				if (userSport == null && SysId.IsValid(userSportId))
				{
					SaLogger.Warn(fn + " Failed to retrieve User Sport for Id: '" + model.UserSportId + "'");
					return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.id.not.found"]));
				}
				// Validate user sport properties.
				if (userSport != null)
				{
					if (!userSport.SportId.Equals(sportId))
					{
						SaLogger.Warn(fn + " Inconsistent Sport Id specified for User Sport. Expected: " + userSport.SportId + ". Found: " + sportId);
						return Json(responseData.SetGoHome(messageTitle, Localiser["msg.error.system"]));
					}
				}

				// If sport doesn't exist for the user, it may have been previously deleted.
				if (userSport == null)
				{
					SaxUserSport.Params prmUserSport = new SaxUserSport.Params();
					prmUserSport.UserAccountIdsIncluded.Add(SessionUserAccountId);
					prmUserSport.SportIdsIncluded.Add(sportId);
					prmUserSport.StatusCat = SaxUserSport.StatusCat.Any;
					userSport = AccountMgr.GetUserSport(prmUserSport);
					if (userSport != null)
					{
						disposableItems.Add(userSport);
						if (userSport.Status == SaStatus.Deleted)
						{
							SaLogger.Info(fn + " Resurrecting User Sport with status: " + userSport.StatusDesc + ". Id: " + SysId.ToString(userSport.Id));
							userSport.Status = SaxUserSport.DefaultStatus;
						}
						else
						{
							responseData.SetControlError(nameof(model.ProfileSportId), Localiser["msg.validation.duplicate.value"]);
							return Json(responseData);
						}
					}
					else
					{
						userSport = AccountMgr.CreateUserSport(SessionUserAccountId, sportId);
						disposableItems.Add(userSport);
					}
				}

				// Populate item properties.
				if (model.ProfileSportAbout != null)
					userSport.About = model.ProfileSportAbout;
				if (model.Contacts.ContactsData != null)
					userSport.ContactsData = model.Contacts.ContactsData.ToXml();
				if (model.ProfileSportParticipatingCode != null)
					userSport.Participating = model.ProfileSportParticipating;
				if (model.ProfileSportPreparingCode != null)
					userSport.Preparing = model.ProfileSportPreparing;
				if (model.ProfileSportOfficiatingCode != null)
					userSport.Officiating = model.ProfileSportOfficiating;

				// Store item.
				if (!SysId.IsValid(userSport.Id))
				{
					if (!AccountMgr.InsertUserSport(userSport, DbUpdateInfo))
					{
						SaLogger.Warn(fn + " Failed to insert user sport: " + AccountMgr.ErrorStateMessage);
						return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.insert.failed"]));
					}
				}
				else
				{
					if (!AccountMgr.UpdateUserSport(userSport, DbUpdateInfo))
					{
						SaLogger.Warn(fn + " Failed to update user sport [Id:" + SysId.ToString(userSport.Id) + "]: " + AccountMgr.ErrorStateMessage);
						return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.update.failed"]));
					}
				}

				// Refresh list of profile sports for Activity Index.
				RefreshSessionProfileSports();

				// Construct response.
				PopulateProfileSportResponseItemData(model, userSport, sport, responseData.Sport);
				responseData.Success = true;
			}
			return Json(responseData);
		}

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