463 lines
14 KiB
C#
463 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Web;
|
|
using Swarmops.Logic.Structure;
|
|
|
|
namespace Swarmops.Logic.DataObjects
|
|
{
|
|
#if !__MonoCS__
|
|
[DataObject (true)]
|
|
#endif
|
|
public class OrganizationsDataObject
|
|
{
|
|
public class Org : Organization
|
|
{
|
|
private string countryCode;
|
|
|
|
public Org()
|
|
{
|
|
}
|
|
|
|
public Org (Organization org)
|
|
: base (org)
|
|
{
|
|
try
|
|
{
|
|
ParentName = FromIdentity (ParentOrganizationId).Name;
|
|
}
|
|
catch
|
|
{
|
|
ParentName = "N/A";
|
|
}
|
|
try
|
|
{
|
|
AnchorName = Geography.FromIdentity (AnchorGeographyId).Name;
|
|
}
|
|
catch
|
|
{
|
|
AnchorName = "N/A";
|
|
}
|
|
try
|
|
{
|
|
this.countryCode = base.DefaultCountry.Code;
|
|
}
|
|
catch
|
|
{
|
|
this.countryCode = "N/A";
|
|
}
|
|
}
|
|
|
|
#region Properties for fields
|
|
|
|
public new bool AcceptsMembers
|
|
{
|
|
get { return base.AcceptsMembers; }
|
|
set { base.AcceptsMembers = value; }
|
|
}
|
|
|
|
public new int AnchorGeographyId
|
|
{
|
|
get { return base.AnchorGeographyId; }
|
|
set { base.AnchorGeographyId = value; }
|
|
}
|
|
|
|
public new bool AutoAssignNewMembers
|
|
{
|
|
get { return base.AutoAssignNewMembers; }
|
|
set { base.AutoAssignNewMembers = value; }
|
|
}
|
|
|
|
public new string Domain
|
|
{
|
|
get { return base.Domain; }
|
|
set { base.Domain = value; }
|
|
}
|
|
|
|
public new string MailPrefix
|
|
{
|
|
get { return base.MailPrefix; }
|
|
set { base.MailPrefix = value; }
|
|
}
|
|
|
|
public new string Name
|
|
{
|
|
get { return base.Name; }
|
|
set { base.Name = value; }
|
|
}
|
|
|
|
public new string NameInternational
|
|
{
|
|
get { return base.NameInternational; }
|
|
set { base.NameInternational = value; }
|
|
}
|
|
|
|
public new int Identity
|
|
{
|
|
get { return base.OrganizationId; }
|
|
set { base.OrganizationId = value; }
|
|
}
|
|
|
|
public new string NameShort
|
|
{
|
|
get { return base.NameShort; }
|
|
set { base.NameShort = value; }
|
|
}
|
|
|
|
public new int ParentOrganizationId
|
|
{
|
|
get { return base.ParentOrganizationId; }
|
|
set { base.ParentOrganizationId = value; }
|
|
}
|
|
|
|
public new int DefaultCountryId
|
|
{
|
|
get { return base.DefaultCountryId; }
|
|
set { base.DefaultCountryId = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
public string ParentName { get; set; }
|
|
|
|
public string AnchorName { get; set; }
|
|
|
|
public string CountryCode
|
|
{
|
|
get
|
|
{
|
|
if ("" + this.countryCode == "")
|
|
this.countryCode = base.DefaultCountry.Code;
|
|
return this.countryCode;
|
|
}
|
|
set { this.countryCode = value; }
|
|
}
|
|
}
|
|
|
|
public class UptakeGeography : Structure.UptakeGeography
|
|
{
|
|
public UptakeGeography()
|
|
{
|
|
}
|
|
|
|
public UptakeGeography (Structure.UptakeGeography other)
|
|
: base (other)
|
|
{
|
|
}
|
|
|
|
internal static UptakeGeography fromUptake (Structure.UptakeGeography up)
|
|
{
|
|
return new UptakeGeography (up);
|
|
}
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Select, true)]
|
|
#endif
|
|
public static Org[] Select()
|
|
{
|
|
List<Org> res = new List<Org>();
|
|
|
|
Organizations orgs = Organizations.GetAll();
|
|
foreach (Organization org in orgs)
|
|
{
|
|
res.Add (new Org (org));
|
|
}
|
|
|
|
return res.ToArray();
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Select, true)]
|
|
#endif
|
|
public static Org Select (int orgid)
|
|
{
|
|
try
|
|
{
|
|
return new Org (Organization.FromIdentity (orgid));
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Select)]
|
|
#endif
|
|
public static Organization[] Select (int[] OrganizationIds)
|
|
{
|
|
if (OrganizationIds == null)
|
|
{
|
|
return new Organization[0];
|
|
}
|
|
|
|
return Organizations.FromIdentities (OrganizationIds).ToArray();
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Select)]
|
|
#endif
|
|
public static Organization[] SelectStatic (Organization[] OrganizationArray)
|
|
{
|
|
if (OrganizationArray == null)
|
|
{
|
|
return new Organization[0];
|
|
}
|
|
|
|
return OrganizationArray;
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Select)]
|
|
#endif
|
|
public static Organization[] SelectStatic (Organizations Organizations)
|
|
{
|
|
if (Organizations == null)
|
|
{
|
|
return new Organization[0];
|
|
}
|
|
|
|
return Organizations.ToArray();
|
|
}
|
|
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Select)]
|
|
#endif
|
|
public static Organization[] SelectSortedStatic (Organizations Organizations, string sort)
|
|
{
|
|
if (Organizations == null)
|
|
{
|
|
return new Organization[0];
|
|
}
|
|
|
|
|
|
List<Organization> pList = new List<Organization>();
|
|
Organization[] foundOrganizations = SelectStatic (Organizations);
|
|
foreach (Organization pers in foundOrganizations)
|
|
{
|
|
pList.Add (pers);
|
|
}
|
|
|
|
switch (sort)
|
|
{
|
|
case "OrganizationId":
|
|
pList.Sort (IdentityComparison);
|
|
break;
|
|
}
|
|
|
|
return pList.ToArray();
|
|
}
|
|
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Insert, true)]
|
|
#endif
|
|
public int AddOrganization (Org org)
|
|
{
|
|
try
|
|
{
|
|
org.DefaultCountryId = Country.FromCode (org.CountryCode).CountryId;
|
|
}
|
|
catch
|
|
{
|
|
org.DefaultCountryId = FindDefaultCountry (org);
|
|
}
|
|
org.Identity = Organization.Create (org.ParentOrganizationId, org.NameInternational,
|
|
org.Name, org.NameShort, org.Domain, org.MailPrefix, org.AnchorGeographyId, org.AcceptsMembers,
|
|
org.AutoAssignNewMembers, org.DefaultCountryId).Identity;
|
|
// Return true if precisely one row was inserted, otherwise false
|
|
return org.Identity;
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Update, false)]
|
|
#endif
|
|
public int AddDuplicateOrganization (Org org)
|
|
{
|
|
AddOrganization (org);
|
|
return org.Identity;
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Update, true)]
|
|
#endif
|
|
public bool UpdateOrganisation (Org org)
|
|
{
|
|
try
|
|
{
|
|
try
|
|
{
|
|
org.DefaultCountryId = Country.FromCode (org.CountryCode).CountryId;
|
|
}
|
|
catch
|
|
{
|
|
org.DefaultCountryId = FindDefaultCountry (org);
|
|
}
|
|
Organization.UpdateOrganization (org.ParentOrganizationId, org.NameInternational,
|
|
org.Name, org.NameShort, org.Domain, org.MailPrefix, org.AnchorGeographyId, org.AcceptsMembers,
|
|
org.AutoAssignNewMembers, org.DefaultCountryId,
|
|
org.Identity);
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
HttpContext.Current.Response.Write ("Failed Update:" + ex.Message);
|
|
throw new Exception ("UpdateOrganisation failed because:" + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static int FindDefaultCountry (Org org)
|
|
{
|
|
//Find default country = Country of anchor.
|
|
Geographies line = Geography.FromIdentity (org.AnchorGeographyId).GetRootLineage();
|
|
Geography[] arrLine = line.ToArray();
|
|
Array.Reverse (arrLine);
|
|
Countries countries = Countries.All;
|
|
int foundCntry = 1; //sweden
|
|
foreach (Geography geo in arrLine)
|
|
{
|
|
if (geo.Identity == 1)
|
|
return foundCntry; //Didnt find any, we are at world.
|
|
foreach (Country cntry in countries)
|
|
{
|
|
if (geo.Identity == cntry.GeographyId)
|
|
{
|
|
foundCntry = cntry.CountryId;
|
|
return foundCntry;
|
|
}
|
|
}
|
|
}
|
|
return foundCntry; //Didnt find any
|
|
}
|
|
|
|
|
|
public static Comparison<Organization> IdentityComparison =
|
|
delegate (Organization p1, Organization p2) { return p1.OrganizationId.CompareTo (p2.OrganizationId); };
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
private static UptakeGeography[] UptakeFromArray (Structure.UptakeGeography[] inputArray)
|
|
{
|
|
List<UptakeGeography> retlist = new List<UptakeGeography>();
|
|
|
|
foreach (Structure.UptakeGeography up in inputArray)
|
|
{
|
|
retlist.Add (UptakeGeography.fromUptake (up));
|
|
}
|
|
return retlist.ToArray();
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Select, false)]
|
|
#endif
|
|
public static UptakeGeography[] SelectOrgMineUptake (int orgid)
|
|
{
|
|
try
|
|
{
|
|
return UptakeFromArray (Organization.FromIdentity (orgid).GetUptakeGeographies (false));
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Select, false)]
|
|
#endif
|
|
public static UptakeGeography[] SelectOrgOthersUptake (int orgid)
|
|
{
|
|
try
|
|
{
|
|
return UptakeFromArray (Organization.FromIdentity (orgid).GetUptakeGeographies (true));
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Select, false)]
|
|
#endif
|
|
public static UptakeGeography[] SelectOrgOthersUptakeForGeo (int orgid, int geoid)
|
|
{
|
|
try
|
|
{
|
|
List<UptakeGeography> filtered = new List<UptakeGeography>();
|
|
UptakeGeography[] unfiltered =
|
|
UptakeFromArray (Organization.FromIdentity (orgid).GetUptakeGeographies (true));
|
|
foreach (UptakeGeography bu in unfiltered)
|
|
{
|
|
if (bu.GeoId == geoid)
|
|
filtered.Add (bu);
|
|
}
|
|
return filtered.ToArray();
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static void UpdateOrgUptake (int orgid, int[] newUptakeGeos)
|
|
{
|
|
try
|
|
{
|
|
Organization org = Organization.FromIdentity (orgid);
|
|
List<int> inOld = new List<int>();
|
|
foreach (Geography oldGeo in org.UptakeGeographies)
|
|
{
|
|
if (Array.IndexOf (newUptakeGeos, oldGeo.Identity) > -1)
|
|
{
|
|
inOld.Add (oldGeo.Identity);
|
|
}
|
|
else
|
|
{
|
|
org.DeleteUptakeGeography (oldGeo.Identity);
|
|
}
|
|
}
|
|
foreach (int newgeo in newUptakeGeos)
|
|
{
|
|
if (!inOld.Contains (newgeo))
|
|
{
|
|
org.AddUptakeGeography (newgeo);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
}
|
|
}
|
|
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Delete, false)]
|
|
#endif
|
|
public bool DeleteUptake (UptakeGeography ut)
|
|
{
|
|
Organization org = Organization.FromIdentity (ut.OrgId);
|
|
org.DeleteUptakeGeography (ut.GeoId);
|
|
|
|
return true;
|
|
}
|
|
|
|
#if !__MonoCS__
|
|
[DataObjectMethod (DataObjectMethodType.Insert, false)]
|
|
#endif
|
|
public bool AddUptake (UptakeGeography ut)
|
|
{
|
|
Organization org = Organization.FromIdentity (ut.OrgId);
|
|
org.AddUptakeGeography (ut.GeoId);
|
|
|
|
// Return true if precisely one row was inserted, otherwise false
|
|
return true;
|
|
}
|
|
}
|
|
} |