379 lines
14 KiB
C#
379 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Swarmops.Basic.Types;
|
|
using Swarmops.Basic.Types.Structure;
|
|
using Swarmops.Common;
|
|
using Swarmops.Database;
|
|
using Swarmops.Logic.Structure;
|
|
|
|
namespace Swarmops.Logic.Cache
|
|
{
|
|
public class OrganizationCache
|
|
{
|
|
private static DateTime lastRefresh;
|
|
private static object loadCacheLock = new object();
|
|
public static bool __loadCache = true;
|
|
private static Dictionary<int, List<BasicOrganization>> __organizationCache = null;
|
|
private static readonly int cacheLifeSpanMinutes = 2;
|
|
private static Dictionary<int, List<int>> __cachedUptakeGeographies = null;
|
|
|
|
static OrganizationCache()
|
|
{
|
|
lastRefresh = Constants.DateTimeLow;
|
|
}
|
|
|
|
public static bool needsReload
|
|
{
|
|
get
|
|
{
|
|
lock (loadCacheLock)
|
|
{
|
|
return (__loadCache || lastRefresh.AddMinutes (cacheLifeSpanMinutes) < DateTime.Now);
|
|
}
|
|
}
|
|
private set
|
|
{
|
|
lock (loadCacheLock)
|
|
{
|
|
__loadCache = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static Dictionary<int, List<BasicOrganization>> GetHashedOrganizations()
|
|
{
|
|
if (needsReload)
|
|
{
|
|
lock (loadCacheLock)
|
|
{
|
|
if (needsReload)
|
|
{
|
|
__organizationCache = SwarmDb.GetDatabaseForReading().GetHashedOrganizations();
|
|
__cachedUptakeGeographies = null;
|
|
lastRefresh = DateTime.Now;
|
|
needsReload = false;
|
|
}
|
|
}
|
|
}
|
|
return __organizationCache;
|
|
}
|
|
|
|
public static Organization FromCache (int OrganizationId)
|
|
{
|
|
lock (loadCacheLock)
|
|
{
|
|
return Organization.FromBasic (GetOrganization (OrganizationId));
|
|
}
|
|
}
|
|
|
|
|
|
internal static int CreateOrganization (int ParentOrganizationId, string NameInternational, string Name,
|
|
string NameShort, string Domain, string MailPrefix,
|
|
int AnchorGeographyId, bool AcceptsMembers,
|
|
bool AutoAssignNewMembers, int DefaultCountryId)
|
|
{
|
|
int Identity = SwarmDb.GetDatabaseForWriting().CreateOrganization (ParentOrganizationId,
|
|
NameInternational,
|
|
Name,
|
|
NameShort,
|
|
Domain,
|
|
MailPrefix,
|
|
AnchorGeographyId,
|
|
AcceptsMembers,
|
|
AutoAssignNewMembers,
|
|
DefaultCountryId);
|
|
needsReload = true;
|
|
return Identity;
|
|
}
|
|
|
|
public static void UpdateOrganization (int ParentOrganizationId, string NameInternational, string Name,
|
|
string NameShort, string Domain, string MailPrefix, int AnchorGeographyId, bool AcceptsMembers,
|
|
bool AutoAssignNewMembers, int DefaultCountryId, int OrganizationId)
|
|
{
|
|
SwarmDb.GetDatabaseForWriting()
|
|
.UpdateOrganization (ParentOrganizationId, NameInternational, Name, NameShort, Domain,
|
|
MailPrefix, AnchorGeographyId, AcceptsMembers, AutoAssignNewMembers, DefaultCountryId,
|
|
OrganizationId);
|
|
|
|
needsReload = true;
|
|
}
|
|
|
|
internal static void Reload (int objectId)
|
|
{
|
|
__loadCache = true;
|
|
|
|
// Let this be for the moment, new and old parents need to be loaded as well. Better right now to reload the whole cache.
|
|
//lock (loadCacheLock)
|
|
//{
|
|
// __organizationCache[objectId][0] = Organization.FromBasic(SwarmDb.GetDatabaseForReading().GetOrganization(objectId));
|
|
//}
|
|
}
|
|
|
|
public static BasicOrganization[] GetAll()
|
|
{
|
|
lock (loadCacheLock)
|
|
{
|
|
Dictionary<int, List<BasicOrganization>> hashedOrganisations = GetHashedOrganizations();
|
|
List<BasicOrganization> returnList = new List<BasicOrganization>();
|
|
foreach (int id in hashedOrganisations.Keys)
|
|
{
|
|
returnList.Add (hashedOrganisations[id][0]);
|
|
}
|
|
return returnList.ToArray();
|
|
}
|
|
}
|
|
|
|
public static BasicOrganization GetOrganization (int OrganizationId)
|
|
{
|
|
lock (loadCacheLock)
|
|
{
|
|
Dictionary<int, List<BasicOrganization>> hashedOrganisations = GetHashedOrganizations();
|
|
if (hashedOrganisations.ContainsKey (OrganizationId))
|
|
return hashedOrganisations[OrganizationId][0];
|
|
else
|
|
{
|
|
//Didn't find, strange, id's should exist, try reloading the cache, it could be newly added.
|
|
|
|
needsReload = true;
|
|
hashedOrganisations = GetHashedOrganizations();
|
|
if (hashedOrganisations.ContainsKey (OrganizationId))
|
|
return hashedOrganisations[OrganizationId][0];
|
|
else
|
|
{
|
|
throw new ArgumentException ("No such OrganizationId: " + OrganizationId.ToString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static BasicOrganization[] GetOrganizationTree (int startOrganizationId)
|
|
{
|
|
lock (loadCacheLock)
|
|
{
|
|
Dictionary<int, List<BasicOrganization>> organizations = GetHashedOrganizations();
|
|
|
|
return GetOrganizationTree (organizations, startOrganizationId, 0);
|
|
}
|
|
}
|
|
|
|
|
|
public static Dictionary<int, BasicOrganization> GetOrganizationHashtable (int startOrganizationId)
|
|
{
|
|
BasicOrganization[] organizations = GetOrganizationTree (startOrganizationId);
|
|
|
|
Dictionary<int, BasicOrganization> result = new Dictionary<int, BasicOrganization>();
|
|
|
|
foreach (BasicOrganization organization in organizations)
|
|
{
|
|
result[organization.OrganizationId] = organization;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
private static BasicOrganization[] GetOrganizationTree (Dictionary<int, List<BasicOrganization>> organizations,
|
|
int startOrganizationId, int generation)
|
|
{
|
|
List<BasicOrganization> result = new List<BasicOrganization>();
|
|
|
|
//Prime the cache
|
|
BasicOrganization start = GetOrganization (startOrganizationId);
|
|
|
|
List<BasicOrganization> thisList = organizations[startOrganizationId];
|
|
|
|
foreach (BasicOrganization organization in thisList)
|
|
{
|
|
if (organization.OrganizationId != startOrganizationId)
|
|
{
|
|
result.Add (organization);
|
|
// new Organization(organization.OrganizationId, organization.ParentOrganizationId, organization.Name, generation + 1));
|
|
|
|
// Add recursively
|
|
|
|
BasicOrganization[] children = GetOrganizationTree (organizations, organization.OrganizationId,
|
|
generation + 1);
|
|
|
|
if (children.Length > 0)
|
|
{
|
|
foreach (BasicOrganization child in children)
|
|
{
|
|
result.Add (child);
|
|
}
|
|
}
|
|
}
|
|
else if (generation == 0)
|
|
{
|
|
// The top parent is special and should be added; the others shouldn't
|
|
|
|
result.Add (organization);
|
|
// (new Organization(organization.OrganizationId, organization.ParentOrganizationId, organization.Name, generation));
|
|
}
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
public static BasicOrganization[] GetOrganizationChildren (int parentOrgId)
|
|
{
|
|
List<BasicOrganization> result = new List<BasicOrganization>();
|
|
lock (loadCacheLock)
|
|
{
|
|
BasicOrganization parent = GetOrganization (parentOrgId);
|
|
//TODO: It is possible to miss a child here if that child was added after the last cache load.
|
|
|
|
Dictionary<int, List<BasicOrganization>> hashedOrganizations = GetHashedOrganizations();
|
|
foreach (BasicOrganization b in hashedOrganizations[parentOrgId])
|
|
{
|
|
if (b.Identity != parentOrgId)
|
|
result.Add (b);
|
|
}
|
|
return result.ToArray();
|
|
}
|
|
}
|
|
|
|
public static BasicOrganization[] GetOrganizationLine (int leafOrganizationId)
|
|
{
|
|
lock (loadCacheLock)
|
|
{
|
|
List<BasicOrganization> result = new List<BasicOrganization>();
|
|
|
|
BasicOrganization currentOrganization = GetOrganization (leafOrganizationId);
|
|
|
|
// This iterates until the zero-parentid root Organization is found
|
|
|
|
while (currentOrganization.OrganizationId > 0)
|
|
{
|
|
result.Add (currentOrganization);
|
|
|
|
if (currentOrganization.ParentOrganizationId > 0)
|
|
{
|
|
currentOrganization = GetOrganization (currentOrganization.ParentOrganizationId);
|
|
}
|
|
else
|
|
{
|
|
currentOrganization = new BasicOrganization();
|
|
}
|
|
}
|
|
|
|
result.Reverse();
|
|
|
|
return result.ToArray();
|
|
}
|
|
}
|
|
|
|
[Obsolete ("Never use this function. Mark the org as unused, deleted. Records are needed for historic reasons.",
|
|
true)]
|
|
internal static void DeleteOrganization (int p)
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().DeleteOrganization (p);
|
|
needsReload = true;
|
|
}
|
|
|
|
/*
|
|
* Caching of Uptake Geographies
|
|
*/
|
|
|
|
// this is nulled when a main cache load is done, so it don't need a timing parameter really
|
|
// since that will be governed by the timeout of organisations.
|
|
|
|
private static Dictionary<int, List<int>> GetUptakes()
|
|
{
|
|
//to make sure we dont end up loading uptakes, loding organisations, then load uptakes again.
|
|
lock (loadCacheLock)
|
|
{
|
|
GetHashedOrganizations();
|
|
|
|
if (__cachedUptakeGeographies == null)
|
|
{
|
|
__cachedUptakeGeographies = SwarmDb.GetDatabaseForReading().GetAllOrganizationUptakeGeographyIds();
|
|
}
|
|
}
|
|
return __cachedUptakeGeographies;
|
|
}
|
|
|
|
internal static int[] GetOrganizationsIdsInGeographies (BasicGeography[] nodes)
|
|
{
|
|
if (nodes == null || nodes.Length == 0)
|
|
{
|
|
return new int[0];
|
|
}
|
|
|
|
List<int> nodeIdList = new List<int>();
|
|
|
|
foreach (BasicGeography node in nodes)
|
|
{
|
|
nodeIdList.Add (node.GeographyId);
|
|
}
|
|
|
|
return GetOrganizationIdsInGeographies (nodeIdList.ToArray());
|
|
}
|
|
|
|
|
|
public static int[] GetOrganizationIdsInGeographies (int[] nodeIds)
|
|
{
|
|
if (nodeIds == null || nodeIds.Length == 0)
|
|
{
|
|
return new int[0];
|
|
}
|
|
|
|
Dictionary<int, bool> resultKeys = new Dictionary<int, bool>();
|
|
Dictionary<int, bool> idsToFind = new Dictionary<int, bool>();
|
|
foreach (int i in nodeIds) idsToFind[i] = true;
|
|
|
|
//fist add those that has the geo as anchor
|
|
lock (loadCacheLock)
|
|
{
|
|
Dictionary<int, List<BasicOrganization>> hashedOrgs = GetHashedOrganizations();
|
|
foreach (int id in hashedOrgs.Keys)
|
|
{
|
|
BasicOrganization bo = hashedOrgs[id][0];
|
|
if (idsToFind.ContainsKey (bo.AnchorGeographyId))
|
|
{
|
|
resultKeys[bo.Identity] = true;
|
|
}
|
|
}
|
|
|
|
|
|
//then add those that has the geo as uptake
|
|
Dictionary<int, List<int>> allUptakes = GetUptakes();
|
|
foreach (int orgId in allUptakes.Keys)
|
|
{
|
|
//connected to valid org?
|
|
if (hashedOrgs.ContainsKey (orgId))
|
|
{
|
|
foreach (int geoId in allUptakes[orgId])
|
|
{
|
|
if (idsToFind.ContainsKey (geoId))
|
|
{
|
|
resultKeys[orgId] = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return (new List<int> (resultKeys.Keys)).ToArray();
|
|
;
|
|
}
|
|
|
|
internal static void AddOrgUptakeGeography (int p, int geoId)
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().AddOrgUptakeGeography (p, geoId);
|
|
lock (loadCacheLock)
|
|
{
|
|
__cachedUptakeGeographies = null;
|
|
}
|
|
}
|
|
|
|
internal static void DeleteOrgUptakeGeography (int p, int geoId)
|
|
{
|
|
SwarmDb.GetDatabaseForWriting().DeleteOrgUptakeGeography (p, geoId);
|
|
lock (loadCacheLock)
|
|
{
|
|
__cachedUptakeGeographies = null;
|
|
}
|
|
}
|
|
}
|
|
} |