using Sarand.Net.Standard.Dbas.Data;
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 Saxonite.Base.App;
using Saxonite.Net.Standard.Dbas.Bus;
using Saxonite.Net.Standard.Dbas.Internal;
using Saxonite.Net.Standard.Base.App;
using Saxonite.Net.Standard.Base.Bus;
using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Text;
using Sarand.Net.Standard.Base.Utils;
using System.Linq;
using Saxonite.Net.Standard.Dbas.Internal.Core;

namespace Saxonite.Net.Standard.Dbas.Mgr
{
	//=======================================================================
	partial class SaxActivityMgr_Dbas
	{
		//*******************************************************************
		// Activity Mgr - Article
		//*******************************************************************
		// Utilities.
		private List<StringPair> GetLogProperties(SaxArticle article)
		{
			return new List<StringPair>()
			{
				new StringPair("Id", SysId.ToString(article.Id)),
				new StringPair("UserAccountIdAuthor", SysId.ToString(article.UserAccountIdAuthor)),
				new StringPair("OrganisationId", SysId.ToString(article.OrganisationId)),
				new StringPair("Headline", StringUtil.Left(article.Headline,32)),
				new StringPair("Status", article.StatusCode)
			};
		}

		//-------------------------------------------------------------------
		// Create item.
		public override SaxArticle CreateArticle(SysId userAccountIdAuthor, SysId organisationId)
		{
			ClearErrorState();
			return new SaxArticle_Dbas(CoreDatabase, null, userAccountIdAuthor, organisationId, 0);
		}
		private SaxArticle_Dbas CreateArticle(Article_Db dbArticle)
		{
			ClearErrorState();
			SaxArticle_Dbas article = new SaxArticle_Dbas(CoreDatabase, new SysId(dbArticle._Id), new SysId(dbArticle._UserAccountIdAuthor), new SysId(dbArticle._OrganisationId), (UInt16)dbArticle._Flags);
			PopulateFrom(dbArticle, article);
			return article;
		}

		//-------------------------------------------------------------------
		// Get item.
		public override SaxArticle GetArticle(SaxArticle.Params prm)
		{
			ClearErrorState();
			return GetArticle(GetArticleQueryFilter(prm).Concat(" And ", "(", ")"));
		}
		private SaxArticle GetArticle(String filter)
		{
			ClearErrorState();
			long count = GetArticleCount(filter);
			if (count == 0) return null;
			if (count != 1)
			{
				SetErrorState("Multiple items found");
				return null;
			}
			SaxArticle article = null;
			// Query data.
			using (var dbConnection = CoreDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					Article_Db dbArticle = new Article_Db(CoreDbInfo);
					dbArticle.PopulateFrom(dbCommand, aliasArticle, filter);
					article = CreateArticle(dbArticle);
				}
				catch (Exception exc)
				{
					SetErrorState("Database query exception");
					SaLogger.Warn(GetType().Name + ".GetArticle\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
				}
			}
			return article;
		}

		//-------------------------------------------------------------------
		// Validate item.
		public override bool IsValidArticleData(SaxArticle.Data data, SaxArticle.ErrField errField)
		{
			ClearErrorState();
			if (!base.IsValidArticleData(data, errField)) return false;
			return true;
		}

		//-------------------------------------------------------------------
		// Insert item.
		public override bool InsertArticle(SaxArticle article, DbUpdateInfo dbUpdateInfo)
		{
			String fn = GetType().Name + ".InsertArticle";
			ClearErrorState();
			if (!IsValidArticle(article)) return false;
			if (SysId.IsValid(article.Id)) return SetErrorState(ErrorMessage.ValiditemId);
			using (var dbConnection = CoreDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					Article_Db dbArticle = new Article_Db(CoreDbInfo);
					PopulateTo(dbArticle, article, dbUpdateInfo);
					if (Article_Db.FieldsNonId.Contains("Id"))
					{
						// Generate next Id.
						// ToDo dbArticle._Id = CoreDatabase.GetNextIdFromTable("Article");
					}
					dbArticle.ExecuteInsertCommand(dbCommand);
					article.Id = new SysId(dbArticle._Id);
					article.Changed = false;
					if (DebugMode) SaLogger.Debug(fn + " Inserted. " + GetLogProperties(article).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Update item.
		public override bool UpdateArticle(SaxArticle article, DbUpdateInfo dbUpdateInfo)
		{
			String fn = GetType().Name + ".UpdateArticle";
			ClearErrorState();
			if (!IsValidArticle(article)) return false;
			if (!SysId.IsValid(article.Id)) return SetErrorState(ErrorMessage.InvalidItemId);
			if (!article.Changed)
			{
				if (DebugMode) SaLogger.Debug(fn + " Data not changed. " + GetLogProperties(article).Concat(": ").Concat("", "\n\t"));
				return true;
			}
			using (var dbConnection = CoreDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					Article_Db dbArticle = new Article_Db(CoreDbInfo);
					dbArticle.PopulateFrom(dbCommand, aliasArticle, "Id=" + SysId.ToString(article.Id));
					// ToDo SaxUpdateLogItemMonitor_Article updateLogMonitor = new SaxUpdateLogItemMonitor_Article(SessionContext, CreateArticle(dbArticle), dbUpdateInfo);
					// Update item.
					PopulateTo(dbArticle, article, dbUpdateInfo);
					dbArticle.ExecuteUpdateCommand(dbCommand);
					article.Changed = false;
					if (DebugMode) SaLogger.Debug(fn + " Updated. " + GetLogProperties(article).Concat(": ").Concat("", "\n\t"));
					// Record updates.
					// ToDo updateLogMonitor.RecordUpdatedValues(article);
					// ToDo updateLogMonitor.LogUpdates();
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
		}

		//-------------------------------------------------------------------
		// Delete item.
		public override bool ArticleCanBeDeleted(SaxArticle article)
		{
			ClearErrorState();
			if (!base.ArticleCanBeDeleted(article)) return false;
			return true;
		}
		public override bool DeleteArticle(SaxArticle article, DbUpdateInfo dbUpdateInfo)
		{
			String fn = GetType().Name + ".DeleteArticle";
			ClearErrorState();
			if (!ArticleCanBeDeleted(article)) return false;

			// Articles are logically deleted by changing the status.
			article.Status = SaStatus.Deleted;
			return UpdateArticle(article, dbUpdateInfo);

			/*
			 * Physical deletion.
			using (var dbConnection = CoreDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					// Retrieve item.
					dbConnection.Open();
					Article_Db dbArticle = new Article_Db(CoreDbInfo);
					dbArticle.PopulateFrom(dbCommand, aliasArticle, "Id=" + article.Id.ToString());
					// Delete item.
					dbCommand.CommandType = System.Data.CommandType.Text;
					dbCommand.CommandText = "DELETE FROM " + SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Article) + " WHERE Id=" + SysId.ToString(article.Id) + ";";
					dbCommand.ExecuteNonQuery();
					article.Changed = false;
					if (DebugMode) SaLogger.Debug(fn + " Deleted. " + GetLogProperties(article).Concat(": ").Concat("", "\n\t"));
				}
				catch (Exception exc) { SetErrorState(exc.Message); }
			}
			return !HasErrorState();
			*/
		}

		//-------------------------------------------------------------------
		// Copy data properties to and from database.
		private void PopulateTo(Article_Db dbArticle, SaxArticle article, DbUpdateInfo dbUpdateInfo)
		{
			dbArticle._Id = SysId.ToInt(article.Id);
			dbArticle._UserAccountIdAuthor = SysId.ToInt(article.UserAccountIdAuthor);
			dbArticle._OrganisationId = SysId.ToInt(article.OrganisationId);
			dbArticle._SportIdPrimary = SysId.ToInt(article.SportIdPrimary);
			dbArticle._RegionIdPrimary = SysId.ToInt(article.RegionIdPrimary);
			dbArticle._Headline = article.Headline;
			dbArticle._Summary = article.Summary;
			dbArticle._ItemImageIdThumbnail = SysId.ToInt(article.ItemImageIdThumbnail);
			dbArticle._BodyData = article.BodyData;
			dbArticle._PublishedAt = article.PublishedAt;
			dbArticle._Notes = article.Notes;
			dbArticle._Status = SacsSystem.GetStatusCode(article.Status);
			dbArticle._Flags = (short)article.Flags;
			if (!SysId.IsValid(article.Id))
			{
				dbArticle._CreateOn = DateTime.Now;
				dbArticle._CreateBy = dbUpdateInfo.UserId.ToInt();
				dbArticle._CreateHost = dbUpdateInfo.Host;
			}
			dbArticle._UpdateOn = DateTime.Now;
			dbArticle._UpdateBy = dbUpdateInfo.UserId.ToInt();
			dbArticle._UpdateHost = dbUpdateInfo.Host;
		}
		private void PopulateFrom(Article_Db dbArticle, SaxArticle article)
		{
			//article.Id = new SysId(dbArticle._Id);
			//article.UserAccountIdAuthor = new SysId(dbArticle._UserAccountIdAuthor);
			//article.OrganisationId = new SysId(dbArticle._OrganisationId);
			article.SportIdPrimary = new SysId(dbArticle._SportIdPrimary);
			article.RegionIdPrimary = new SysId(dbArticle._RegionIdPrimary);
			article.Headline = dbArticle._Headline;
			article.Summary = dbArticle._Summary;
			article.ItemImageIdThumbnail = new SysId(dbArticle._ItemImageIdThumbnail);
			article.BodyData = dbArticle._BodyData;
			article.PublishedAt = dbArticle._PublishedAt;
			article.Notes = dbArticle._Notes;
			article.Status = SacsSystem.GetStatusForCode(dbArticle._Status);
			article.SetCreateStamp(dbArticle._CreateOn, new SysId(dbArticle._CreateBy), dbArticle._CreateHost);
			article.SetUpdateStamp(dbArticle._UpdateOn, new SysId(dbArticle._UpdateBy), dbArticle._UpdateHost);
			article.AcceptChanges();
		}

		//-------------------------------------------------------------------
		// Item column definitions.
		private static readonly String aliasArticle = "Art";
		private static readonly String aliasArticle_Author = "Art_Auth";
		private static readonly String prefixArticle_Author = aliasArticle_Author + "_";
		private static readonly String aliasArticle_Organisation = "Art_Org";
		private static readonly String prefixArticle_Organisation = aliasArticle_Organisation + "_";
		private static readonly String colArticle_OrganisationOwner_LogoCount = "Art_Org_LogoCount";
		private static readonly String aliasArticle_Sport = "Art_Spt";
		private static readonly String prefixArticle_Sport = aliasArticle_Sport + "_";
		private static readonly String aliasArticle_Region = "Art_Rgn";
		private static readonly String prefixArticle_Region = aliasArticle_Region + "_";
		private static readonly String aliasArticle_Feedback = "Art_Fbk";
		private static readonly String prefixArticle_Feedback = aliasArticle_Feedback + "_";
		private void SetArticleColDfn
			(ColumnDfn col, String caption, int width, SaxDbDfn_Core.ColumnIdx dbCol,
			ColumnAlignment align = ColumnAlignment.Default, DataValue.DataType dataType = DataValue.DataType.String,
			String alias = "", String prefix = "")
		{
			if (String.IsNullOrEmpty(alias) && SaxDbDfn_Core.GetTableForColumn(dbCol) == SaxDbDfn_Core.TableIdx.Article)
				alias = aliasArticle;
			col.Set(caption, width, (int)dbCol, prefix + SaxDbDfn_Core.GetColumnName(dbCol, false), SaxDbDfn_Core.GetColumnNameQual(dbCol, alias), dataType, align);
			if (dataType == DataValue.DataType.String && dbCol != SaxDbDfn_Core.ColumnIdx.Unknown)
				col.MaxLength = (int)SaxDbDfn_Core.GetColTextLen(dbCol);
		}
		public override ColumnDfn GetArticleColumnDfn(SaxArticle.Column columnId, string caption = "", int width = 0)
		{
			ColumnDfn columnDfn = new ColumnDfn((int)columnId, caption, width);
			switch (columnId)
			{
				//-----------------------------------------------------------
				case SaxArticle.Column.Pos:
					SetArticleColDfn(columnDfn, "Pos", 60, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Right);
					columnDfn.SortMode = ColumnDfn.ColumnSortMode.Off;
					columnDfn.ReadOnly = true;
					columnDfn.Resizable = false;
					break;
				case SaxArticle.Column.Id:
					SetArticleColDfn(columnDfn, "Id", 80, SaxDbDfn_Core.ColumnIdx.Article_Id, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;

				//-----------------------------------------------------------
				// Organisation.
				case SaxArticle.Column.OrganisationId:
					SetArticleColDfn(columnDfn, "Organisation Id", 80, SaxDbDfn_Core.ColumnIdx.Article_OrganisationId, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Organisation_Name:
					SetArticleColDfn(columnDfn, "Organisation", 120, SaxDbDfn_Core.ColumnIdx.Organisation_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasArticle_Organisation, prefixArticle_Organisation);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Organisation_LogoCount:
					SetActivityIndexColDfn(columnDfn, "Organisation Logos", 100, SaxDbDfn_Core.ColumnIdx.Unknown, ColumnAlignment.Center, DataValue.DataType.Long);
					columnDfn.DataName = colArticle_OrganisationOwner_LogoCount;
					columnDfn.ReadOnly = true;
					break;

				//-----------------------------------------------------------
				// Author.
				case SaxArticle.Column.UserAccountIdAuthor:
					SetArticleColDfn(columnDfn, "Author Id", 80, SaxDbDfn_Core.ColumnIdx.Article_UserAccountIdAuthor, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Author_DisplayName:
					SetArticleColDfn(columnDfn, "Author", 120, SaxDbDfn_Core.ColumnIdx.Unknown);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Author_Title:
					SetArticleColDfn(columnDfn, "Author title", 80, SaxDbDfn_Core.ColumnIdx.UserAccount_Title, ColumnAlignment.Left, DataValue.DataType.String, aliasArticle_Author, prefixArticle_Author);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Author_FirstName:
					SetArticleColDfn(columnDfn, "Author first name", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName, ColumnAlignment.Left, DataValue.DataType.String, aliasArticle_Author, prefixArticle_Author);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Author_LastName:
					SetArticleColDfn(columnDfn, "Author last name", 100, SaxDbDfn_Core.ColumnIdx.UserAccount_LastName, ColumnAlignment.Left, DataValue.DataType.String, aliasArticle_Author, prefixArticle_Author);
					columnDfn.ReadOnly = true;
					break;

				//-----------------------------------------------------------
				// Sport.
				case SaxArticle.Column.SportIdPrimary:
					SetArticleColDfn(columnDfn, "Sport Id", 80, SaxDbDfn_Core.ColumnIdx.Article_SportIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Sport_Name:
					SetArticleColDfn(columnDfn, "Sport", 100, SaxDbDfn_Core.ColumnIdx.Sport_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasArticle_Sport, prefixArticle_Sport);
					columnDfn.ReadOnly = true;
					break;

				//-----------------------------------------------------------
				// Region.
				case SaxArticle.Column.RegionIdPrimary:
					SetArticleColDfn(columnDfn, "Region Id", 80, SaxDbDfn_Core.ColumnIdx.Article_RegionIdPrimary, ColumnAlignment.Right, DataValue.DataType.Long);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Region_Name:
					SetArticleColDfn(columnDfn, "Region", 100, SaxDbDfn_Core.ColumnIdx.Region_Name, ColumnAlignment.Left, DataValue.DataType.String, aliasArticle_Region, prefixArticle_Region);
					columnDfn.ReadOnly = true;
					break;

				//-----------------------------------------------------------
				// Article.
				case SaxArticle.Column.Headline:
					SetArticleColDfn(columnDfn, "Headline", 200, SaxDbDfn_Core.ColumnIdx.Article_Headline);
					break;
				case SaxArticle.Column.Summary:
					SetArticleColDfn(columnDfn, "Summary", 200, SaxDbDfn_Core.ColumnIdx.Article_Summary);
					break;
				case SaxArticle.Column.ItemImageIdThumbnail:
					SetArticleColDfn(columnDfn, "Thumbnail", 80, SaxDbDfn_Core.ColumnIdx.Article_ItemImageIdThumbnail, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SaxArticle.Column.PublishedAt_Date:
					SetArticleColDfn(columnDfn, "Published", 80, SaxDbDfn_Core.ColumnIdx.Article_PublishedAt, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.PublishedAt_DateTime:
					SetArticleColDfn(columnDfn, "Published", 100, SaxDbDfn_Core.ColumnIdx.Article_PublishedAt, ColumnAlignment.Center, DataValue.DataType.DateTime);
					columnDfn.ReadOnly = true;
					break;

				//-----------------------------------------------------------
				// Feedback.
				case SaxArticle.Column.Feedback_ViewCount:
					SetArticleColDfn(columnDfn, "Views", 80, SaxDbDfn_Core.ColumnIdx.ActivityFeedback_ViewCount, ColumnAlignment.Center, DataValue.DataType.Long, aliasActivityFeedback, prefixArticle_Feedback);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Feedback_FeedbackCount:
					SetArticleColDfn(columnDfn, "Feedbacks", 80, SaxDbDfn_Core.ColumnIdx.ActivityFeedback_FeedbackCount, ColumnAlignment.Center, DataValue.DataType.Long, aliasActivityFeedback, prefixArticle_Feedback);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Feedback_FeedbackTotal:
					SetArticleColDfn(columnDfn, "Feedback total", 80, SaxDbDfn_Core.ColumnIdx.ActivityFeedback_FeedbackTotal, ColumnAlignment.Center, DataValue.DataType.Long, aliasActivityFeedback, prefixArticle_Feedback);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.Feedback_FeedbackAverage:
					SetArticleColDfn(columnDfn, "Feedback", 80, SaxDbDfn_Core.ColumnIdx.ActivityFeedback_FeedbackAverage, ColumnAlignment.Center, DataValue.DataType.Double, aliasActivityFeedback, prefixArticle_Feedback);
					columnDfn.ReadOnly = true;
					columnDfn.NumDecimals = 2;
					break;

				//-----------------------------------------------------------
				// Derived properties.

				//-----------------------------------------------------------
				// Common properties.
				case SaxArticle.Column.Notes:
					SetArticleColDfn(columnDfn, "Notes", 240, SaxDbDfn_Core.ColumnIdx.Article_Notes);
					break;
				case SaxArticle.Column.Flags:
					SetArticleColDfn(columnDfn, "Flags", 60, SaxDbDfn_Core.ColumnIdx.Article_Flags, ColumnAlignment.Center, DataValue.DataType.Long);
					break;
				case SaxArticle.Column.Status:
					SetArticleColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.Article_Status, ColumnAlignment.Center);
					break;
				case SaxArticle.Column.Status_Desc:
					SetArticleColDfn(columnDfn, "Status", 90, SaxDbDfn_Core.ColumnIdx.Article_Status, ColumnAlignment.Center);
					break;
				case SaxArticle.Column.Status_Ind:
					SetArticleColDfn(columnDfn, "Status", 80, SaxDbDfn_Core.ColumnIdx.Article_Status, ColumnAlignment.Center, DataValue.DataType.TriState);
					columnDfn.TriStateFormat = ColumnTriStateFormat.Lights;
					break;
				case SaxArticle.Column.CreateOn_Date:
					SetArticleColDfn(columnDfn, "Created", 80, SaxDbDfn_Core.ColumnIdx.Article_CreateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;
				case SaxArticle.Column.UpdateOn_Date:
					SetArticleColDfn(columnDfn, "Updated", 80, SaxDbDfn_Core.ColumnIdx.Article_UpdateOn, ColumnAlignment.Center, DataValue.DataType.Date);
					columnDfn.ReadOnly = true;
					break;

					//-----------------------------------------------------------
			}
			if (!String.IsNullOrEmpty(caption))
				columnDfn.Caption = caption;
			if (width > 0)
				columnDfn.Width = width;
			return columnDfn;
		}

		//-------------------------------------------------------------------
		// Item query filter.
		public override List<string> GetArticleQueryFilter(SaxArticle.Params prm)
		{
			List<String> filter = new List<String>();

			// Item Ids.
			String idsIncluded = prm.IdsIncluded.Concat(",");
			if (!idsIncluded.IsEmpty())
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Id, aliasArticle) + " IN (" + idsIncluded + ")");
			String idsExcluded = prm.IdsExcluded.Concat(",");
			if (!idsExcluded.IsEmpty())
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Id, aliasArticle) + " NOT IN (" + idsExcluded + ")");

			// Author User Account.
			String userAccountIdsIncluded = prm.UserAccountIdsAuthorIncluded.Concat(",");
			if (!userAccountIdsIncluded.IsEmpty())
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_UserAccountIdAuthor, aliasArticle) + " IN (" + userAccountIdsIncluded + ")");

			// Organisations.
			String organisationIdsIncluded = prm.OrganisationIdsIncluded.Concat(",");
			if (!organisationIdsIncluded.IsEmpty())
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_OrganisationId, aliasArticle) + " IN (" + organisationIdsIncluded + ")");
			else if (prm.ExcludeOrganisationArticles)
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_OrganisationId, aliasArticle) + "=0 Or " + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_OrganisationId, aliasArticle) + " Is Null");

			// Sport Ids.
			String sportIdsIncluded = prm.SportIdsIncluded.Concat(",");
			if (!sportIdsIncluded.IsEmpty())
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_SportIdPrimary, aliasArticle) + " IN (" + sportIdsIncluded + ")");

			// Region Ids.
			String regionIdsIncluded = prm.RegionIdsIncluded.Concat(",");
			if (!regionIdsIncluded.IsEmpty())
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_RegionIdPrimary, aliasArticle) + " IN (" + regionIdsIncluded + ")");

			// Headline.
			if (!StringUtil.IsEmpty(prm.HeadlinePartial))
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Headline, aliasArticle) + " Like '%" + DbQuery.FormatForLike(prm.HeadlinePartial, true) + "%'");

			// Summary.
			if (!StringUtil.IsEmpty(prm.SummaryPartial))
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Summary, aliasArticle) + " Like '%" + DbQuery.FormatForLike(prm.SummaryPartial, true) + "%'");

			// Article.
			if (!StringUtil.IsEmpty(prm.ArticleFilter))
			{
				// Split filter into words.
				List<String> filterWords = prm.ArticleFilter.Split((char[])null).ToList();
				filterWords.RemoveDuplicatesCI();
				filterWords.RemoveBlanks();
				foreach (String filterWord in filterWords)
				{
					List<String> articleFilter = new List<String>();
					articleFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Headline, aliasArticle) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
					articleFilter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Summary, aliasArticle) + " Like '%" + DbQuery.FormatForLike(filterWord, true) + "%'");
					filter.Add(articleFilter.Concat(" OR ", "(", ")"));
				}
			}

			// Notes.
			if (!StringUtil.IsEmpty(prm.NotesPartial))
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Notes, aliasArticle) + " LIKE '%" + DbQuery.FormatForLike(prm.NotesPartial) + "%'");

			// Status.
			if (prm.StatusCat != SaxArticle.StatusCat.Any)
				filter.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Status, aliasArticle) + GetArticleStatusCatFilterCondition(prm.StatusCat));

			if (filter.Count < 1) filter.Add("1=1");
			return filter;
		}
		internal static String GetArticleStatusCatFilterCondition(SaxArticle.StatusCat statusCat)
		{
			if (statusCat == SaxArticle.StatusCat.ActiveOnly)
				return "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'";
			if (statusCat == SaxArticle.StatusCat.InactiveOnly)
				return "='" + SacsSystem.GetStatusCode(SaStatus.Inactive) + "'";
			if (statusCat == SaxArticle.StatusCat.NotDeleted)
				return "!='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'";
			if (statusCat == SaxArticle.StatusCat.DeletedOnly)
				return "='" + SacsSystem.GetStatusCode(SaStatus.Deleted) + "'";
			return "";
		}
		// Item sort columns.
		public List<String> GetArticleSortColumns(SaxArticle.Params prm)
		{
			// Sort sequence:
			List<String> sortColumnNames = new List<String>();
			foreach (var columnDfn in prm.SortColumns)
			{
				// Need to ensure correct alias used for Article columns in case of conflict.
				String sortCol = String.Empty;
				if (SaxDbDfn_Core.GetTableForColumn((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn) == SaxDbDfn_Core.TableIdx.Article)
				{
					sortCol = SaxDbDfn_Core.GetColumnNameQual((SaxDbDfn_Core.ColumnIdx)columnDfn.DbColumn, aliasArticle);
				}
				else
				{
					sortCol = columnDfn.DataName;
					if (!StringUtil.IsEmpty(columnDfn.SortDataName))
						sortCol = columnDfn.SortDataName;
				}
				if (!sortCol.IsEmpty())
				{
					DbOrderByNullMode orderByNullMode = DbOrderByNullMode.Default; // eSaOrderByDemoteNulls, eSaOrderByPromoteNulls
					sortColumnNames.Add(DbQuery.FormatForOrderBy(sortCol, columnDfn.SortAscending, orderByNullMode).Concat(", "));
				}
			}
			sortColumnNames.RemoveBlanks();
			if (sortColumnNames.IsEmpty())
			{
				// Default sort columns.
				sortColumnNames.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Id, aliasArticle) + " ASC");
			}
			return sortColumnNames;
		}

		//-------------------------------------------------------------------
		// Item count.
		private long GetArticleCount(String filter)
		{
			ClearErrorState();
			return CoreDatabase.GetRowCount(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Article) + " As " + aliasArticle, filter);
		}
		public override long GetArticleCount(SaxArticle.Params prm)
		{
			ClearErrorState();
			return GetArticleCount(GetArticleQueryFilter(prm).Concat(" AND ", "(", ")"));
		}

		//-------------------------------------------------------------------
		// Item list.
		public override List<SaxArticle> GetArticleList(SaxArticle.Params prm)
		{
			List<SaxArticle> userActivitys = new List<SaxArticle>();
			DbQuery qry = new DbQuery(CoreDatabase.DbmsType);
			qry.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Article), aliasArticle);
			Article_Db dbArticle = new Article_Db(CoreDbInfo);
			qry.Columns.AddRange(dbArticle.ExistingColumnNames);
			qry.Filters.AddRange(GetArticleQueryFilter(prm));
			qry.OrderBy.AddRange(GetArticleSortColumns(prm));
			// Query data.
			using (var dbConnection = CoreDatabase.CreateConnection())
			using (var dbCommand = dbConnection.CreateCommand())
			{
				try
				{
					dbConnection.Open();
					dbCommand.CommandText = qry.BuildQuery(prm.ResultsPaging);
					using (DbDataReader dbDataReader = dbCommand.ExecuteReader())
					{
						while (dbDataReader.Read())
						{
							dbArticle = new Article_Db(CoreDbInfo);
							dbArticle.PopulateFrom(dbDataReader);
							userActivitys.Add(CreateArticle(dbArticle));
						}
					}
				}
				catch (Exception exc)
				{
					SaLogger.Warn(GetType().Name + ".GetArticleList\n\tQuery: " + dbCommand.CommandText + "\n\t" + ExceptionUtil.GetLogMessage(exc));
				}
			}
			return userActivitys;
		}

		//-------------------------------------------------------------------
		// Item query execution.
		public override DbResultSet ExecuteArticleQuery(List<ColumnDfn> columns, SaxArticle.Params prm)
		{
			ClearErrorState();

			//---------------------------------------------------------------------
			// Construct query.
			DbQuery query = new DbQuery(CoreDatabase.DbmsType);
			query.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Article), aliasArticle);

			// Add columns as defined in query list.
			if (columns.HasId(SaxArticle.Column.Id))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Id, aliasArticle));
			bool hasUserAccountCols = (columns.HasId(SaxArticle.Column.Author_DisplayName) || columns.HasId(SaxArticle.Column.Author_Title) || columns.HasId(SaxArticle.Column.Author_FirstName) || columns.HasId(SaxArticle.Column.Author_LastName));
			if (columns.HasId(SaxArticle.Column.UserAccountIdAuthor) || hasUserAccountCols)
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_UserAccountIdAuthor, aliasArticle));
			bool hasOrganisationCols = (columns.HasId(SaxArticle.Column.Organisation_Name));
			if (columns.HasId(SaxArticle.Column.OrganisationId) || hasOrganisationCols)
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_OrganisationId, aliasArticle));
			bool hasSportCols = (columns.HasId(SaxArticle.Column.Sport_Name));
			if (columns.HasId(SaxArticle.Column.SportIdPrimary) || hasSportCols)
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_SportIdPrimary, aliasArticle));
			bool hasRegionCols = (columns.HasId(SaxArticle.Column.Region_Name));
			if (columns.HasId(SaxArticle.Column.RegionIdPrimary) || hasRegionCols)
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_RegionIdPrimary, aliasArticle));
			if (columns.HasId(SaxArticle.Column.Headline))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Headline, aliasArticle));
			if (columns.HasId(SaxArticle.Column.Summary))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Summary, aliasArticle));
			if (columns.HasId(SaxArticle.Column.ItemImageIdThumbnail))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_ItemImageIdThumbnail, aliasArticle));
			if (columns.HasId(SaxArticle.Column.PublishedAt_Date) || columns.HasId(SaxArticle.Column.PublishedAt_DateTime))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_PublishedAt, aliasArticle));
			// Common properties.
			if (columns.HasId(SaxArticle.Column.Notes))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Notes, aliasArticle));
			if (columns.HasId(SaxArticle.Column.Flags))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Flags, aliasArticle));
			if (columns.HasId(SaxArticle.Column.Status) || columns.HasId(SaxArticle.Column.Status_Desc) || columns.HasId(SaxArticle.Column.Status_Ind))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Status, aliasArticle));
			if (columns.HasId(SaxArticle.Column.CreateOn_Date))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_CreateOn, aliasArticle));
			if (columns.HasId(SaxArticle.Column.UpdateOn_Date))
				query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_UpdateOn, aliasArticle));

			//---------------------------------------------------------------------
			// User Account.
			if (hasUserAccountCols)
			{
				DbQueryJoin joinUserAccount = new DbQueryJoin(DbJoinType.LeftOuter);
				joinUserAccount.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.UserAccount), aliasArticle_Author);
				joinUserAccount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.UserAccount_Id, aliasArticle_Author) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_UserAccountIdAuthor, aliasArticle));
				query.Joins.Add(joinUserAccount);
				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_Title);
				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_FirstName);
				cols.Add(SaxDbDfn_Core.ColumnIdx.UserAccount_LastName);
				foreach (var col in cols)
					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasArticle_Author), prefixArticle_Author + SaxDbDfn_Core.GetColumnName(col, false));
			}

			//---------------------------------------------------------------------
			// Organisation.
			if (hasOrganisationCols)
			{
				DbQueryJoin joinOrganisation = new DbQueryJoin(DbJoinType.LeftOuter);
				joinOrganisation.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Organisation), aliasArticle_Organisation);
				joinOrganisation.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Organisation_Id, aliasArticle_Organisation) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_OrganisationId, aliasArticle));
				query.Joins.Add(joinOrganisation);
				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
				cols.Add(SaxDbDfn_Core.ColumnIdx.Organisation_Name);
				foreach (var col in cols)
					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasArticle_Organisation), prefixArticle_Organisation + SaxDbDfn_Core.GetColumnName(col, false));
			}

			//---------------------------------------------------------------------
			// Organisation Logo Image Count.
			if (columns.HasId(SaxArticle.Column.Organisation_LogoCount))
			{
				String aliasLogoCount = "aImg_Logo";
				DbQuery queryLogoCount = new DbQuery(CoreDatabase.DbmsType);
				queryLogoCount.Tables.Add(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ItemImage), aliasLogoCount);
				queryLogoCount.Columns.Add("Count(*)");
				queryLogoCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemImage_ItemType, aliasLogoCount) + "=" + (int)Sax.DataItemType.Organisation);
				queryLogoCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemImage_ItemId, aliasLogoCount) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_OrganisationId, aliasArticle));
				queryLogoCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemImage_ImageType, aliasLogoCount) + "=" + (int)Sax.ImageType.OrganisationLogo);
				queryLogoCount.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ItemImage_Status, aliasLogoCount) + "='" + SacsSystem.GetStatusCode(SaStatus.Active) + "'");
				// Construct sub-query.
				query.Columns.Add("(" + queryLogoCount.BuildQuery() + ")", colArticle_OrganisationOwner_LogoCount);
			}

			//---------------------------------------------------------------------
			// Primary Sport.
			if (hasSportCols)
			{
				DbQueryJoin joinSport = new DbQueryJoin(DbJoinType.LeftOuter);
				joinSport.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Sport), aliasArticle_Sport);
				joinSport.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Sport_Id, aliasArticle_Sport) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_SportIdPrimary, aliasArticle));
				query.Joins.Add(joinSport);
				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
				cols.Add(SaxDbDfn_Core.ColumnIdx.Sport_Name);
				foreach (var col in cols)
					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasArticle_Sport), prefixArticle_Sport + SaxDbDfn_Core.GetColumnName(col, false));
			}

			//---------------------------------------------------------------------
			// Primary Region.
			if (hasRegionCols)
			{
				DbQueryJoin joinRegion = new DbQueryJoin(DbJoinType.LeftOuter);
				joinRegion.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.Region), aliasArticle_Region);
				joinRegion.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Region_Id, aliasArticle_Region) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_RegionIdPrimary, aliasArticle));
				query.Joins.Add(joinRegion);
				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
				cols.Add(SaxDbDfn_Core.ColumnIdx.Region_Name);
				foreach (var col in cols)
					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasArticle_Region), prefixArticle_Region + SaxDbDfn_Core.GetColumnName(col, false));
			}

			//---------------------------------------------------------------------
			// Feedback.
			if (columns.HasId(SaxArticle.Column.Feedback_ViewCount) || columns.HasId(SaxArticle.Column.Feedback_FeedbackCount) || columns.HasId(SaxArticle.Column.Feedback_FeedbackTotal) || columns.HasId(SaxArticle.Column.Feedback_FeedbackAverage))
			{
				DbQueryJoin joinFeedback = new DbQueryJoin(DbJoinType.LeftOuter);
				joinFeedback.Table = new StringPair(SaxDbDfn_Core.GetTableName(SaxDbDfn_Core.TableIdx.ActivityFeedback), aliasArticle_Feedback);
				joinFeedback.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityFeedback_ItemType, aliasArticle_Feedback) + "=" + ((int)Sax.DataItemType.Article).ToString());
				joinFeedback.Filters.Add(SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.ActivityFeedback_ItemId, aliasArticle_Feedback) + "=" + SaxDbDfn_Core.GetColumnNameQual(SaxDbDfn_Core.ColumnIdx.Article_Id, aliasArticle));
				query.Joins.Add(joinFeedback);
				List<SaxDbDfn_Core.ColumnIdx> cols = new List<SaxDbDfn_Core.ColumnIdx>();
				cols.Add(SaxDbDfn_Core.ColumnIdx.ActivityFeedback_ViewCount);
				cols.Add(SaxDbDfn_Core.ColumnIdx.ActivityFeedback_FeedbackCount);
				cols.Add(SaxDbDfn_Core.ColumnIdx.ActivityFeedback_FeedbackTotal);
				cols.Add(SaxDbDfn_Core.ColumnIdx.ActivityFeedback_FeedbackAverage);
				foreach (var col in cols)
					query.Columns.Add(SaxDbDfn_Core.GetColumnNameQual(col, aliasArticle_Feedback), prefixArticle_Feedback + SaxDbDfn_Core.GetColumnName(col, false));
			}

			//---------------------------------------------------------------------
			// Populate filter.
			query.Filters.AddRange(GetArticleQueryFilter(prm));

			if (prm.IdsIncluded.Count != 1)
			{
				// Configure sort sequence.
				foreach (String sortColumn in GetArticleSortColumns(prm))
					query.OrderBy.Add(sortColumn);
			}

			//---------------------------------------------------------------------
			//return new DbResultSet_DataTableReader(db, query.BuildQuery(prm.ResultsPaging));
			return DbResultSet_DataReader.ExecuteQuery(CoreDatabase, query.BuildQuery(prm.ResultsPaging));
		}

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