579 lines
18 KiB
C#
579 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Swarmops.Basic.Types;
|
|
using Swarmops.Basic.Types.Structure;
|
|
using Swarmops.Basic.Types.Swarm;
|
|
using Swarmops.Common.Enums;
|
|
using Swarmops.Common.Interfaces;
|
|
using Swarmops.Database;
|
|
using Swarmops.Logic.Security;
|
|
using Swarmops.Logic.Structure;
|
|
using Swarmops.Logic.Support;
|
|
|
|
namespace Swarmops.Logic.Swarm
|
|
{
|
|
public class People : List<Person>, IHasIdentities, IHasSingularPluralTypes
|
|
{
|
|
public int[] Identities
|
|
{
|
|
get { return LogicServices.ObjectsToIdentifiers (ToArray()); }
|
|
}
|
|
|
|
public static People FromMemberships (Participations participations)
|
|
{
|
|
List<int> personIds = new List<int>();
|
|
|
|
foreach (Participation membership in participations)
|
|
{
|
|
personIds.Add (membership.PersonId);
|
|
}
|
|
|
|
return FromIdentities (personIds.ToArray());
|
|
}
|
|
|
|
public static People FromIdentities (int[] personIds)
|
|
{
|
|
if (personIds.Length > 500)
|
|
{
|
|
// If over fivehundred identities are requested, we won't pass the array to
|
|
// SQL Server. Rather, we'll get ALL the people and parse the list ourselves.
|
|
|
|
Dictionary<int, bool> lookup = new Dictionary<int, bool>();
|
|
|
|
foreach (int key in personIds)
|
|
{
|
|
lookup[key] = true;
|
|
}
|
|
|
|
BasicPerson[] basicArray = SwarmDb.GetDatabaseForReading().GetAllPeople();
|
|
People result = new People();
|
|
|
|
for (int index = 0; index < basicArray.Length; index++)
|
|
{
|
|
if (lookup.ContainsKey (basicArray[index].Identity))
|
|
{
|
|
result.Add (Person.FromBasic (basicArray[index]));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeople (personIds));
|
|
}
|
|
|
|
public static People GetAll()
|
|
{
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetAllPeople());
|
|
}
|
|
|
|
public static People FromNamePattern (string namePattern)
|
|
{
|
|
if (namePattern.Trim().Length < 3)
|
|
{
|
|
return new People();
|
|
}
|
|
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeopleFromNamePattern (namePattern));
|
|
}
|
|
|
|
public static People FromBirthDatePattern (DateTime fromdate, DateTime todate)
|
|
{
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeopleFromBirthdate (fromdate, todate));
|
|
}
|
|
|
|
public static People FromEmailPattern (string emailPattern)
|
|
{
|
|
// Remove any injection codes
|
|
emailPattern = emailPattern.Replace ("%", String.Empty).Trim();
|
|
|
|
if (emailPattern.Length > 0)
|
|
{
|
|
emailPattern = "%" + emailPattern + "%";
|
|
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeopleFromEmailPattern (emailPattern));
|
|
}
|
|
|
|
return null; // If no valid search string was supplied
|
|
}
|
|
|
|
public static People FromCityPattern (string cityPattern)
|
|
{
|
|
// Remove any injection codes
|
|
cityPattern = cityPattern.Replace ("%", String.Empty).Trim();
|
|
|
|
if (cityPattern.Length > 0)
|
|
{
|
|
cityPattern = "%" + cityPattern + "%";
|
|
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeopleFromCityPattern (cityPattern));
|
|
}
|
|
|
|
return null; // If no valid search string was supplied
|
|
}
|
|
|
|
public static People FromPostalCodePattern (string pcPattern)
|
|
{
|
|
// Remove any injection codes
|
|
pcPattern = pcPattern.Replace ("%", String.Empty).Trim();
|
|
|
|
if (pcPattern.Length > 0)
|
|
{
|
|
pcPattern = pcPattern + "%";
|
|
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeopleFromPostalCodePattern (pcPattern));
|
|
}
|
|
|
|
return null; // If no valid search string was supplied
|
|
}
|
|
|
|
public static People FromPostalCodes (string[] pcodes)
|
|
{
|
|
// Remove any injection codes
|
|
if (pcodes.Length > 0)
|
|
{
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeopleFromPostalCodes (pcodes));
|
|
}
|
|
|
|
return null; // If no valid search string was supplied
|
|
}
|
|
|
|
public static People FromMail (string email)
|
|
{
|
|
if (email.Length > 0)
|
|
{
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeopleFromEmail (email));
|
|
}
|
|
|
|
return null; // If no valid search string was supplied
|
|
}
|
|
|
|
public static People LogicalAnd (People set1, People set2)
|
|
{
|
|
// If either set is invalid, return the other
|
|
// (a null is different from an empty set)
|
|
|
|
if (set1 == null)
|
|
{
|
|
return set2;
|
|
}
|
|
|
|
if (set2 == null)
|
|
{
|
|
return set1;
|
|
}
|
|
|
|
People result = new People();
|
|
Dictionary<int, bool> set2Lookup = new Dictionary<int, bool>();
|
|
|
|
// Build set2's lookup table
|
|
|
|
foreach (Person person in set2)
|
|
{
|
|
set2Lookup[person.Identity] = true;
|
|
}
|
|
|
|
// Build result
|
|
|
|
foreach (Person person in set1)
|
|
{
|
|
if (set2Lookup.ContainsKey (person.Identity))
|
|
{
|
|
result.Add (person);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static People LogicalOr (People set1, People set2)
|
|
{
|
|
// If either set is invalid, return the other
|
|
// (a null is different from an empty set)
|
|
|
|
if (set1 == null)
|
|
{
|
|
return set2;
|
|
}
|
|
|
|
if (set2 == null)
|
|
{
|
|
return set1;
|
|
}
|
|
|
|
// Build table, eliminating duplicates
|
|
|
|
Dictionary<int, Person> table = new Dictionary<int, Person>();
|
|
|
|
foreach (Person person in set1)
|
|
{
|
|
if (person == null) continue;
|
|
|
|
table[person.Identity] = person;
|
|
}
|
|
|
|
foreach (Person person in set2)
|
|
{
|
|
if (person == null) continue;
|
|
|
|
table[person.Identity] = person;
|
|
}
|
|
|
|
// Assemble result, without any nulls in the original sets
|
|
|
|
People result = new People();
|
|
|
|
foreach (Person person in table.Values)
|
|
{
|
|
result.Add (person);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public People LogicalAnd (People set2)
|
|
{
|
|
return LogicalAnd (this, set2);
|
|
}
|
|
|
|
public People LogicalOr (People set2)
|
|
{
|
|
return LogicalOr (this, set2);
|
|
}
|
|
|
|
public People Filter (Predicate<Person> match)
|
|
{
|
|
People retlist = new People();
|
|
|
|
ForEach (delegate (Person p)
|
|
{
|
|
if (match (p))
|
|
retlist.Add (p);
|
|
});
|
|
|
|
return retlist;
|
|
}
|
|
|
|
|
|
public static People FromOrganizationAndGeographyWithPattern (Organization organization, Geography geography,
|
|
string pattern)
|
|
{
|
|
Geographies geoTree = geography.ThisAndBelow();
|
|
|
|
pattern = pattern.Trim();
|
|
if (pattern.Length == 0)
|
|
{
|
|
return FromOrganizationAndGeography (organization, geography);
|
|
}
|
|
if (pattern.Length < 3)
|
|
{
|
|
// too short pattern! Return empty set.
|
|
return new People();
|
|
}
|
|
|
|
// First, get list of people in the geography, then filter on memberships
|
|
|
|
BasicPerson[] candidates =
|
|
SwarmDb.GetDatabaseForReading().GetPeopleInGeographiesWithPattern (geoTree.Identities, pattern);
|
|
|
|
return People.LogicalOr(FilterByMembership (candidates, organization), FilterByApplicant(candidates, organization));
|
|
}
|
|
|
|
|
|
public static People FromOrganizationAndGeography (Organization organization, Geography geography)
|
|
{
|
|
Geographies geoTree = geography.ThisAndBelow();
|
|
|
|
// First, get list of people in the geography, then filter on memberships
|
|
|
|
BasicPerson[] people = SwarmDb.GetDatabaseForReading().GetPeopleInGeographies (geoTree.Identities);
|
|
|
|
// Filter on memberships
|
|
|
|
return People.LogicalOr(FilterByMembership (people, organization), FilterByApplicant(people, organization));
|
|
}
|
|
|
|
|
|
private static People FilterByMembership (BasicPerson[] candidates, Organization organization)
|
|
{
|
|
// Get the organization tree
|
|
|
|
Organizations orgTree = organization.ThisAndBelow();
|
|
|
|
// Build a lookup table of this organization tree. For each person in 'people'
|
|
// that has at least one membership in an organization in the lookup table,
|
|
// add that person to the final result.
|
|
|
|
Dictionary<int, BasicOrganization> lookup = new Dictionary<int, BasicOrganization>();
|
|
|
|
foreach (Organization org in orgTree)
|
|
{
|
|
lookup[org.Identity] = org;
|
|
}
|
|
|
|
// Get the list of all memberships
|
|
|
|
Dictionary<int, List<BasicParticipation>> memberships =
|
|
SwarmDb.GetDatabaseForReading()
|
|
.GetParticipationsForPeople (LogicServices.ObjectsToIdentifiers (candidates));
|
|
|
|
People result = new People();
|
|
|
|
foreach (BasicPerson basicPerson in candidates)
|
|
{
|
|
bool memberOfOrganization = false;
|
|
|
|
if (memberships.ContainsKey (basicPerson.Identity))
|
|
{
|
|
foreach (BasicParticipation membership in memberships[basicPerson.Identity])
|
|
{
|
|
if (lookup.ContainsKey (membership.OrganizationId))
|
|
{
|
|
memberOfOrganization = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (memberOfOrganization)
|
|
{
|
|
result.Add (Person.FromBasic (basicPerson));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static People FilterByApplicant(BasicPerson[] candidates, Organization organization)
|
|
{
|
|
// Get the organization tree
|
|
|
|
Organizations orgTree = organization.ThisAndBelow();
|
|
|
|
// Build a lookup table of this organization tree. For each person in 'people'
|
|
// that has at least one membership in an organization in the lookup table,
|
|
// add that person to the final result.
|
|
|
|
Dictionary<int, BasicOrganization> lookup = new Dictionary<int, BasicOrganization>();
|
|
|
|
foreach (Organization org in orgTree)
|
|
{
|
|
lookup[org.Identity] = org;
|
|
}
|
|
|
|
// Get the list of all memberships
|
|
|
|
Dictionary<int, List<BasicApplicant>> applicants =
|
|
SwarmDb.GetDatabaseForReading()
|
|
.GetApplicantsFromPeople(People.FromArray(candidates).Identities);
|
|
|
|
People result = new People();
|
|
|
|
foreach (BasicPerson basicPerson in candidates)
|
|
{
|
|
bool applicantToOrganization = false;
|
|
|
|
if (applicants.ContainsKey(basicPerson.Identity))
|
|
{
|
|
foreach (BasicApplicant applicant in applicants[basicPerson.Identity])
|
|
{
|
|
if (lookup.ContainsKey(applicant.OrganizationId))
|
|
{
|
|
applicantToOrganization = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (applicantToOrganization)
|
|
{
|
|
result.Add(Person.FromBasic(basicPerson));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static People FromGeography (int geographyId)
|
|
{
|
|
Geographies geoTree = Geography.FromIdentity (geographyId).ThisAndBelow();
|
|
|
|
// First, get list of people in the geography, then filter on memberships
|
|
|
|
BasicPerson[] people = SwarmDb.GetDatabaseForReading().GetPeopleInGeographies (geoTree.Identities);
|
|
|
|
People result = new People();
|
|
|
|
foreach (BasicPerson basicPerson in people)
|
|
{
|
|
result.Add (Person.FromBasic (basicPerson));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static People FromSingle (Person person)
|
|
{
|
|
People result = new People();
|
|
result.Add (person);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
public static People FromArray (Person[] personArray)
|
|
{
|
|
People result = new People();
|
|
|
|
result.Capacity = personArray.Length*11/10;
|
|
foreach (Person person in personArray)
|
|
{
|
|
result.Add (person);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static People FromArray (BasicPerson[] personArray)
|
|
{
|
|
People result = new People();
|
|
|
|
result.Capacity = personArray.Length*11/10;
|
|
foreach (BasicPerson basic in personArray)
|
|
{
|
|
result.Add (Person.FromBasic (basic));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
public static People FromOptionalData (ObjectOptionalDataType dataType, string data)
|
|
{
|
|
return
|
|
FromIdentities (SwarmDb.GetDatabaseForReading()
|
|
.GetObjectsByOptionalData (ObjectType.Person, dataType, data));
|
|
}
|
|
|
|
public static People FromPhoneNumber (int countryId, string phoneNumber)
|
|
{
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeopleFromPhoneNumber (countryId, phoneNumber));
|
|
}
|
|
|
|
public static People FromPhoneNumber (string countryCode, string phoneNumber)
|
|
{
|
|
return People.FromArray (SwarmDb.GetDatabaseForReading().GetPeopleFromPhoneNumber (countryCode, phoneNumber));
|
|
}
|
|
|
|
/*
|
|
public People GetVisiblePeople (Organization organization)
|
|
{
|
|
People result = new People();
|
|
|
|
// First, get all the currently visible people for this org
|
|
|
|
Dictionary<RoleType, bool> roleTypeLookup = Authorization.VisibleRolesDictionary;
|
|
Roles orgRoles = Roles.FromOrganization (organization);
|
|
|
|
Dictionary<int, bool> personIdLookup = new Dictionary<int, bool>();
|
|
|
|
foreach (PersonRole orgRole in orgRoles)
|
|
{
|
|
if (roleTypeLookup.ContainsKey (orgRole.Type))
|
|
{
|
|
personIdLookup[orgRole.PersonId] = true;
|
|
}
|
|
}
|
|
|
|
// Now that we have all the visible people in the org, match them against the current list
|
|
|
|
foreach (Person person in this)
|
|
{
|
|
if (personIdLookup.ContainsKey (person.Identity))
|
|
{
|
|
result.Add (person);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public People RemoveUnique()
|
|
{
|
|
BasicPerson[] arrayToFilter = ToArray();
|
|
BasicPerson[] filtered = Authorization.FilterUniquePeople (arrayToFilter);
|
|
return FromArray (filtered);
|
|
}
|
|
|
|
public People RemoveUnlisted()
|
|
{
|
|
BasicPerson[] arrayToFilter = ToArray();
|
|
BasicPerson[] filtered = Authorization.FilterUnlistedPeople (arrayToFilter);
|
|
return FromArray (filtered);
|
|
}*/
|
|
|
|
|
|
/*
|
|
private void Repopulate(BasicPerson[] personArray)
|
|
{
|
|
this.Clear();
|
|
|
|
this.Capacity = personArray.Length * 11 / 10;
|
|
foreach (PirateWeb.Basic.Types.BasicPerson person in personArray)
|
|
{
|
|
this.Add((Person)person);
|
|
}
|
|
}*/
|
|
|
|
public static People FromNewsletterFeed (int feedId)
|
|
{
|
|
int[] subscriberIds = SwarmDb.GetDatabaseForReading().GetSubscribersForNewsletterFeed (2);
|
|
|
|
return FromIdentities (subscriberIds);
|
|
}
|
|
|
|
public new void Remove (Person personToRemove)
|
|
{
|
|
for (int index = 0; index < Count; index++)
|
|
{
|
|
if (this[index].Identity == personToRemove.Identity)
|
|
{
|
|
RemoveAt (index);
|
|
index--;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static Dictionary<int, int> GetPeopleGeographies()
|
|
{
|
|
return SwarmDb.GetDatabaseForReading().GetPeopleGeographies();
|
|
}
|
|
|
|
public static People FromIdentities (int[] personIds, bool preserveOrder)
|
|
{
|
|
People set = FromIdentities (personIds);
|
|
|
|
if (preserveOrder == false)
|
|
{
|
|
return set;
|
|
}
|
|
|
|
Dictionary<int, Person> lookup = new Dictionary<int, Person>();
|
|
|
|
foreach (Person person in set)
|
|
{
|
|
lookup[person.Identity] = person;
|
|
}
|
|
|
|
People result = new People();
|
|
|
|
foreach (int identity in personIds)
|
|
{
|
|
result.Add (lookup[identity]);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public Type SingularType { get { return typeof(Person); } }
|
|
public Type PluralType { get { return typeof(People); } }
|
|
}
|
|
} |