Saxonite/Workspace/SaxoniteCoreWebAdmin/Admin/Controllers/UserController-Ajax.cs

using Microsoft.AspNetCore.Mvc;
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.Net.Core.Web.Admin.Models;
using Saxonite.Net.Standard.Base.App;
using Saxonite.Net.Standard.Base.Bus;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Saxonite.Net.Core.Web.Admin.Controllers
{
	//=======================================================================
	partial class UserController
	{
		//-------------------------------------------------------------------
		// User data.
		private class UserListData : AjaxResponse_Data.ItemData_Base
		{
			public String EmailAddress { get; set; }
			public String DisplayName { get; set; }
			public String Title { get; set; }
			public String FirstName { get; set; }
			public String LastName { get; set; }
			public String RegionNameCountry { get; set; }
			public String RegionNameProvince { get; set; }
			public int? UserSportCount { get; set; } = null;
			public int? UserRoleCount { get; set; } = null;
			public bool? SystemAdmin { get; set; } = null;
			public String LastOnlineLoginAt { get; set; }
			public String LastAdminLoginAt { get; set; }
		}
		private class UserItemData : UserListData
		{
			public String RegionIdCountry { get; set; }
			public String RegionIdProvince { get; set; }
			// User sports.
			public class UserSportData
			{
				public String SportId { get; set; }
				public String SportName { get; set; }
			}
			public List<UserSportData> Sports { get; set; }
			// User roles.
			public List<String> userRoleCodes { get; } = new List<string>();
		}
		private void PopulateUserResponseListData(SaxModel_Admin model, UserListData data, SaxUserAccount user, List<SaxUserSport> userSports, List<SaxUserRole> userRoles)
		{
			data.Id = SysId.ToString(user.Id);
			data.EmailAddress = user.EmailAddress;
			data.DisplayName = user.GetDisplayName();
			data.Title = user.Title;
			data.FirstName = user.FirstName;
			data.LastName = user.LastName;
			data.RegionNameCountry = model.GetRegionName(user.RegionIdCountry);
			data.RegionNameProvince = model.GetRegionName(user.RegionIdProvince);
			// User sports.
			// User roles.
			if (userRoles?.GetUserRolesByStatus(SaStatus.Active).Count > 0)
				data.UserRoleCount = userRoles.GetUserRolesByStatus(SaStatus.Active).Count;
			data.SystemAdmin = (userRoles != null && userRoles.Exists(item => item.UserRole == Sax.UserRole.SystemAdmin) ? true : (bool?)null);
			data.LastOnlineLoginAt = model.FormatDateTimeForDisplay(user.LastLoginAt);
			data.StatusCode = user.StatusCode;
			data.StatusDesc = user.StatusDesc;
			// System Admin role.
			SaxUserRole userRole_SystemAdmin = userRoles.Find(item => item.UserRole == Sax.UserRole.SystemAdmin);
			if (userRole_SystemAdmin != null)
				data.LastAdminLoginAt = model.FormatDateTimeForDisplay(userRole_SystemAdmin.LastLoginAt);
		}
		private void PopulateUserResponseItemData(SaxModel_Admin model, UserItemData data, SaxUserAccount user, List<SaxUserSport> userSports, List<SaxUserRole> userRoles)
		{
			PopulateUserResponseListData(model, data, user, userSports, userRoles);

			data.RegionIdCountry = SysId.ToString(user.RegionIdCountry);
			data.RegionIdProvince = SysId.ToString(user.RegionIdProvince);

			// User sports.
			if (userSports != null && !userSports.IsEmpty())
			{
				data.Sports = new List<UserItemData.UserSportData>();
				List<SaxSport> sports = ReferenceMgr.GetSportListByIds(userSports.GetSportIds());
				foreach (SaxUserSport userSport in userSports)
				{
					SaxSport sport = sports.GetSportById(userSport.SportId);
					UserItemData.UserSportData userSportData = new UserItemData.UserSportData()
					{
						SportId = SysId.ToString(userSport.SportId),
						SportName = sport?.Name ?? null
					};
					data.Sports.Add(userSportData);
				}
			}

			// User roles.
			if (userRoles != null)
			{
				foreach (SaxUserRole userRole in userRoles.GetUserRolesByStatus(SaStatus.Active))
					data.userRoleCodes.Add(UserRoleCodes.GetCodeForType(userRole.UserRole));
			}
		}

		//-------------------------------------------------------------------
		// Utilities.
		private List<SaxUserSport> GetUserSports(SysId userAccountId, SaxUserSport.StatusCat statusCat = SaxUserSport.StatusCat.NotDeleted)
		{
			if (!SysId.IsValid(userAccountId)) return new List<SaxUserSport>();
			SaxUserSport.Params prmUserSport = new SaxUserSport.Params();
			prmUserSport.UserAccountIdsIncluded.Add(userAccountId);
			prmUserSport.StatusCat = statusCat;
			return AccountMgr.GetUserSportList(prmUserSport);
		}
		private List<SaxUserRole> GetUserRoles(SysId userAccountId, SaxUserRole.StatusCat statusCat = SaxUserRole.StatusCat.NotDeleted)
		{
			if (!SysId.IsValid(userAccountId)) return new List<SaxUserRole>();
			SaxUserRole.Params prmUserRole = new SaxUserRole.Params();
			prmUserRole.UserAccountIdsIncluded.Add(userAccountId);
			prmUserRole.StatusCat = statusCat;
			return AccountMgr.GetUserRoleList(prmUserRole);
		}

		//-------------------------------------------------------------------
		// Get User List ajax request.
		//-------------------------------------------------------------------
		private class AjaxResponse_UserList : AjaxResponse_Data
		{
			// Construction.
			public AjaxResponse_UserList(SaxModel_Admin model) : base(model) { }
			// User list.
			public List<UserListData> Users { get; } = new List<UserListData>();
			// Reference data.
			public List<CodeDesc> UserRoles { get; } = new List<CodeDesc>();
			public List<CodeDesc> Statuses { get; } = new List<CodeDesc>();
			public String DefaultStatusCode { get; set; }
		}
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("User/Ajax/GetList")]
		[Route("User/Ajax/GetUsers")]
		[Route("User/Ajax/GetUserList")]
		public IActionResult Ajax_GetUserList(Model_User model)
		{
			String fn = GetType().Name + ".Ajax_GetUserList";
			String messageTitle = Localiser["user.caption.users"];
			AjaxResponse_UserList responseData = new AjaxResponse_UserList(model);

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

			// Reference data - user roles.
			foreach (TypeCodeDesc userRole in UserRoleCodes)
				responseData.UserRoles.Add(userRole.Code, Localiser.GetUserRoleCaption((Sax.UserRole)userRole.Type));
			responseData.DefaultStatusCode = SacsSystem.GetStatusCode(SaxUserAccount.DefaultStatus);

			// Reference data - statuses.
			foreach (SaStatus status in SaxUserAccount.ValidStatuses.FindAll(item => item != SaStatus.Deleted))
				responseData.Statuses.Add(SacsSystem.GetStatusCode(status), Localiser.GetStatusCaption(status));

			// Store filter values.
			SysId filterSportId = SysId.ToSysId(model.Filter.UserSportId);
			SessionData_Admin.Filter.SportId = SysId.IsValid(filterSportId) ? filterSportId : null;
			SysId filterRegionId = SysId.ToSysId(model.Filter.UserRegionId);
			SessionData_Admin.Filter.RegionId = SysId.IsValid(filterRegionId) ? filterRegionId : null;

			// Item filter.
			SaxUserAccount.Params prmUserAccount = new SaxUserAccount.Params();
			prmUserAccount.UserFilterPartial = model.Filter.User;
			prmUserAccount.SportIdsIncluded.AddId(SysId.ToSysId(model.Filter.UserSportId));
			prmUserAccount.RegionIdsIncluded.AddId(SysId.ToSysId(model.Filter.UserRegionId));
			prmUserAccount.StatusCat = model.Filter.UserStatusCategoryCode != null ? model.FilterUserStatusCategory : SaxUserAccount.StatusCat.NotDeleted;
			model.Paging.ItemTotal = (ulong)AccountMgr.GetUserAccountCount(prmUserAccount);
			model.PopulatePagingTo(prmUserAccount.ResultsPaging);

			// Item columns.
			ColumnDfn colId = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.Id);
			ColumnDfn colEmail = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.EmailAddress);
			ColumnDfn colTitle = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.Title);
			ColumnDfn colFirstName = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.FirstName);
			ColumnDfn colLastName = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.LastName);
			ColumnDfn colCountryName = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.RegionCountry_Name);
			ColumnDfn colProvinceName = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.RegionProvince_Name);
			ColumnDfn colUserRoleCount = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.UserRoleCount);
			ColumnDfn colSystemAdminUser = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.SystemAdminUser);
			ColumnDfn colUserSportCount = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.UserSportCount_Active);
			ColumnDfn colLastLogin = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.LastLoginAt);
			ColumnDfn colAdminLastLogin = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.LastAdminLoginAt);
			ColumnDfn colStatus = AccountMgr.GetUserAccountColumnDfn(SaxUserAccount.Column.Status);
			List<ColumnDfn> columns = new List<ColumnDfn>()
			{
				colId, colEmail, colTitle, colFirstName, colLastName,
				colCountryName, colProvinceName,
				colUserSportCount, colUserRoleCount,
				colSystemAdminUser, colLastLogin, colAdminLastLogin,
				colStatus
			};

			// Query items.
			using (DbResultSet resultSet = AccountMgr.ExecuteUserAccountQuery(columns, prmUserAccount))
			{
				while (resultSet != null && resultSet.HasRows && resultSet.NextRecord())
				{
					NamedValue.Map values = resultSet.GetRecordValues();
					UserListData userData = new UserListData()
					{
						Id = values.GetString(colId.DataName),
						EmailAddress = values.GetString(colEmail.DataName),
						Title = values.GetString(colTitle.DataName),
						FirstName = values.GetString(colFirstName.DataName),
						LastName = values.GetString(colLastName.DataName),
						RegionNameCountry = values.GetString(colCountryName.DataName),
						RegionNameProvince = values.GetString(colProvinceName.DataName),
						UserSportCount = StringUtil.ToInt(values.GetString(colUserSportCount.DataName)),
						UserRoleCount = StringUtil.ToInt(values.GetString(colUserRoleCount.DataName)),
						SystemAdmin = StringUtil.ToBool(values.GetString(colSystemAdminUser.DataName)),
						LastOnlineLoginAt = model.FormatDateTimeForDisplay(values.GetDateTime(colLastLogin.DataName)),
						LastAdminLoginAt = model.FormatDateTimeForDisplay(values.GetDateTime(colAdminLastLogin.DataName)),
						StatusCode = values.GetString(colStatus.DataName),
						StatusDesc = SacsSystem.GetStatusDescForCode(values.GetString(colStatus.DataName))
					};
					if (userData.UserSportCount < 1) userData.UserSportCount = null;
					if (userData.UserRoleCount < 1) userData.UserRoleCount = null;
					if (userData.SystemAdmin == false) userData.SystemAdmin = null;
					userData.DisplayName = SaxUserAccount.GetDisplayName(userData.Title, userData.FirstName, userData.LastName);
					responseData.Users.Add(userData);
				}
			}
			if (model.Paging.IsPaged)
				model.Paging.ItemCount = (ushort)responseData.Users.Count;

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

		//-------------------------------------------------------------------
		// Get User ajax request.
		//-------------------------------------------------------------------
		private class AjaxResponse_User : AjaxResponse_Data
		{
			// Construction.
			public AjaxResponse_User(SaxModel_Admin model) : base(model) { }
			// User details.
			public UserItemData user { get; } = new UserItemData();
		}
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("User/Ajax/GetItem")]
		[Route("User/Ajax/GetUser")]
		public IActionResult Ajax_GetUser(Model_User model)
		{
			String fn = GetType().Name + ".Ajax_GetUser";
			String messageTitle = Localiser["user.caption.user"];
			AjaxResponse_User responseData = new AjaxResponse_User(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<IDisposable> disposableItems = new DisposableCollection<IDisposable>())
			{

				// Identify item.
				SysId userAccountId = SysId.ToSysId(model.UserId);
				if (!SysId.IsValid(userAccountId))
					return Json(responseData.SetPopupMessage(messageTitle, Localiser["msg.error.item.id.not.specified"]));

				// Retrieve item.
				SaxUserAccount user = AccountMgr.GetUserAccountById(userAccountId);
				disposableItems.Add(user);
				if (user == null)
				{
					SaLogger.Warn(fn + " Failed to retrieve user for Id: '" + userAccountId + "'");
					return Json(responseData.SetPopupMessage(messageTitle, Localiser["msg.error.item.id.not.found"]));
				}

				// User Sports.
				List<SaxUserSport> userSports = GetUserSports(user.Id, SaxUserSport.StatusCat.ActiveOnly);
				disposableItems.AddRange(userSports);

				// User Roles.
				List<SaxUserRole> userRoles = GetUserRoles(user.Id, SaxUserRole.StatusCat.ActiveOnly);
				disposableItems.AddRange(userRoles);

				// Construct response.
				PopulateUserResponseItemData(model, responseData.user, user, userSports, userRoles);
				responseData.Success = true;
			}
			return Json(responseData);
		}

		//-------------------------------------------------------------------
		// Get User by email ajax request.
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("User/Ajax/GetUserByEmail")]
		public IActionResult Ajax_GetUserByEmail(Model_User model)
		{
			String fn = GetType().Name + ".Ajax_GetUserByEmail";
			String messageTitle = Localiser["user.caption.user"];
			AjaxResponse_User responseData = new AjaxResponse_User(model);
			StoreSessionData = false;

			// 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<IDisposable> disposableItems = new DisposableCollection<IDisposable>())
			{

				// Identify user.
				if (StringUtil.IsEmpty(model.UserEmailAddress))
				{
					SaLogger.Warn(fn + " Attempt to get user details with blank email.");
					return Json(responseData);
				}

				// Retrieve user.
				SaxUserAccount user = AccountMgr.GetUserAccountByEmailAddress(model.UserEmailAddress);
				disposableItems.Add(user);
				if (user == null)
				{
					SaLogger.Warn(fn + " Failed to retrieve user for Email: " + model.UserEmailAddress);
					return Json(responseData);
				}

				// User Sports.
				List<SaxUserSport> userSports = GetUserSports(user.Id, SaxUserSport.StatusCat.ActiveOnly);
				disposableItems.AddRange(userSports);

				// User Roles.
				List<SaxUserRole> userRoles = GetUserRoles(user.Id, SaxUserRole.StatusCat.ActiveOnly);
				disposableItems.AddRange(userRoles);

				// Construct response.
				PopulateUserResponseItemData(model, responseData.user, user, userSports, userRoles);
				responseData.Success = true;
			}
			return Json(responseData);
		}

		//-------------------------------------------------------------------
		// Store User ajax request.
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("User/Ajax/StoreItem")]
		[Route("User/Ajax/StoreUser")]
		public IActionResult Ajax_StoreUser(Model_User model)
		{
			String fn = GetType().Name + ".Ajax_StoreUser";
			String messageTitle = Localiser["user.caption.user"];
			AjaxResponse_User responseData = new AjaxResponse_User(model);

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

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

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

				// Retrieve existing item.
				SysId userAccountId = SysId.ToSysId(model.UserId);
				SaxUserAccount user = AccountMgr.GetUserAccountById(userAccountId);
				disposableItems.Add(user);
				if (user == null && SysId.IsValid(userAccountId))
				{
					SaLogger.Warn(fn + " Failed to retrieve user for Id: '" + model.UserId + "'");
					return Json(responseData.SetPopupMessage(messageTitle, Localiser["msg.error.item.id.not.found"]));
				}

				// User roles, including deleted in case of reassignment.
				List<SaxUserRole> userRoles = new List<SaxUserRole>();
				if (user != null) userRoles = GetUserRoles(user.Id, SaxUserRole.StatusCat.Any);
				disposableItems.AddRange(userRoles);
				if (model.UserRoleCodes != null)
				{
					List<String> userRoleCodes = model.GetUserRoleCodes();
					foreach (String userRoleCode in userRoleCodes)
					{
						// Role to activate.
						Sax.UserRole role = (Sax.UserRole)UserRoleCodes.GetTypeForCode(userRoleCode);
						SaxUserRole userRole = userRoles.GetUserRoleByRole(role);
						if (userRole == null)
						{
							userRole = AccountMgr.CreateUserRole(user?.Id, role);
							userRoles.Add(userRole);
						}
						userRole.Status = SaStatus.Active;
					}
					// Roles to deactivate.
					foreach (SaxUserRole userRole in userRoles)
					{
						if (!userRoleCodes.Exists(item => item.EqualsCI(UserRoleCodes.GetCodeForType(userRole.UserRole))))
							userRole.Status = SaStatus.Inactive;
					}
				}

				// Create new item if required.
				if (user == null)
				{
					user = AccountMgr.CreateUserAccount();
					if (model.UserEmailAddress != null)
						user.EmailAddress = model.UserEmailAddress;
				}

				// Populate item properties.
				if (model.UserTitle != null)
					user.Title = model.UserTitle;
				if (model.UserFirstName != null)
					user.FirstName = model.UserFirstName;
				if (model.UserLastName != null)
					user.LastName = model.UserLastName;
				if (model.UserRegionIdCountry != null)
					user.RegionIdCountry = SysId.ToSysId(model.UserRegionIdCountry);
				if (model.UserRegionIdProvince != null)
					user.RegionIdProvince = SysId.ToSysId(model.UserRegionIdProvince);
				if (model.UserStatusCode != null)
					user.Status = model.UserStatus;

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

				if (model.UserRoleCodes != null)
				{
					// Associated data - User Roles.
					foreach (SaxUserRole userRole in (userRoles))
					{
						// Store User Role.
						if (!SysId.IsValid(userRole.Id))
						{
							// Apply User Account Id if not yet done (for new user).
							if (!SysId.IsValid(userRole.UserAccountId))
								userRole.UserAccountId = user.Id;
							if (!AccountMgr.InsertUserRole(userRole, DbUpdateInfo))
								SaLogger.Warn(fn + " Failed to insert user role: " + AccountMgr.ErrorStateMessage);
						}
						else
						{
							if (!AccountMgr.UpdateUserRole(userRole, DbUpdateInfo))
								SaLogger.Warn(fn + " Failed to update user role [Id:" + SysId.ToString(userRole.Id) + "]: " + AccountMgr.ErrorStateMessage);
						}
					}
				}

				// User Sports.
				List<SaxUserSport> userSports = GetUserSports(user.Id, SaxUserSport.StatusCat.ActiveOnly);
				disposableItems.AddRange(userSports);

				// Construct response.
				PopulateUserResponseItemData(model, responseData.user, user, userSports, userRoles.GetUserRolesByStatus(SaStatus.Active));
				responseData.Success = true;
			}
			return Json(responseData);
		}

		//-------------------------------------------------------------------
		// Send User Emails ajax request.
		//-------------------------------------------------------------------
		[HttpPost]
		[Route("User/Ajax/SendEmails")]
		public IActionResult Ajax_SendEmails(Model_User model)
		{
			String fn = GetType().Name + ".Ajax_SendEmails";
			String messageTitle = Localiser["label.emails"];
			AjaxResponse_User responseData = new AjaxResponse_User(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<IDisposable> disposableItems = new DisposableCollection<IDisposable>())
			{

				// Retrieve user.
				SysId userAccountId = SysId.ToSysId(model.UserId);
				SaxUserAccount userAccount = AccountMgr.GetUserAccountById(userAccountId);
				disposableItems.Add(userAccount);
				if (userAccount == null)
				{
					SaLogger.Warn(fn + " Failed to retrieve user for Id: '" + model.UserId + "'");
					return Json(responseData.SetPopupMessage(messageTitle, Localiser["msg.error.item.id.not.found"]));
				}

				// User roles.
				List<SaxUserRole> userRoles = GetUserRoles(userAccount.Id, SaxUserRole.StatusCat.Any);
				disposableItems.AddRange(userRoles);
				bool systemAdmin = userRoles.Exists(item => item.UserRole == Sax.UserRole.SystemAdmin);

				// Email types to send.
				bool sendAcountActivationOnline = StringUtil.ToBool(model.UserEmailAcountActivationOnline);
				bool sendRequestPasswordOnline = StringUtil.ToBool(model.UserEmailRequestPasswordOnline);
				bool sendRequestPasswordAdmin = StringUtil.ToBool(model.UserEmailRequestPasswordAdmin);
				if (!sendAcountActivationOnline && !sendRequestPasswordOnline && !sendRequestPasswordAdmin)
					return Json(responseData.SetPopupMessage(messageTitle, Localiser["msg.validation.select.option"]));
				if (sendRequestPasswordAdmin && !systemAdmin)
					return Json(responseData.SetPopupMessage(messageTitle, Localiser["user.msg.not.system.admin"]));

				// Send emails.
				int emailsSentCount = 0;
				if (sendAcountActivationOnline)
				{
					if (!OrganisationController.SendAccountActivatedEmail(this, userAccount))
						return Json(responseData.SetPopupMessage(messageTitle, "Failed to send Online Account Activation email."));
					emailsSentCount++;
				}
				if (sendRequestPasswordOnline)
				{
					if (!SecurityController.SendRequestPasswordEmail(this, userAccount, true))
						return Json(responseData.SetPopupMessage(messageTitle, "Failed to send Online Request Password email."));
					emailsSentCount++;
				}
				if (sendRequestPasswordAdmin)
				{
					if (!SecurityController.SendRequestPasswordEmail(this, userAccount, false))
						return Json(responseData.SetPopupMessage(messageTitle, "Failed to send Admin Request Password email."));
					emailsSentCount++;
				}

				// User Sports.
				List<SaxUserSport> userSports = GetUserSports(userAccount.Id, SaxUserSport.StatusCat.ActiveOnly);
				disposableItems.AddRange(userSports);

				// Construct response.
				PopulateUserResponseItemData(model, responseData.user, userAccount, userSports, userRoles.GetUserRolesByStatus(SaStatus.Active));
				responseData.SetNotifyMessage(messageTitle, "Emails sent: " + emailsSentCount);
				responseData.Success = true;
			}
			return Json(responseData);
		}

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