Saxonite/SaxoniteCoreWebOnline/Online/Controllers/AccountController-Ajax-UserSportExperience.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 Saxonite.Net.Standard.Base.App;
using Microsoft.AspNetCore.Http;
using Sarand.Net.Standard.Base.Helpers;
using System.IO;
using System.Drawing;
using Sarand.Net.Standard.Base.Core;
using Sarand.Net.Standard.Base.Dbas;

namespace Saxonite.Net.Core.Web.Online.Controllers
{
	//=======================================================================
	// Online Account Controller - User Sport Experience - Ajax actions.
	//=======================================================================
	partial class AccountController
	{
		//-------------------------------------------------------------------
		// Common response data.
		private class SportExperienceResponseData_List : AjaxResponse_Data.ItemData_Base
		{
			public String UserSportId { get; set; }
			public String Period { get; set; }
			public String PeriodFrom { get; set; }
			public String PeriodTo { get; set; }
			public String OrganisationName { get; set; }
			public String Summary { get; set; }
			public String Team { get; set; }
			public String League { get; set; }
			public String Speciality { get; set; }
			// Regions.
			public String RegionCaptionNation { get; set; }
			public String RegionCaptionProvince { get; set; }
			public string RegionRepresentation { get; set; }
		}
		private class SportExperienceResponseData_Detail : SportExperienceResponseData_List
		{
			public String PeriodFrom_YMD { get; set; }
			public String PeriodTo_YMD { get; set; }
			public String OrganisationId { get; set; }
			public String RegionIdNation { get; set; }
			public String RegionIdProvince { get; set; }
		}
		private void PopulateSportExperienceResponseData(Model_UserSportExperience model, SportExperienceResponseData_Detail data, SaxUserSport userSport, SaxUserSportExperience userSportExperience)
		{
			data.Id = model.EncryptId(userSportExperience.Id);
			data.UserSportId = model.EncryptId(userSportExperience.UserSportId);
			data.PeriodFrom_YMD = DateUtil.FormatDateForJavascript(userSportExperience.PeriodFrom);
			data.PeriodFrom = model.FormatDateForForm(userSportExperience.PeriodFrom);
			data.PeriodTo_YMD = DateUtil.FormatDateForJavascript(userSportExperience.PeriodTo);
			data.PeriodTo = model.FormatDateForForm(userSportExperience.PeriodTo);
			data.Period = data.PeriodFrom + " - " + data.PeriodTo;
			data.OrganisationId = model.EncryptId(userSportExperience.OrganisationId);
			data.OrganisationName = userSportExperience.OrganisationName;
			data.Summary = userSportExperience.Summary;
			data.Team = userSportExperience.Team;
			data.League = userSportExperience.League;
			data.Speciality = userSportExperience.Speciality;
			// Regions.
			data.RegionIdNation = model.GetEncryptedRegionId(userSportExperience.RegionIdNation);
			data.RegionIdProvince = model.GetEncryptedRegionId(userSportExperience.RegionIdProvince);
			data.RegionCaptionNation = Localiser.GetRegionName(Internals.GetRegion(userSportExperience.RegionIdNation));
			data.RegionCaptionProvince = Localiser.GetRegionName(Internals.GetRegion(userSportExperience.RegionIdProvince));
			List<String> locations = new List<string>() { data.RegionCaptionProvince, data.RegionCaptionNation };
			data.RegionRepresentation = locations.Concat(", ", "", "", true, true);
		}

		//-------------------------------------------------------------------
		// Utilites.

		//-------------------------------------------------------------------
		// User Sport - Get Experience list.
		//-------------------------------------------------------------------
		private class AjaxResponse_UserSportExperienceList : AjaxResponse_Data
		{
			// Construction.
			public AjaxResponse_UserSportExperienceList(SaxModel_Online model) : base(model) { }
			// Contact details.
			public List<SportExperienceResponseData_List> Experiences { get; } = new List<SportExperienceResponseData_List>();
			// Sport details.
			public class SportData
			{
				public class SpecialityData
				{
					public bool? NotRelevant { get; set; } = null;
					public String Label { get; set; }
				}
				public SpecialityData Speciality { get; } = new SpecialityData();
			}
			public SportData Sport { get; } = new SportData();
		}
		// Ajax request.
		[HttpPost]
		[Route("UserSport/Ajax/GetExperienceList")]
		public IActionResult GetUserSportExperienceList(Model_UserSportExperience model)
		{
			String fn = GetType().Name + ".GetUserSportExperienceList";
			AjaxResponse_UserSportExperienceList responseData = new AjaxResponse_UserSportExperienceList(model);
			String messageTitle = Localiser["account.caption.profile.sports"];

			// 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 User Sport Id against user account.
				SysId userSportId = model.ExtractSysId(model.UserSportId);
				SaxUserSport userSport = AccountMgr.GetUserSportById(userSportId);
				disposableItems.Add(userSport);
				if (userSport == null || !userSport.UserAccountId.Equals(UserAccountId))
					return Json(responseData.SetGoHome(messageTitle, Localiser["msg.something.gone.wrong"]));

				// Sport details.
				if (model.SportSpecialityNotRelevant(userSport.SportId)) responseData.Sport.Speciality.NotRelevant = true;
				responseData.Sport.Speciality.Label = model.GetSportSpecialityLabel(userSport.SportId);

				// Columns.
				ColumnDfn colId = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.Id);
				ColumnDfn colUserSportId = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.UserSportId);
				ColumnDfn colPeriodFrom = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.PeriodFrom);
				ColumnDfn colPeriodTo = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.PeriodTo);
				ColumnDfn colOrganisationId = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.OrganisationId);
				ColumnDfn colOrganisationName = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.Organisation_Name);
				ColumnDfn colSummary = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.Summary);
				ColumnDfn colTeam = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.Team);
				ColumnDfn colLeague = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.League);
				ColumnDfn colSpeciality = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.Speciality);
				ColumnDfn colNotes = AccountMgr.GetUserSportExperienceColumnDfn(SaxUserSportExperience.Column.Notes);
				List<ColumnDfn> columnsToQuery = new List<ColumnDfn>()
				{
					colId, colUserSportId, colPeriodFrom, colPeriodTo,
					colOrganisationId, colOrganisationName,
					colSummary, colTeam, colLeague, colSpeciality, colNotes
				};

				// Filter.
				SaxUserSportExperience.Params prmUserSportExperience = new SaxUserSportExperience.Params();
				prmUserSportExperience.UserSportIdsIncluded.Add(model.ExtractSysId(model.UserSportId));
				prmUserSportExperience.StatusCat = SaxUserSportExperience.StatusCat.NotDeleted;

				// Sort columns.
				colPeriodFrom.SortAscending = false;
				prmUserSportExperience.SortColumns.Add(colPeriodFrom);

				// Query items.
				using (DbResultSet resultSet = AccountMgr.ExecuteUserSportExperienceQuery(columnsToQuery, prmUserSportExperience))
				{
					while (resultSet != null && resultSet.HasRows && resultSet.NextRecord())
					{
						NamedValue.Map values = resultSet.GetRecordValues();
						SportExperienceResponseData_List itemData = new SportExperienceResponseData_List()
						{
							Id = model.EncryptId(new SysId(values.GetLong(colId.DataName))),
							UserSportId = model.EncryptId(new SysId(values.GetLong(colUserSportId.DataName))),
							PeriodFrom = model.FormatDateForForm(values.GetDate(colPeriodFrom.DataName)),
							PeriodTo = model.FormatDateForForm(values.GetDate(colPeriodTo.DataName)),
							OrganisationName = AccountMgr.GetUserSportExperienceDataValue(colOrganisationName, values).AsString(),
							Summary = values.GetString(colSummary.DataName),
							Team = values.GetString(colTeam.DataName),
							League = values.GetString(colLeague.DataName),
							Speciality = values.GetString(colSpeciality.DataName),
						};
						itemData.Period = itemData.PeriodFrom + " - " + itemData.PeriodTo;
						responseData.Experiences.Add(itemData);
					}
				}
			}

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

		//-------------------------------------------------------------------
		// User Sport - Get Experience.
		//-------------------------------------------------------------------
		private class AjaxResponse_UserSportExperienceData : AjaxResponse_Data
		{
			// Construction.
			public AjaxResponse_UserSportExperienceData(SaxModel_Online model) : base(model) { }
			// Contact details.
			public SportExperienceResponseData_Detail Experience { get; set; }
		}
		// Ajax request.
		[HttpPost]
		[Route("UserSport/Ajax/GetExperience")]
		public IActionResult GetUserSportExperience(Model_UserSportExperience model)
		{
			String fn = GetType().Name + ".GetUserSportExperience";
			AjaxResponse_UserSportExperienceData responseData = new AjaxResponse_UserSportExperienceData(model);
			String messageTitle = Localiser["account.caption.profile.sports"];

			// 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 User Sport Experience Id against user account.
				SysId userSportExperienceId = model.ExtractSysId(model.UserSportExperienceId);
				SaxUserSportExperience userSportExperience = AccountMgr.GetUserSportExperienceById(userSportExperienceId);
				disposableItems.Add(userSportExperience);
				SaxUserSport userSport = AccountMgr.GetUserSportById(userSportExperience?.UserSportId ?? null);
				disposableItems.Add(userSport);
				if (userSportExperience == null || userSport == null || !userSport.UserAccountId.Equals(UserAccountId))
					return Json(responseData.SetGoHome(messageTitle, Localiser["msg.something.gone.wrong"]));

				// Populate data to response.
				responseData.Experience = new SportExperienceResponseData_Detail();
				PopulateSportExperienceResponseData(model, responseData.Experience, userSport, userSportExperience);
			}

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

		//-------------------------------------------------------------------
		// Account - Store User Sport Experience.
		//-------------------------------------------------------------------
		private class AjaxResponse_StoreUserSportExperience : AjaxResponse_Data
		{
			// Construction.
			public AjaxResponse_StoreUserSportExperience(SaxModel_Online model) : base(model) { }
			// Contact details.
			public SportExperienceResponseData_Detail Experience { get; set; }
		}
		// Ajax request.
		[HttpPost]
		[Route("UserSport/Ajax/StoreExperience")]
		public IActionResult StoreUserSportExperience(Model_UserSportExperience model)
		{
			String fn = GetType().Name + ".StoreUserSportExperience";
			AjaxResponse_StoreUserSportExperience responseData = new AjaxResponse_StoreUserSportExperience(model);
			String messageTitle = Localiser["account.caption.profile.sports"];

			// 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 data.
				model.ValidateProfileSportData(responseData);
				if (responseData.HasControlErrors())
					return Json(responseData);

				// Validate User Sport Experience Id.
				SysId userSportExperienceId = model.ExtractSysId(model.UserSportExperienceId);
				if (SysId.IsValid(userSportExperienceId) != StringUtil.ToBool(model.UserSportExperienceExists))
					return Json(responseData.SetGoHome(messageTitle, Localiser["msg.something.gone.wrong"]));

				// Retrieve User Sport Experience.
				SaxUserSportExperience userSportExperience = null;
				SaxUserSport userSport = null;
				if (SysId.IsValid(userSportExperienceId))
				{
					userSportExperience = AccountMgr.GetUserSportExperienceById(userSportExperienceId);
					disposableItems.Add(userSportExperience);
					userSport = AccountMgr.GetUserSportById(userSportExperience?.UserSportId ?? null);
					disposableItems.Add(userSport);
					if (userSportExperience == null || userSport == null || !userSport.UserAccountId.Equals(UserAccountId))
						return Json(responseData.SetGoHome(messageTitle, Localiser["msg.something.gone.wrong"]));
				}
				else
				{
					// Creating new User Sport Experience.
					// Retrieve User Sport and validate.
					SysId userSportId = model.ExtractSysId(model.UserSportId);
					userSport = AccountMgr.GetUserSportById(userSportId);
					disposableItems.Add(userSport);
					if (userSport == null || !userSport.UserAccountId.Equals(UserAccountId))
						return Json(responseData.SetGoHome(messageTitle, Localiser["msg.something.gone.wrong"]));
					// Create User Sport Experience.
					userSportExperience = AccountMgr.CreateUserSportExperience(userSport.Id);
					disposableItems.Add(userSportExperience);
				}

				// Populate properties.
				userSportExperience.Changed = false;
				if (model.ExperiencePeriodFrom != null)
					userSportExperience.PeriodFrom = model.ParseDateFromForm(model.ExperiencePeriodFrom);
				if (model.ExperiencePeriodTo != null)
					userSportExperience.PeriodTo = model.ParseDateFromForm(model.ExperiencePeriodTo);
				if (model.ExperienceOrganisationId != null)
					userSportExperience.OrganisationId = model.ExtractSysId(model.ExperienceOrganisationId);
				if (model.ExperienceOrganisationName != null)
					userSportExperience.OrganisationName = model.ExperienceOrganisationName;
				if (model.ExperienceSummary != null)
					userSportExperience.Summary = model.ExperienceSummary;
				if (model.ExperienceTeam != null)
					userSportExperience.Team = model.ExperienceTeam;
				if (model.ExperienceLeague != null)
					userSportExperience.League = model.ExperienceLeague;
				if (model.ExperienceSpeciality != null)
					userSportExperience.Speciality = model.ExperienceSpeciality;
				// Regions.
				if (model.ExperienceRegionIdNation != null)
					userSportExperience.RegionIdNation = model.ExtractSysId(model.ExperienceRegionIdNation);
				if (model.ExperienceRegionIdProvince != null)
					userSportExperience.RegionIdProvince = model.ExtractSysId(model.ExperienceRegionIdProvince);

				// Store Experience.
				if (!SysId.IsValid(userSportExperience.Id))
				{
					if (AccountMgr.InsertUserSportExperience(userSportExperience, DbUpdateInfo))
					{
						responseData.SetNotification(messageTitle, Localiser["msg.item.created"]);
					}
					else
					{
						SaLogger.Warn(fn + " Failed to insert user sport experience: " + AccountMgr.ErrorStateMessage);
						return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.insert.failed"]));
					}
				}
				else
				{
					if (AccountMgr.UpdateUserSportExperience(userSportExperience, DbUpdateInfo))
					{
						responseData.SetNotification(messageTitle, Localiser["msg.item.updated"]);
					}
					else
					{
						SaLogger.Warn(fn + " Failed to update user sport experience: " + AccountMgr.ErrorStateMessage);
						return Json(responseData.SetMessage(messageTitle, Localiser["msg.error.item.update.failed"]));
					}
				}

				// Populate data to response.
				responseData.Experience = new SportExperienceResponseData_Detail();
				PopulateSportExperienceResponseData(model, responseData.Experience, userSport, userSportExperience);
			}

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

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