andy/Saxonite
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

v1.0.5.0

Browse Source 
Activity Index. User Account country. Internals regions.
This commit is contained in:
andy
2021-05-25 22:00:08 +01:00
parent 778ee3aa03
commit 63473c725b
173 changed files with 8149 additions and 41639 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SaxoniteStandardBase/Base/Consoles/SaxActivityConsole.cs
+232
View File
@@ -0,0 +1,232 @@
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.Standard.Base.App;
using Saxonite.Net.Standard.Base.Bus;
using System;
using System.Collections.Generic;
using System.Linq;
namespace Saxonite.Net.Standard.Base.Consoles
{
//=======================================================================
// The index data is intended to provide a common, performance effective route
// to identifying the activities that are relevant to a User or other context
// that defines at least one region/sport combination and an effective date (usually today).
//=======================================================================
public abstract class SaxActivityConsole : SacsDisposable
{
//-------------------------------------------------------------------
// Definitions.
/// <summary>
/// Parameters required to query the index for activities to identify relevant activities.
/// </summary>
public class IndexContext
{
public List<SysId> SportIds { get; } = new List<SysId>();
public List<SysId> RegionIds { get; } = new List<SysId>();
// Default period is ~3 months up to today.
public DateTime EffectiveFrom { get; } = DateUtil.IncrementDate(DateTime.Today, -90);
public DateTime EffectiveTo { get; } = DateTime.Today;
public bool IsValid()
{
// Context must contain at least a sport, a region and a valid effective period.
if (!SportIds.HasValidIds()) return false;
if (!RegionIds.HasValidIds()) return false;
if (!DateUtil.IsValid(EffectiveFrom) || EffectiveTo < EffectiveFrom) return false;
return true;
}
public DbQuery.Paging Paging { get; } = new DbQuery.Paging();
}
/// <summary>
/// Activities identified by querying index with context.
/// </summary>
public class IndexResults
{
public class ItemData
{
public ItemData(ItemId itemId, DateTime effectiveOn)
{
ItemId = itemId;
EffectiveOn = effectiveOn;
}
public ItemId ItemId { get; }
public DateTime EffectiveOn { get; }
}
public List<ItemData> Items { get; } = new List<ItemData>();
}
//-------------------------------------------------------------------
// Data members.
private readonly List<Sax.DataItemType> validActivityItemTypes = new List<Sax.DataItemType>()
{
Sax.DataItemType.JournalistArticle,
Sax.DataItemType.OrganisationOpportunity,
};
//-------------------------------------------------------------------
// Protected construction.
protected SaxActivityConsole(SaxSessionContext sessionContext)
{
SessionContext = sessionContext;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
}
}
//-------------------------------------------------------------------
// Properties.
protected SaxSessionContext SessionContext { get; }
protected List<Sax.DataItemType> ValidActivityItemTypes { get { return validActivityItemTypes.ToList(); } }
//-------------------------------------------------------------------
// Query Activity Index Entries for User Context.
//-------------------------------------------------------------------
public abstract IndexResults QueryIndex(IndexContext context);
//-------------------------------------------------------------------
// Store Activity Index for Specific activities.
//-------------------------------------------------------------------
/// <summary>
/// Store the Activity Index for a Journalist Article.
/// </summary>
public bool StoreActivityIndex(SaxJournalistArticle article, DbUpdateInfo dbUpdateInfo)
{
// Only active articles have an activity index.
if (!article.IsStatusActive) ClearActivityIndex(article.GetItemId(), dbUpdateInfo);
// NB There will be other rules as well, eg. whether published.
// Activity Index properties.
IndexData indexData = new IndexData(article.GetItemId());
indexData.SportIds.Add(article.SportIdPrimary);
indexData.RegionIds.Add(article.RegionIdPrimary);
indexData.EffectiveOn = DateUtil.OnInvalid(article.PublishedAt.Date, article.CreateStamp.On.Date);
return StoreActivityIndexData(indexData, dbUpdateInfo);
}
public bool ClearActivityIndex(SaxJournalistArticle article, DbUpdateInfo dbUpdateInfo)
{
return ClearActivityIndex(article.GetItemId(), dbUpdateInfo);
}
//-------------------------------------------------------------------
/// <summary>
/// Store the Activity Index for a Organisation Opportunity.
/// </summary>
public bool StoreActivityIndex(SaxOrganisationOpportunity opportunity, DbUpdateInfo dbUpdateInfo)
{
// Only active opportunities have an activity index.
if (!opportunity.IsStatusActive) ClearActivityIndex(opportunity.GetItemId(), dbUpdateInfo);
// NB There will be other rules as well, eg. whether published.
// Activity Index properties.
IndexData indexData = new IndexData(opportunity.GetItemId());
indexData.SportIds.Add(opportunity.SportIdPrimary);
indexData.RegionIds.Add(opportunity.RegionIdPrimary);
indexData.EffectiveOn = DateUtil.OnInvalid(opportunity.PublishedAt.Date, opportunity.CreateStamp.On.Date);
List<SysId> regionIds = new List<SysId>();
return StoreActivityIndexData(indexData, dbUpdateInfo);
}
public bool ClearActivityIndex(SaxOrganisationOpportunity opportunity, DbUpdateInfo dbUpdateInfo)
{
return ClearActivityIndex(opportunity.GetItemId(), dbUpdateInfo);
}
//-------------------------------------------------------------------
// Store Activity Index.
//-------------------------------------------------------------------
/// <summary>Data values that make up the index for an activity.</summary>
protected class IndexData
{
public IndexData(ItemId itemId)
{
ItemId = itemId;
}
public ItemId ItemId { get; }
public List<SysId> SportIds { get; } = new List<SysId>();
public List<SysId> RegionIds { get; } = new List<SysId>();
public DateTime EffectiveOn { get; set; }
public bool IsValid()
{
if (!ItemId.IsValid(ItemId)) return false;
if (!SportIds.HasValidIds()) return false;
if (!RegionIds.HasValidIds()) return false;
if (!DateUtil.IsValid(EffectiveOn)) return false;
return true;
}
}
/// <summary>Single entry in the index for an activity.</summary>
protected class IndexEntryData
{
public IndexEntryData(ItemId itemId, SysId sportId, SysId regionId, DateTime effectiveOn)
{
ItemId = itemId;
SportId = sportId;
RegionId = regionId;
EffectiveOn = effectiveOn;
}
public ItemId ItemId { get; }
public SysId SportId { get; }
public SysId RegionId { get; }
public DateTime EffectiveOn { get; }
public bool IsValid()
{
if (!ItemId.IsValid(ItemId)) return false;
if (!SysId.IsValid(SportId)) return false;
if (!SysId.IsValid(RegionId)) return false;
if (!DateUtil.IsValid(EffectiveOn)) return false;
return true;
}
/// <summary>Compare index entry Ids - Item, Sport & Region.</summary>
public bool MatchesIds(SaxActivityIndex activityIndex)
{
if (!ItemId.Equals(activityIndex.ItemId)) return false;
if (!SportId.Equals(activityIndex.SportId)) return false;
if (!RegionId.Equals(activityIndex.RegionId)) return false;
return true;
}
/// <summary>Compare index entry Ids - Item, Sport & Region - and effective date.</summary>
public bool Matches(SaxActivityIndex activityIndex)
{
if (!MatchesIds(activityIndex)) return false;
if (!EffectiveOn.Equals(activityIndex.EffectiveOn)) return false;
return true;
}
}
//-------------------------------------------------------------------
protected abstract bool StoreActivityIndexData(IndexData indexData, DbUpdateInfo dbUpdateInfo);
//-------------------------------------------------------------------
protected abstract bool ClearActivityIndex(ItemId itemId, DbUpdateInfo dbUpdateInfo);
//-------------------------------------------------------------------
// Utilities.
//-------------------------------------------------------------------
protected List<IndexEntryData> GetEntriesForIndex(IndexData indexData)
{
List<IndexEntryData> indexEntries = new List<IndexEntryData>();
if (ItemId.IsValid(indexData.ItemId) && DateUtil.IsValid(indexData.EffectiveOn))
{
foreach (SysId sportId in indexData.SportIds.FindAll(item => SysId.IsValid(item)))
{
foreach (SysId regionId in indexData.RegionIds.FindAll(item => SysId.IsValid(item)))
{
IndexEntryData indexEntry = new IndexEntryData(indexData.ItemId, sportId, regionId, indexData.EffectiveOn);
if (indexEntry.IsValid())
indexEntries.Add(indexEntry);
}
}
}
return indexEntries;
}
//-------------------------------------------------------------------
}
//=======================================================================
}
SaxoniteStandardBase/Base/Consoles/SaxConsoleHelper.cs
+4
View File
@@ -18,6 +18,10 @@ namespace Saxonite.Net.Standard.Base.Consoles
// Data cache console.
public abstract SaxDataCacheConsole GetDataCacheConsole(SaxSessionContext sessionContext);
//-------------------------------------------------------------------
// Activity console.
public abstract SaxActivityConsole CreateActivityConsole(SaxSessionContext sessionContext);
//-------------------------------------------------------------------
// Email console.
public abstract SaxEmailConsole CreateEmailConsole(SaxSessionContext sessionContext);
SaxoniteStandardBase/Base/Consoles/SaxDataCacheConsole.cs
+15
View File
@@ -14,15 +14,30 @@ namespace Saxonite.Net.Standard.Base.Consoles
// Protected construction.
protected SaxDataCacheConsole(SaxSessionContext sessionContext)
{
SessionContext = sessionContext;
}
protected override void Dispose(bool disposing) { }
//-------------------------------------------------------------------
// Properties.
protected SaxSessionContext SessionContext { get; }
//-------------------------------------------------------------------
// Utilities.
public abstract void PopulateCachedDataToInternals(SaxInternals internals);
//-------------------------------------------------------------------
// Regions.
/// <summary>
/// Get the cached list of regions. NB These should be disposed after use.
/// </summary>
public abstract List<SaxRegion> GetActiveRegions();
//-------------------------------------------------------------------
// Sports.
/// <summary>
/// Get the cached list of sports. NB These should be disposed after use.
/// </summary>
public abstract List<SaxSport> GetActiveSports();
//-------------------------------------------------------------------