public static BasicOrganization[] GetOrganizationLine(int leafOrganizationId)
{
lock (loadCacheLock)
{
List <BasicOrganization> result = new List <BasicOrganization>();
BasicOrganization currentOrganization = OrganizationCache.GetOrganization(leafOrganizationId);
// This iterates until the zero-parentid root Organization is found
while (currentOrganization.OrganizationId > 0)
{
result.Add(currentOrganization);
if (currentOrganization.ParentOrganizationId > 0)
{
currentOrganization = OrganizationCache.GetOrganization(currentOrganization.ParentOrganizationId);
}
else
{
currentOrganization = new BasicOrganization();
}
}
result.Reverse();
return(result.ToArray());
}
}
public static Organization FromCache(int OrganizationId)
{
lock (loadCacheLock)
{
return(Organization.FromBasic(OrganizationCache.GetOrganization(OrganizationId)));
}
}
public static BasicOrganization GetOrganization(int OrganizationId)
{
lock (loadCacheLock)
{
Dictionary <int, List <BasicOrganization> > hashedOrganisations = OrganizationCache.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 = OrganizationCache.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 = OrganizationCache.GetHashedOrganizations();
return(GetOrganizationTree(organizations, startOrganizationId, 0));
}
}
public static BasicOrganization[] GetAll()
{
lock (loadCacheLock)
{
Dictionary <int, List <BasicOrganization> > hashedOrganisations = OrganizationCache.GetHashedOrganizations();
List <BasicOrganization> returnList = new List <BasicOrganization>();
foreach (int id in hashedOrganisations.Keys)
{
returnList.Add(hashedOrganisations[id][0]);
}
return(returnList.ToArray());
}
}
static public BasicOrganization[] GetOrganizationChildren(int parentOrgId)
{
List <BasicOrganization> result = new List <BasicOrganization>();
lock (loadCacheLock)
{
BasicOrganization parent = OrganizationCache.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());
}
}
private static BasicOrganization[] GetOrganizationTree(Dictionary <int, List <BasicOrganization> > organizations,
int startOrganizationId, int generation)
{
List <BasicOrganization> result = new List <BasicOrganization>();
//Prime the cache
BasicOrganization start = OrganizationCache.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());
}
