Files
using.cash/Logic/DataObjects/OrganizationDataObject.cs
T
2014-12-05 22:12:51 +01:00

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).GetLine();
Geography[] arrLine = line.ToArray();
Array.Reverse (arrLine);
Countries countries = Countries.GetAll();
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;
}
}
}