519 lines
15 KiB
C#
519 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Activizr.Logic.Security;
|
|
using Activizr.Logic.Structure;
|
|
using Activizr.Logic.Support;
|
|
using Activizr.Basic.Enums;
|
|
using Activizr.Basic.Types;
|
|
using Activizr.Database;
|
|
|
|
namespace Activizr.Logic.Pirates
|
|
{
|
|
public class People : List<Person>
|
|
{
|
|
public int[] Identities
|
|
{
|
|
get { return LogicServices.ObjectsToIdentifiers(ToArray()); }
|
|
}
|
|
|
|
public static People FromMemberships (Memberships memberships)
|
|
{
|
|
var personIds = new List<int>();
|
|
|
|
foreach (Membership membership in memberships)
|
|
{
|
|
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.
|
|
|
|
var lookup = new Dictionary<int, bool>();
|
|
|
|
foreach (int key in personIds)
|
|
{
|
|
lookup[key] = true;
|
|
}
|
|
|
|
BasicPerson[] basicArray = PirateDb.GetDatabase().GetAllPeople();
|
|
var 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;
|
|
}
|
|
else
|
|
{
|
|
return People.FromArray(PirateDb.GetDatabase().GetPeople(personIds));
|
|
}
|
|
}
|
|
|
|
public static People GetAll ()
|
|
{
|
|
return People.FromArray(PirateDb.GetDatabase().GetAllPeople());
|
|
}
|
|
|
|
public static People FromNamePattern (string namePattern)
|
|
{
|
|
// Remove any injection codes
|
|
namePattern = namePattern.Replace("%", String.Empty).Trim();
|
|
|
|
while (namePattern.Contains(" "))
|
|
{
|
|
namePattern = namePattern.Replace(" ", " ");
|
|
}
|
|
|
|
if (namePattern.Length > 0)
|
|
{
|
|
namePattern = namePattern.Replace(" ", "% ") + "%";
|
|
|
|
if (!namePattern.Contains(" "))
|
|
{
|
|
namePattern = "%" + namePattern;
|
|
}
|
|
|
|
return People.FromArray(PirateDb.GetDatabase().GetPeopleFromNamePattern(namePattern));
|
|
}
|
|
|
|
return null; // If no valid search string was supplied
|
|
}
|
|
|
|
public static People FromBirtDatePattern (DateTime fromdate, DateTime todate)
|
|
{
|
|
return People.FromArray(PirateDb.GetDatabase().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(PirateDb.GetDatabase().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(PirateDb.GetDatabase().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(PirateDb.GetDatabase().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(PirateDb.GetDatabase().GetPeopleFromPostalCodes(pcodes));
|
|
}
|
|
|
|
return null; // If no valid search string was supplied
|
|
}
|
|
|
|
public static People FromEmail (string email)
|
|
{
|
|
if (email.Length > 0)
|
|
{
|
|
return People.FromArray(PirateDb.GetDatabase().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;
|
|
}
|
|
|
|
var result = new People();
|
|
var 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
|
|
|
|
var 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
|
|
|
|
var 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();
|
|
|
|
this.ForEach(delegate(Person p)
|
|
{
|
|
if (match(p))
|
|
retlist.Add(p);
|
|
});
|
|
|
|
return retlist;
|
|
}
|
|
|
|
public static People FromOrganizationAndGeography (int organizationId, int geographyId)
|
|
{
|
|
Geographies geoTree = Geography.FromIdentity(geographyId).GetTree();
|
|
|
|
// First, get list of people in the geography, then filter on memberships
|
|
|
|
BasicPerson[] people = PirateDb.GetDatabase().GetPeopleInGeographies(geoTree.Identities);
|
|
|
|
// Filter on memberships
|
|
|
|
// Get the organization tree
|
|
|
|
Organizations orgTree = Organization.FromIdentity(organizationId).GetTree();
|
|
|
|
// 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.
|
|
|
|
var lookup = new Dictionary<int, BasicOrganization>();
|
|
|
|
foreach (Organization org in orgTree)
|
|
{
|
|
lookup[org.Identity] = org;
|
|
}
|
|
|
|
// Get the list of all memberships
|
|
|
|
Dictionary<int, List<BasicMembership>> memberships =
|
|
PirateDb.GetDatabase().GetMembershipsForPeople(LogicServices.ObjectsToIdentifiers(people));
|
|
|
|
var result = new People();
|
|
|
|
foreach (BasicPerson basicPerson in people)
|
|
{
|
|
bool memberOfOrganization = false;
|
|
|
|
if (memberships.ContainsKey(basicPerson.Identity))
|
|
{
|
|
foreach (BasicMembership membership in memberships[basicPerson.Identity])
|
|
{
|
|
if (lookup.ContainsKey(membership.OrganizationId))
|
|
{
|
|
memberOfOrganization = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (memberOfOrganization)
|
|
{
|
|
result.Add(Person.FromBasic(basicPerson));
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static People FromGeography (int geographyId)
|
|
{
|
|
Geographies geoTree = Geography.FromIdentity(geographyId).GetTree();
|
|
|
|
// First, get list of people in the geography, then filter on memberships
|
|
|
|
BasicPerson[] people = PirateDb.GetDatabase().GetPeopleInGeographies(geoTree.Identities);
|
|
|
|
var result = new People();
|
|
|
|
foreach (BasicPerson basicPerson in people)
|
|
{
|
|
result.Add(Person.FromBasic(basicPerson));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static People FromSingle (Person person)
|
|
{
|
|
var result = new People();
|
|
result.Add(person);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
public static People FromArray (Person[] personArray)
|
|
{
|
|
var 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)
|
|
{
|
|
var 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 People.FromIdentities(PirateDb.GetDatabase().GetObjectsByOptionalData(ObjectType.Person, dataType, data));
|
|
}
|
|
|
|
public static People FromPhoneNumber (int countryId, string phoneNumber)
|
|
{
|
|
return People.FromArray(PirateDb.GetDatabase().GetPeopleFromPhoneNumber(countryId, phoneNumber));
|
|
}
|
|
|
|
public static People FromPhoneNumber (string countryCode, string phoneNumber)
|
|
{
|
|
return People.FromArray(PirateDb.GetDatabase().GetPeopleFromPhoneNumber(countryCode, phoneNumber));
|
|
}
|
|
|
|
public People GetVisiblePeopleByAuthority (Authority authority)
|
|
{
|
|
return GetVisiblePeopleByAuthority(authority, 0);
|
|
}
|
|
|
|
public People GetVisiblePeopleByAuthority (Authority authority, int gracePeriod)
|
|
{
|
|
return Authorization.FilterPeopleToMatchAuthority(this, authority,gracePeriod );
|
|
}
|
|
|
|
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 = PirateDb.GetDatabase().GetSubscribersForNewsletterFeed(2);
|
|
|
|
return FromIdentities(subscriberIds);
|
|
}
|
|
|
|
public new void Remove (Person personToRemove)
|
|
{
|
|
for (int index = 0; index < this.Count; index++)
|
|
{
|
|
if (this[index].Identity == personToRemove.Identity)
|
|
{
|
|
RemoveAt(index);
|
|
index--;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static Dictionary<int, int> GetPeopleGeographies ()
|
|
{
|
|
return PirateDb.GetDatabase().GetPeopleGeographies();
|
|
}
|
|
|
|
public static People FromIdentities (int[] personIds, bool preserveOrder)
|
|
{
|
|
People set = People.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;
|
|
}
|
|
}
|
|
} |