/// <summary>
/// Returns the default Location Type for the given PartnerClass
/// </summary>
/// <param name="APartnerClass">PartnerClass.</param>
/// <returns>Default Location Type for the PartnerClass specified with <paramref name="APartnerClass" />.</returns>
public static String GetDefaultLocationType(TPartnerClass APartnerClass)
{
String ReturnValue = "";
// No copying > assign values of columns manually
switch (APartnerClass)
{
case TPartnerClass.PERSON:
case TPartnerClass.FAMILY:
ReturnValue = "HOME";
break;
case TPartnerClass.CHURCH:
ReturnValue = "CHURCH";
break;
case TPartnerClass.ORGANISATION:
case TPartnerClass.BANK:
case TPartnerClass.VENUE:
ReturnValue = "BUSINESS";
break;
case TPartnerClass.UNIT:
ReturnValue = "FIELD";
break;
}
return(ReturnValue);
}
public static string PrintGiftReceipt(
String AGiftCurrency,
String ADonorShortName,
Int64 ADonorKey,
TPartnerClass ADonorClass,
AGiftTable GiftsThisDonor,
string AHTMLTemplateFilename
)
{
TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted);
string HtmlDoc;
try
{
string LocalCountryCode = TAddressTools.GetCountryCodeFromSiteLedger(Transaction);
HtmlDoc = FormatHtmlReceipt(
ADonorShortName,
ADonorKey,
ADonorClass,
AGiftCurrency,
LocalCountryCode,
GiftsThisDonor,
AHTMLTemplateFilename,
Transaction);
}
finally
{
DBAccess.GDBAccessObj.RollbackTransaction();
}
return(HtmlDoc);
}
/// <summary>
/// Updates and immediately saves the UserDefault for the 'Last Partner Used'.
/// </summary>
/// <param name="APartnerKey">Partner Key of the last used Partner</param>
/// <param name="ALastPartnerUse">Specifies which 'Last Partner Used' setting should be
/// updated
/// </param>
/// <param name="APartnerClass">Partner Class of the Partner (default=<see cref="TPartnerClass.FAMILY"/>).
/// Only relevant if <paramref name="ALastPartnerUse"/> is <see cref="TLastPartnerUse.lpuMailroomPartner"/>.</param>
/// <returns>void</returns>
public static void SetLastPartnerWorkedWith(Int64 APartnerKey,
TLastPartnerUse ALastPartnerUse,
TPartnerClass APartnerClass = TPartnerClass.FAMILY)
{
switch (ALastPartnerUse)
{
case TLastPartnerUse.lpuMailroomPartner:
TUserDefaults.SetDefault(TUserDefaults.USERDEFAULT_LASTPARTNERMAILROOM, (object)APartnerKey);
if (APartnerClass == TPartnerClass.PERSON)
{
TUserDefaults.SetDefault(TUserDefaults.USERDEFAULT_LASTPERSONPERSONNEL, (object)APartnerKey);
}
break;
case TLastPartnerUse.lpuPersonnelPerson:
TUserDefaults.SetDefault(TUserDefaults.USERDEFAULT_LASTPERSONPERSONNEL, (object)APartnerKey);
break;
case TLastPartnerUse.lpuPersonnelUnit:
TUserDefaults.SetDefault(TUserDefaults.USERDEFAULT_LASTUNITPERSONNEL, (object)APartnerKey);
break;
case TLastPartnerUse.lpuConferencePerson:
TUserDefaults.SetDefault(TUserDefaults.USERDEFAULT_LASTPERSONCONFERENCE, (object)APartnerKey);
// if partner is person then also set this for personnel module
TUserDefaults.SetDefault(TUserDefaults.USERDEFAULT_LASTPERSONPERSONNEL, (object)APartnerKey);
break;
}
}
public static Boolean VerifyPartner(Int64 APartnerKey,
TPartnerClass[] AValidPartnerClasses,
out bool APartnerExists,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out Boolean AIsMergedPartner)
{
Boolean ReturnValue;
TStdPartnerStatusCode PartnerStatus;
ReturnValue = APartnerExists = MCommonMain.RetrievePartnerShortName(APartnerKey,
out APartnerShortName,
out APartnerClass,
out PartnerStatus);
// TLogging.LogAtLevel(7, "TPartnerServerLookups.VerifyPartner: " + Convert.ToInt32(AValidPartnerClasses.Length));
if (AValidPartnerClasses.Length != 0)
{
if (Array.BinarySearch(AValidPartnerClasses, APartnerClass) < 0)
{
ReturnValue = false;
}
}
if (PartnerStatus == TStdPartnerStatusCode.spscMERGED)
{
AIsMergedPartner = true;
}
else
{
AIsMergedPartner = false;
}
return(ReturnValue);
}
/// <summary>
/// Returns the default Location Type for the given PartnerClass
/// </summary>
/// <param name="APartnerClass">PartnerClass.</param>
/// <returns>Default Location Type for the PartnerClass specified with <paramref name="APartnerClass" />.</returns>
public static String GetDefaultLocationType(TPartnerClass APartnerClass)
{
String ReturnValue = "";
// No copying > assign values of columns manually
switch (APartnerClass)
{
case TPartnerClass.PERSON:
case TPartnerClass.FAMILY:
ReturnValue = "HOME";
break;
case TPartnerClass.CHURCH:
ReturnValue = "CHURCH";
break;
case TPartnerClass.ORGANISATION:
case TPartnerClass.BANK:
case TPartnerClass.VENUE:
ReturnValue = "BUSINESS";
break;
case TPartnerClass.UNIT:
ReturnValue = "FIELD";
break;
}
return ReturnValue;
}
public static bool ActiveGiftDestination(long AFromPartnerKey,
long AToPartnerKey,
TPartnerClass APartnerClass,
out bool AFromGiftDestinationNeedsEnded,
out bool AToGiftDestinationNeedsEnded)
{
bool ReturnValue = true;
bool FromGiftDestinationNeedsEnded = false;
bool ToGiftDestinationNeedsEnded = false;
PPartnerGiftDestinationRow FromGiftDestinationRowNeedsEnded = null;
PPartnerGiftDestinationRow ToGiftDestinationRowNeedsEnded = null;
PPartnerGiftDestinationRow ActiveRow = null;
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.BeginAutoReadTransaction(IsolationLevel.ReadCommitted,
ref Transaction,
delegate
{
// if partners are Person's then find their family keys
if (APartnerClass == TPartnerClass.PERSON)
{
AFromPartnerKey = ((PPersonRow)PPersonAccess.LoadByPrimaryKey(AFromPartnerKey, Transaction).Rows[0]).FamilyKey;
AToPartnerKey = ((PPersonRow)PPersonAccess.LoadByPrimaryKey(AToPartnerKey, Transaction).Rows[0]).FamilyKey;
}
// check for an active gift destination for the 'From' partner
PPartnerGiftDestinationTable GiftDestinations = PPartnerGiftDestinationAccess.LoadViaPPartner(AFromPartnerKey, Transaction);
ActiveRow = GetActiveGiftDestination(GiftDestinations);
// return if no active record has been found
if (ActiveRow == null)
{
ReturnValue = false;
}
else
{
// check for clash with the 'To' partner
PPartnerGiftDestinationTable ToGiftDestinations = PPartnerGiftDestinationAccess.LoadViaPPartner(AToPartnerKey, Transaction);
CheckGiftDestinationClashes(ToGiftDestinations, ActiveRow, out FromGiftDestinationRowNeedsEnded,
out ToGiftDestinationRowNeedsEnded);
if (FromGiftDestinationRowNeedsEnded != null)
{
FromGiftDestinationNeedsEnded = true;
}
if (ToGiftDestinationRowNeedsEnded != null)
{
ToGiftDestinationNeedsEnded = true;
}
}
});
AFromGiftDestinationNeedsEnded = FromGiftDestinationNeedsEnded;
AToGiftDestinationNeedsEnded = ToGiftDestinationNeedsEnded;
return(ReturnValue);
}
public static bool ActiveGiftDestination(long AFromPartnerKey,
long AToPartnerKey,
TPartnerClass APartnerClass,
out bool AFromGiftDestinationNeedsEnded,
out bool AToGiftDestinationNeedsEnded)
{
AFromGiftDestinationNeedsEnded = false;
AToGiftDestinationNeedsEnded = false;
PPartnerGiftDestinationRow FromGiftDestinationRowNeedsEnded = null;
PPartnerGiftDestinationRow ToGiftDestinationRowNeedsEnded = null;
PPartnerGiftDestinationRow ActiveRow = null;
TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
// if partners are Person's then find their family keys
if (APartnerClass == TPartnerClass.PERSON)
{
AFromPartnerKey = ((PPersonRow)PPersonAccess.LoadByPrimaryKey(AFromPartnerKey, Transaction).Rows[0]).FamilyKey;
AToPartnerKey = ((PPersonRow)PPersonAccess.LoadByPrimaryKey(AToPartnerKey, Transaction).Rows[0]).FamilyKey;
}
// check for an active gift destination for the 'From' partner
PPartnerGiftDestinationTable GiftDestinations = PPartnerGiftDestinationAccess.LoadViaPPartner(AFromPartnerKey, Transaction);
ActiveRow = GetActiveGiftDestination(GiftDestinations);
// return if no active record has been found
if (ActiveRow == null)
{
return(false);
}
// check for clash with the 'To' partner
PPartnerGiftDestinationTable ToGiftDestinations = PPartnerGiftDestinationAccess.LoadViaPPartner(AToPartnerKey, Transaction);
CheckGiftDestinationClashes(ToGiftDestinations, ActiveRow, out FromGiftDestinationRowNeedsEnded, out ToGiftDestinationRowNeedsEnded);
if (FromGiftDestinationRowNeedsEnded != null)
{
AFromGiftDestinationNeedsEnded = true;
}
if (ToGiftDestinationRowNeedsEnded != null)
{
AToGiftDestinationNeedsEnded = true;
}
}
catch (Exception e)
{
TLogging.Log(e.ToString());
}
finally
{
DBAccess.GDBAccessObj.RollbackTransaction();
TLogging.LogAtLevel(7, "TMergePartnersWebConnector.GetPartnerBankingDetails: rollback own transaction.");
}
return(true);
}
/// <summary>
/// Constructor that initializes internal fields which can be
/// read out by using the Properties of this Class.
/// </summary>
/// <param name="APartnerKey">PartnerKey of the Partner in the 'Forms Message'.</param>
/// <param name="APartnerClass">Partner Class of the Partner in the 'Forms Message'.</param>
/// <param name="AShortName">ShortName of the Partner in the 'Forms Message'.</param>
/// <param name="APartnerStatus">Status of the Partner in the 'Forms Message'.</param>
public FormsMessagePartner(Int64 APartnerKey,
TPartnerClass APartnerClass,
string AShortName, string APartnerStatus)
{
FPartnerKey = APartnerKey;
FPartnerClass = APartnerClass;
FShortName = AShortName;
FPartnerStatus = APartnerStatus;
}
/// <summary>
/// Creates a new DataRow in the passed PLocation and PPartnerLocation tables.
///
/// </summary>
/// <param name="ALocationDT">Typed PLocation table. If nil is passed in it is created
/// automatically</param>
/// <param name="APartnerLocationDT">Typed PPartnerLocation table. If nil is passed in
/// it is created automatically</param>
/// <param name="APartnerKey">PartneKey of the Partner for which the Address should
/// be created</param>
/// <param name="APartnerClass">PartnerClass of the Partner for which the Address should
/// be created</param>
/// <param name="ACountryCode"></param>
/// <param name="ANewLocationKey">A LocationKey that the new Location and
/// PartnerLocation rows would be set to.</param>
/// <returns>void</returns>
/// <exception cref="ArgumentException"> if any of the Arguments (or their combination) is
/// not valid
/// </exception>
public static void CreateNewAddress(PLocationTable ALocationDT,
PPartnerLocationTable APartnerLocationDT,
Int64 APartnerKey,
TPartnerClass APartnerClass,
String ACountryCode,
Int32 ANewLocationKey)
{
CreateNewAddressInternal(ALocationDT, APartnerLocationDT, APartnerKey, APartnerClass, ACountryCode, ANewLocationKey);
}
/// <summary>
/// Creates a new DataRow in the passed PLocation and PPartnerLocation tables.
///
/// </summary>
/// <param name="ALocationDT">Typed PLocation table. If nil is passed in it is created
/// automatically</param>
/// <param name="APartnerLocationDT">Typed PPartnerLocation table. If nil is passed in
/// it is created automatically</param>
/// <param name="APartnerKey">PartneKey of the Partner for which the Address should
/// be created</param>
/// <param name="APartnerClass">PartnerClass of the Partner for which the Address should
/// be created</param>
/// <param name="ACountryCode"></param>
/// <param name="ANewLocationKey">A LocationKey that the new Location and
/// PartnerLocation rows would be set to.</param>
/// <returns>void</returns>
/// <exception cref="ArgumentException"> if any of the Arguments (or their combination) is
/// not valid
/// </exception>
public static void CreateNewAddress(PLocationTable ALocationDT,
PPartnerLocationTable APartnerLocationDT,
Int64 APartnerKey,
TPartnerClass APartnerClass,
String ACountryCode,
Int32 ANewLocationKey)
{
CreateNewAddressInternal(ALocationDT, APartnerLocationDT, APartnerKey, APartnerClass, ACountryCode, ANewLocationKey);
}
/// <summary>
/// Used for passing parameters to the screen before it is actually shown.
/// </summary>
/// <param name="AMergedPartnerPartnerKey">PartnerKey of the Merged Partner.</param>
/// <param name="AMergedPartnerPartnerShortName">Shortname of the Merged Partner.</param>
/// <param name="AMergedPartnerPartnerClass">PartnerClass of the Merged Partner.</param>
public void SetParameters(Int64 AMergedPartnerPartnerKey,
String AMergedPartnerPartnerShortName,
TPartnerClass AMergedPartnerPartnerClass)
{
FMergedPartnerPartnerKey = AMergedPartnerPartnerKey;
FMergedPartnerPartnerShortName = AMergedPartnerPartnerShortName;
FMergedPartnerPartnerClass = AMergedPartnerPartnerClass;
FMergedIntoPartnerKey = -1;
}
public static bool AddRecentlyUsedPartner(Int64 APartnerKey, TPartnerClass APartnerClass,
Boolean ANewPartner, TLastPartnerUse ALastPartnerUse)
{
bool ResultValue = false;
ResultValue = Server.MPartner.Partner.TRecentPartnersHandling.AddRecentlyUsedPartner
(APartnerKey, APartnerClass, ANewPartner, ALastPartnerUse);
return ResultValue;
}
/**
* Gets the ShortName of a Partner.
*
* @param APartnerKey PartnerKey of Partner to find the short name for
* @param APartnerShortName ShortName for the found Partner ('' if Partner
* doesn't exist or PartnerKey is 0)
* @param APartnerClass Partner Class of the found Partner (FAMILY if Partner
* doesn't exist or PartnerKey is 0)
* @param APartnerStatus Partner Status for the found Partner (spscINACTIVE if Partner
* doesn't exist or PartnerKey is 0)
* @param AMergedPartners Set to false if the function should return 'false' if
* the Partner' Partner Status is MERGED
* @return true if Partner was found in DB (except if AMergedPartners is false
* and Partner is MERGED) or PartnerKey is 0, otherwise false
* // future public static methods for MFinance go here...
*/
public static Boolean GetPartnerShortName(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
Boolean AMergedPartners)
{
return(TRemote.MPartner.Partner.ServerLookups.WebConnectors.GetPartnerShortName(APartnerKey,
out APartnerShortName,
out APartnerClass,
AMergedPartners));
}
/// <summary>
/// Verifies the existence of a Partner.
/// </summary>
/// <param name="APartnerKey">PartnerKey of Partner to find the short name for</param>
/// <param name="APartnerShortName">ShortName for the found Partner ('' if Partner
/// doesn't exist or PartnerKey is 0)</param>
/// <param name="APartnerClass">Partner Class of the found Partner (FAMILY if Partner
/// doesn't exist or PartnerKey is 0)</param>
/// <param name="AIsMergedPartner">true if the Partner' Partner Status is MERGED,
/// otherwise false</param>
/// <param name="AUserCanAccessPartner">true if the current user has the rights to
/// edit this partner</param>
/// <returns>true if Partner was found in DB (except if AValidPartnerClasses isn't
/// an empty Set and the found Partner isn't of a PartnerClass that is in the
/// Set) or PartnerKey is 0, otherwise false</returns>
public static Boolean VerifyPartner(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out Boolean AIsMergedPartner,
out Boolean AUserCanAccessPartner)
{
return(TRemote.MPartner.Partner.ServerLookups.WebConnectors.VerifyPartnerAndGetDetails(APartnerKey,
out APartnerShortName,
out APartnerClass,
out AIsMergedPartner,
out AUserCanAccessPartner));
}
/// <summary>
/// Retrieves the Partner ShortName, the PartnerClass and PartnerStatus.
/// </summary>
/// <param name="APartnerKey">PartnerKey to identify the Partner.</param>
/// <param name="APartnerShortName">Returns the ShortName.</param>
/// <param name="APartnerClass">Returns the PartnerClass (FAMILY, ORGANISATION, etc).</param>
/// <param name="APartnerStatus">Returns the PartnerStatus (eg. ACTIVE, DIED).</param>
/// <returns>True if partner was found, otherwise false.</returns>
public static Boolean RetrievePartnerShortName(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out TStdPartnerStatusCode APartnerStatus)
{
bool NewTransaction = false;
bool Result = false;
TDBTransaction ReadTransaction;
TPartnerClass tmpPartnerClass = new TPartnerClass();
TStdPartnerStatusCode tmpPartnerStatus = new TStdPartnerStatusCode();
string tmpPartnerShortName = "";
if (APartnerKey != 0)
{
try
{
ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
out NewTransaction);
Result = RetrievePartnerShortName(APartnerKey,
out tmpPartnerShortName,
out tmpPartnerClass,
out tmpPartnerStatus,
ReadTransaction);
if (NewTransaction)
{
DBAccess.GDBAccessObj.CommitTransaction();
TLogging.LogAtLevel(7, "RetrievePartnerShortName: committed own transaction.");
}
}
catch (Exception)
{
TLogging.Log(String.Format("Problem retrieveing partner short name for Partner {0}", APartnerKey));
TLogging.LogStackTrace(TLoggingType.ToLogfile);
}
}
else
{
APartnerClass = new TPartnerClass();
Result = true; //partner key key 0 should be valid
}
APartnerShortName = tmpPartnerShortName;
APartnerClass = tmpPartnerClass;
APartnerStatus = tmpPartnerStatus;
return Result;
}
/// <summary>
/// Retrieves the Partner ShortName, the PartnerClass and PartnerStatus.
/// </summary>
/// <param name="APartnerKey">PartnerKey to identify the Partner.</param>
/// <param name="APartnerShortName">Returns the ShortName.</param>
/// <param name="APartnerClass">Returns the PartnerClass (FAMILY, ORGANISATION, etc).</param>
/// <param name="APartnerStatus">Returns the PartnerStatus (eg. ACTIVE, DIED).</param>
/// <returns>True if partner was found, otherwise false.</returns>
public static Boolean RetrievePartnerShortName(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out TStdPartnerStatusCode APartnerStatus)
{
bool NewTransaction = false;
bool Result = false;
TDBTransaction ReadTransaction;
TPartnerClass tmpPartnerClass = new TPartnerClass();
TStdPartnerStatusCode tmpPartnerStatus = new TStdPartnerStatusCode();
string tmpPartnerShortName = "";
if (APartnerKey != 0)
{
try
{
ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
out NewTransaction);
Result = RetrievePartnerShortName(APartnerKey,
out tmpPartnerShortName,
out tmpPartnerClass,
out tmpPartnerStatus,
ReadTransaction);
if (NewTransaction)
{
DBAccess.GDBAccessObj.CommitTransaction();
TLogging.LogAtLevel(7, "RetrievePartnerShortName: committed own transaction.");
}
}
catch (Exception)
{
TLogging.Log(String.Format("Problem retrieveing partner short name for Partner {0}", APartnerKey));
TLogging.LogStackTrace(TLoggingType.ToLogfile);
}
}
else
{
APartnerClass = new TPartnerClass();
Result = true; //partner key key 0 should be valid
}
APartnerShortName = tmpPartnerShortName;
APartnerClass = tmpPartnerClass;
APartnerStatus = tmpPartnerStatus;
return(Result);
}
/// <summary>
/// Verifies the existence of a Partner.
/// </summary>
/// <param name="APartnerKey">PartnerKey of Partner to find the short name for</param>
/// <param name="AValidPartnerClasses">Pass in a Set of valid PartnerClasses that the
/// Partner is allowed to have (eg. [PERSON, FAMILY], or an empty Set ( [] ).</param>
/// <param name="APartnerExists">True if the Partner exists in the database or if PartnerKey is 0.</param>
/// <param name="APartnerShortName">ShortName for the found Partner ('' if Partner
/// doesn't exist or PartnerKey is 0)</param>
/// <param name="APartnerClass">Partner Class of the found Partner (FAMILY if Partner
/// doesn't exist or PartnerKey is 0)</param>
/// <param name="AIsMergedPartner">true if the Partner' Partner Status is MERGED,
/// otherwise false</param>
/// <returns>true if Partner was found in DB (except if AValidPartnerClasses isn't
/// an empty Set and the found Partner isn't of a PartnerClass that is in the
/// Set) or PartnerKey is 0, otherwise false</returns>
public static bool VerifyPartner(Int64 APartnerKey, TPartnerClass[] AValidPartnerClasses, out bool APartnerExists,
out String APartnerShortName, out TPartnerClass APartnerClass, out Boolean AIsMergedPartner)
{
if (FDelegateVerifyPartner != null)
{
return FDelegateVerifyPartner(APartnerKey, AValidPartnerClasses, out APartnerExists, out APartnerShortName,
out APartnerClass, out AIsMergedPartner);
}
else
{
throw new InvalidOperationException("Delegate 'TVerifyPartner' must be initialised before calling this Method");
}
}
/// <summary>
/// Verifies the existence of a Partner.
/// </summary>
/// <param name="APartnerKey">PartnerKey of Partner to find the short name for</param>
/// <param name="AValidPartnerClasses">Pass in a Set of valid PartnerClasses that the
/// Partner is allowed to have (eg. [PERSON, FAMILY], or an empty Set ( [] ).</param>
/// <param name="APartnerExists">True if the Partner exists in the database or if PartnerKey is 0.</param>
/// <param name="APartnerShortName">ShortName for the found Partner ('' if Partner
/// doesn't exist or PartnerKey is 0)</param>
/// <param name="APartnerClass">Partner Class of the found Partner (FAMILY if Partner
/// doesn't exist or PartnerKey is 0)</param>
/// <param name="APartnerStatus">Partner Status</param>
/// <returns>true if Partner was found in DB (except if AValidPartnerClasses isn't
/// an empty Set and the found Partner isn't of a PartnerClass that is in the
/// Set) or PartnerKey is 0, otherwise false</returns>
public static bool VerifyPartner(Int64 APartnerKey, TPartnerClass[] AValidPartnerClasses, out bool APartnerExists,
out String APartnerShortName, out TPartnerClass APartnerClass, out TStdPartnerStatusCode APartnerStatus)
{
if (FDelegateVerifyPartner != null)
{
return(FDelegateVerifyPartner(APartnerKey, AValidPartnerClasses, out APartnerExists, out APartnerShortName,
out APartnerClass, out APartnerStatus));
}
else
{
throw new InvalidOperationException("Delegate 'TVerifyPartner' must be initialised before calling this Method");
}
}
/// <summary>
/// Retrieves the Partner ShortName, the PartnerClass and PartnerStatus.
/// </summary>
/// <param name="APartnerKey">PartnerKey to identify the Partner.</param>
/// <param name="APartnerShortName">Returns the ShortName.</param>
/// <param name="APartnerClass">Returns the PartnerClass (FAMILY, ORGANISATION, etc).</param>
/// <param name="APartnerStatus">Returns the PartnerStatus (eg. ACTIVE, DIED).</param>
/// <param name="ATransaction">Open DB Transaction.</param>
/// <returns>True if partner was found, otherwise false.</returns>
public static Boolean RetrievePartnerShortName(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out TStdPartnerStatusCode APartnerStatus,
TDBTransaction ATransaction)
{
Boolean ReturnValue;
StringCollection RequiredColumns;
PPartnerTable PartnerTable;
// initialise out Arguments
APartnerShortName = "";
// Default. This is not really correct but the best compromise if PartnerKey is 0 or Partner isn't found since we have an enum here.
APartnerClass = TPartnerClass.FAMILY;
// Default. This is not really correct but the best compromise if PartnerKey is 0 or Partner isn't found since we have an enum here.
APartnerStatus = TStdPartnerStatusCode.spscINACTIVE;
if (APartnerKey != 0)
{
// only some fields are needed
RequiredColumns = new StringCollection();
RequiredColumns.Add(PPartnerTable.GetPartnerShortNameDBName());
RequiredColumns.Add(PPartnerTable.GetPartnerClassDBName());
RequiredColumns.Add(PPartnerTable.GetStatusCodeDBName());
PartnerTable = PPartnerAccess.LoadByPrimaryKey(APartnerKey, RequiredColumns, ATransaction, null, 0, 0);
if (PartnerTable.Rows.Count == 0)
{
ReturnValue = false;
}
else
{
// since we loaded by primary key there must just be one partner row
APartnerShortName = PartnerTable[0].PartnerShortName;
APartnerClass = SharedTypes.PartnerClassStringToEnum(PartnerTable[0].PartnerClass);
APartnerStatus = SharedTypes.StdPartnerStatusCodeStringToEnum(PartnerTable[0].StatusCode);
ReturnValue = true;
}
}
else
{
// Return result as valid if Partner Key is 0.
ReturnValue = true;
}
return(ReturnValue);
}
/// <summary>
/// mark the selected partner record as the one last worked with in the application
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void SetPartnerLastWorkedWith(System.Object sender, EventArgs e)
{
ExtractTDSMExtractRow SelectedRow = GetSelectedDetailRow();
TPartnerClass SelectedPartnersPartnerClass = SharedTypes.PartnerClassStringToEnum(SelectedRow.PartnerClass);
if (SelectedRow != null)
{
TUserDefaults.NamedDefaults.SetLastPartnerWorkedWith(SelectedRow.PartnerKey,
TLastPartnerUse.lpuMailroomPartner, SelectedPartnersPartnerClass);
TRemote.MPartner.Partner.WebConnectors.AddRecentlyUsedPartner
(SelectedRow.PartnerKey, SelectedPartnersPartnerClass, false, TLastPartnerUse.lpuMailroomPartner);
}
}
/// <summary>
/// Verifies the existence of a Partner.
/// </summary>
/// <param name="APartnerKey">PartnerKey of Partner to find the short name for</param>
/// <param name="AValidPartnerClasses">Pass in a Set of valid PartnerClasses that the
/// Partner is allowed to have (eg. [PERSON, FAMILY], or an empty Set ( [] ).</param>
/// <param name="APartnerExists">True if the Partner exists in the database or if PartnerKey is 0.</param>
/// <param name="APartnerShortName">ShortName for the found Partner ('' if Partner
/// doesn't exist or PartnerKey is 0)</param>
/// <param name="APartnerClass">Partner Class of the found Partner (FAMILY if Partner
/// doesn't exist or PartnerKey is 0)</param>
/// <param name="AIsMergedPartner">true if the Partner' Partner Status is MERGED,
/// otherwise false</param>
/// <returns>true if Partner was found in DB (except if AValidPartnerClasses isn't
/// an empty Set and the found Partner isn't of a PartnerClass that is in the
/// Set) or PartnerKey is 0, otherwise false</returns>
public static Boolean VerifyPartner(Int64 APartnerKey,
TPartnerClass[] AValidPartnerClasses,
out bool APartnerExists,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out Boolean AIsMergedPartner)
{
return(TRemote.MPartner.Partner.ServerLookups.WebConnectors.VerifyPartner(APartnerKey,
AValidPartnerClasses,
out APartnerExists,
out APartnerShortName,
out APartnerClass,
out AIsMergedPartner));
}
/// <summary>
/// Sets the Data for the Form
/// </summary>
/// <param name="GridRows">Grid Information</param>
public void SetFormData(DataRowView[] GridRows)
{
DataRowView Row = GridRows[0];
FPartnerClass = Ict.Petra.Shared.SharedTypes.PartnerClassStringToEnum(Row[0].ToString());
FFormData.ShortName = Row[1].ToString();
FFormData.City = Row[2].ToString();
FFormData.PostalCode = Row[3].ToString();
FFormData.Address1 = Row[4].ToString();
FFormData.AddressStreet2 = Row[5].ToString();
FFormData.Address3 = Row[6].ToString();
FFormData.County = Row[7].ToString();
FFormData.CountryCode = Row[8].ToString();
FFormData.PartnerKey = Row[9].ToString();
}
/// <summary>
/// convert partner class from enum to string
/// </summary>
/// <param name="APartnerClass"></param>
/// <returns></returns>
public static String PartnerClassEnumToString(TPartnerClass APartnerClass)
{
switch (APartnerClass)
{
case TPartnerClass.PERSON:
case TPartnerClass.FAMILY:
case TPartnerClass.CHURCH:
case TPartnerClass.ORGANISATION:
case TPartnerClass.BANK:
case TPartnerClass.UNIT:
case TPartnerClass.VENUE:
return(APartnerClass.ToString());
}
return("##UNCONVERTABLE##");
}
/// <summary>
/// Determines whether DataLabels exist for a specified Partner Class.
/// </summary>
/// <param name="APartnerClass">Partner Class that should be checked for.</param>
/// <param name="ACacheableDataLabelsForPartnerClassesList">Instance of the Cacheable DataTable 'DataLabelsForPartnerClassesList'
/// that has data in it (ie. the Cacheable DataTable must have been retrieved by the caller).</param>
/// <returns>True if at least one DataLabel exists for the Partner Class specified in <paramref name="APartnerClass"></paramref>,
/// otherwise false.</returns>
public static bool HasPartnerClassLocalPartnerDataLabels(TPartnerClass APartnerClass, DataTable ACacheableDataLabelsForPartnerClassesList)
{
bool ReturnValue = false;
DataRow[] PartnerClassDR =
ACacheableDataLabelsForPartnerClassesList.Select("PartnerClass = '" + SharedTypes.PartnerClassEnumToString(APartnerClass) + "'");
if (PartnerClassDR.Length > 0)
{
if (Convert.ToBoolean(PartnerClassDR[0]["DataLabelsAvailable"]) == true)
{
ReturnValue = true;
}
}
return(ReturnValue);
}
public static Boolean GetPartnerShortName(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
Boolean AMergedPartners)
{
Boolean ReturnValue;
TStdPartnerStatusCode PartnerStatus;
ReturnValue = MCommonMain.RetrievePartnerShortName(APartnerKey, out APartnerShortName, out APartnerClass, out PartnerStatus);
if (((!AMergedPartners)) && (PartnerStatus == TStdPartnerStatusCode.spscMERGED))
{
ReturnValue = false;
}
return ReturnValue;
}
public static Boolean GetPartnerShortName(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
Boolean AMergedPartners)
{
Boolean ReturnValue;
TStdPartnerStatusCode PartnerStatus;
ReturnValue = MCommonMain.RetrievePartnerShortName(APartnerKey, out APartnerShortName, out APartnerClass, out PartnerStatus);
if (((!AMergedPartners)) && (PartnerStatus == TStdPartnerStatusCode.spscMERGED))
{
ReturnValue = false;
}
return(ReturnValue);
}
/// <summary>
/// Used for passing parameters to the screen before it is actually shown.
/// </summary>
/// <param name="AMergedPartnerPartnerKey">PartnerKey of the Merged Partner.</param>
/// <param name="AMergedPartnerPartnerShortName">ShortName of the Merged Partner.</param>
/// <param name="AMergedPartnerPartnerClass">PartnerClass of the Merged Partner.</param>
/// <param name="AMergedIntoPartnerKey">PartnerKey of the Partner that the Merged Partner got merged into.</param>
/// <param name="AMergedIntoPartnerShortName">ShortName of the Partner that the Merged Partner got merged into.</param>
/// <param name="AMergedIntoPartnerClass">PartnerClass of the Partner that the Merged Partner got merged into.</param>
/// <param name="AMergedBy">The user that merged the two Partners.</param>
/// <param name="AMergeDate">Date on which the two Partners were merged.</param>
public void SetParameters(Int64 AMergedPartnerPartnerKey,
String AMergedPartnerPartnerShortName,
TPartnerClass AMergedPartnerPartnerClass,
Int64 AMergedIntoPartnerKey,
String AMergedIntoPartnerShortName,
TPartnerClass AMergedIntoPartnerClass,
String AMergedBy,
DateTime AMergeDate)
{
FMergedPartnerPartnerKey = AMergedPartnerPartnerKey;
FMergedPartnerPartnerShortName = AMergedPartnerPartnerShortName;
FMergedPartnerPartnerClass = AMergedPartnerPartnerClass;
FMergedIntoPartnerKey = AMergedIntoPartnerKey;
FMergedIntoPartnerShortName = AMergedIntoPartnerShortName;
FMergedIntoPartnerClass = AMergedIntoPartnerClass;
FMergedBy = AMergedBy;
FMergeDate = AMergeDate;
}
public static String BuildAddressBlock(TFormDataPartner AFormData,
String AAddressLayoutCode,
TPartnerClass APartnerClass,
TDBTransaction ATransaction)
{
PAddressBlockTable AddressBlockTable;
String AddressLayoutBlock = "";
if ((AAddressLayoutCode == null) ||
(AAddressLayoutCode == ""))
{
// this should not happen but just in case we use SMLLABEL as default layout code
AddressBlockTable = PAddressBlockAccess.LoadByPrimaryKey(AFormData.CountryCode, "SMLLABEL", ATransaction);
if (AddressBlockTable.Count == 0)
{
// if no address block layout could be found for given country then try to retrieve for default "99"
AddressBlockTable = PAddressBlockAccess.LoadByPrimaryKey("99", "SMLLABEL", ATransaction);
}
}
else
{
AddressBlockTable = PAddressBlockAccess.LoadByPrimaryKey(AFormData.CountryCode, AAddressLayoutCode, ATransaction);
if (AddressBlockTable.Count == 0)
{
// if no address block layout could be found for given country then try to retrieve for default "99"
AddressBlockTable = PAddressBlockAccess.LoadByPrimaryKey("99", AAddressLayoutCode, ATransaction);
}
}
if (AddressBlockTable.Count == 0)
{
return("");
}
else
{
PAddressBlockRow AddressBlockRow = (PAddressBlockRow)AddressBlockTable.Rows[0];
AddressLayoutBlock = AddressBlockRow.AddressBlockText;
}
return(BuildAddressBlock(AddressLayoutBlock, AFormData, APartnerClass, ATransaction));
}
/// <summary>
/// Returns information about a Partner that was Merged and about the
/// Partner it was merged into.
/// </summary>
/// <param name="AMergedPartnerPartnerKey">PartnerKey of Merged Partner.</param>
/// <param name="AMergedPartnerPartnerShortName">ShortName of Merged Partner.</param>
/// <param name="AMergedPartnerPartnerClass">Partner Class of Merged Partner.</param>
/// <param name="AMergedIntoPartnerKey">PartnerKey of Merged-Into Partner. (Only
/// populated if that information is available.)</param>
/// <param name="AMergedIntoPartnerShortName">ShortName of Merged-Into Partner. (Only
/// populated if that information is available.)</param>
/// <param name="AMergedIntoPartnerClass">PartnerClass of Merged-Into Partner. (Only
/// populated if that information is available.)</param>
/// <param name="AMergedBy">User who performed the Partner Merge operation. (Only
/// populated if that information is available.)</param>
/// <param name="AMergeDate">Date on which the Partner Merge operation was done. (Only
/// populated if that information is available.)</param>
/// <returns>True if (1) Merged Partner exists and (2) its Status is MERGED,
/// otherwise false.</returns>
public static Boolean MergedPartnerDetails(Int64 AMergedPartnerPartnerKey,
out String AMergedPartnerPartnerShortName,
out TPartnerClass AMergedPartnerPartnerClass,
out Int64 AMergedIntoPartnerKey,
out String AMergedIntoPartnerShortName,
out TPartnerClass AMergedIntoPartnerClass,
out String AMergedBy,
out DateTime AMergeDate)
{
return(TRemote.MPartner.Partner.ServerLookups.WebConnectors.MergedPartnerDetails(
AMergedPartnerPartnerKey,
out AMergedPartnerPartnerShortName,
out AMergedPartnerPartnerClass,
out AMergedIntoPartnerKey,
out AMergedIntoPartnerShortName,
out AMergedIntoPartnerClass,
out AMergedBy,
out AMergeDate));
}
/// <summary>
/// Get short name for a partner. Boolean returns result if partner was found.
///
/// @Comment Calling this function should soon be no longer necessary since it
/// can be replaced with a call to Ict.Petra.Client.App.Core.ServerLookups!
///
/// </summary>
/// <param name="APartnerKey">PartnerKey to find the short name for</param>
/// <param name="APartnerShortName">short name found for partner key</param>
/// <param name="APartnerClass">Partner Class for partner that was found</param>
/// <returns>true if Partner was found in DB, otherwise false
/// </returns>
public Boolean GetPartnerShortName(Int64 APartnerKey, out String APartnerShortName, out TPartnerClass APartnerClass)
{
TStdPartnerStatusCode PartnerStatus;
String PartnerShortName = String.Empty;
TPartnerClass PartnerClass = TPartnerClass.FAMILY;
TDBTransaction ReadTransaction = new TDBTransaction();
bool Result = false;
DBAccess.ReadTransaction(
ref ReadTransaction,
delegate
{
Result = MCommonMain.RetrievePartnerShortName(APartnerKey, out PartnerShortName, out PartnerClass, out PartnerStatus, ReadTransaction);
});
APartnerShortName = PartnerShortName;
APartnerClass = PartnerClass;
return(Result);
}
/// <summary>
/// Allows setting of Partner Data for 'Form Messages' of MessageClass
/// <see cref="TFormsMessageClassEnum.mcNewPartnerSaved"></see>,
/// <see cref="TFormsMessageClassEnum.mcExistingPartnerSaved"></see>,
/// <see cref="TFormsMessageClassEnum.mcFamilyMembersChanged"></see>,
/// <see cref="TFormsMessageClassEnum.mcPartnerDeleted"></see> and
/// <see cref="TFormsMessageClassEnum.mcPersonnelCommitmentChanged"></see>.
/// </summary>
/// <param name="APartnerKey">PartnerKey of the Partner in the 'Forms Message'.</param>
/// <param name="APartnerClass">Partner Class of the Partner in the 'Forms Message'.</param>
/// <param name="AShortName">ShortName of the Partner in the 'Forms Message'.</param>
/// <param name="APartnerStatus">Status of the Partner in the 'Forms Message'.</param>
public void SetMessageDataPartner(Int64 APartnerKey,
TPartnerClass APartnerClass, string AShortName, string APartnerStatus)
{
switch (FMessageClass)
{
case TFormsMessageClassEnum.mcNewPartnerSaved:
case TFormsMessageClassEnum.mcExistingPartnerSaved:
case TFormsMessageClassEnum.mcFamilyMembersChanged:
case TFormsMessageClassEnum.mcPartnerDeleted:
case TFormsMessageClassEnum.mcPersonnelCommitmentChanged:
FMessageObject = new FormsMessagePartner(APartnerKey,
APartnerClass, AShortName, APartnerStatus);
break;
default:
throw new ApplicationException(
"Method 'SetMessageDataPartner' must not be called for MessageClass '" +
Enum.GetName(typeof(TFormsMessageClassEnum), FMessageClass) + "'");
}
}
/// <summary>
/// Retrieves the Partner ShortName, the PartnerClass and PartnerStatus.
/// </summary>
/// <param name="APartnerKey">PartnerKey to identify the Partner.</param>
/// <param name="APartnerShortName">Returns the ShortName.</param>
/// <param name="APartnerClass">Returns the PartnerClass (FAMILY, ORGANISATION, etc).</param>
/// <param name="APartnerStatus">Returns the PartnerStatus (eg. ACTIVE, DIED).</param>
/// <returns>True if partner was found, otherwise false.</returns>
public static Boolean RetrievePartnerShortName(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out TStdPartnerStatusCode APartnerStatus)
{
bool Result = false;
TPartnerClass tmpPartnerClass = new TPartnerClass();
TStdPartnerStatusCode tmpPartnerStatus = new TStdPartnerStatusCode();
string tmpPartnerShortName = "";
if (APartnerKey != 0)
{
TDBTransaction ReadTransaction = null;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref ReadTransaction,
delegate
{
Result = RetrievePartnerShortName(APartnerKey,
out tmpPartnerShortName,
out tmpPartnerClass,
out tmpPartnerStatus,
ReadTransaction);
});
}
else
{
APartnerClass = new TPartnerClass();
Result = true; //partner key key 0 should be valid
}
APartnerShortName = tmpPartnerShortName;
APartnerClass = tmpPartnerClass;
APartnerStatus = tmpPartnerStatus;
return(Result);
}
/// <summary>
/// Retrieves the Partner ShortName, the PartnerClass and PartnerStatus.
/// </summary>
/// <param name="APartnerKey">PartnerKey to identify the Partner.</param>
/// <param name="APartnerShortName">Returns the ShortName.</param>
/// <param name="APartnerClass">Returns the PartnerClass (FAMILY, ORGANISATION, etc).</param>
/// <param name="APartnerStatus">Returns the PartnerStatus (eg. ACTIVE, DIED).</param>
/// <returns>True if partner was found, otherwise false.</returns>
public static Boolean RetrievePartnerShortName(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out TStdPartnerStatusCode APartnerStatus)
{
bool Result = false;
TPartnerClass tmpPartnerClass = new TPartnerClass();
TStdPartnerStatusCode tmpPartnerStatus = new TStdPartnerStatusCode();
string tmpPartnerShortName = "";
if (APartnerKey != 0)
{
TDBTransaction ReadTransaction = null;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref ReadTransaction,
delegate
{
Result = RetrievePartnerShortName(APartnerKey,
out tmpPartnerShortName,
out tmpPartnerClass,
out tmpPartnerStatus,
ReadTransaction);
});
}
else
{
APartnerClass = new TPartnerClass();
Result = true; //partner key key 0 should be valid
}
APartnerShortName = tmpPartnerShortName;
APartnerClass = tmpPartnerClass;
APartnerStatus = tmpPartnerStatus;
return Result;
}
/// <summary>
/// Returns the default Addressee Type for the given PartnerClass.
/// </summary>
/// <param name="APartnerClass">PartnerClass.</param>
/// <returns>Default Addressee Type for the PartnerClass specified with <paramref name="APartnerClass" />.</returns>
public static String GetDefaultAddresseeType(TPartnerClass APartnerClass)
{
switch (APartnerClass)
{
case TPartnerClass.PERSON:
case TPartnerClass.FAMILY:
return("FAMILY");
case TPartnerClass.CHURCH:
return("CHURCH");
case TPartnerClass.ORGANISATION:
case TPartnerClass.BANK:
case TPartnerClass.UNIT:
return("ORGANISA");
case TPartnerClass.VENUE:
return("VENUE");
}
return("");
}
/// <summary>
/// Returns the default Addressee Type for the given PartnerClass.
/// </summary>
/// <param name="APartnerClass">PartnerClass.</param>
/// <returns>Default Addressee Type for the PartnerClass specified with <paramref name="APartnerClass" />.</returns>
public static String GetDefaultAddresseeType(TPartnerClass APartnerClass)
{
switch (APartnerClass)
{
case TPartnerClass.PERSON:
case TPartnerClass.FAMILY:
return "FAMILY";
case TPartnerClass.CHURCH:
return "CHURCH";
case TPartnerClass.ORGANISATION:
case TPartnerClass.BANK:
case TPartnerClass.UNIT:
return "ORGANISA";
case TPartnerClass.VENUE:
return "VENUE";
}
return "";
}
/// <summary>
/// Creates a new DataRow in the passed PLocation and PPartnerLocation tables.
/// </summary>
/// <param name="ALocationDT">Typed PLocation table. If null is passed in it is created
/// automatically</param>
/// <param name="APartnerLocationDT">Typed PPartnerLocation table. If null is passed in
/// it is created automatically</param>
/// <param name="APartnerKey">PartneKey of the Partner for which the Address should
/// be created</param>
/// <param name="APartnerClass">PartnerClass of the Partner for which the Address should
/// be created</param>
/// <param name="ACountryCode"></param>
/// <param name="ANewLocationKey">A LocationKey that the new Location and
/// PartnerLocation rows would be set to.</param>
/// <param name="ACopyFromFamilyPartnerKey">Pass in the PartnerKey of a Family Partner
/// to copy over all data from the Family's Address. Note: the DataRow
/// specified with ACopyFromFamilyPartnerKey must be present in the
/// APartnerLocationDT table!</param>
/// <param name="ACopyFromFamilyLocationKey">Pass in the LocationKey of the Family
/// Partner specified in ACopyFromFamilyPartnerKey to copy over all data from
/// the Family's Address. Note: the DataRow specified with
/// ACopyFromFamilyLocationKey must be present in both the ALocationDT and
/// APartnerLocationDT table!</param>
/// <param name="ACopyFromFamilySiteKey">A SiteKey to find the location that should be the source of the copy</param>
/// <param name="ACopyFromFamilyOnlyLocation"></param>
/// <param name="ADeleteDataRowCopiedFrom"></param>
/// <exception cref="ArgumentException"> if any of the Arguments (or their combination) is
/// not valid.</exception>
public static void CreateNewAddress(PLocationTable ALocationDT,
PPartnerLocationTable APartnerLocationDT,
Int64 APartnerKey,
TPartnerClass APartnerClass,
String ACountryCode,
Int32 ANewLocationKey,
Int64 ACopyFromFamilyPartnerKey,
Int32 ACopyFromFamilyLocationKey,
Int64 ACopyFromFamilySiteKey,
Boolean ACopyFromFamilyOnlyLocation,
Boolean ADeleteDataRowCopiedFrom)
{
CreateNewAddressInternal(ALocationDT,
APartnerLocationDT,
APartnerKey,
APartnerClass,
ACountryCode,
ANewLocationKey,
ACopyFromFamilyPartnerKey,
ACopyFromFamilyLocationKey,
ACopyFromFamilySiteKey,
ACopyFromFamilyOnlyLocation,
ADeleteDataRowCopiedFrom);
}
/// <summary>
/// Passes data as a Typed DataSet to the Partner Edit Screen, containing multiple
/// DataTables. The DataSets tables are with default data for a new Partner.
///
/// </summary>
/// <param name="ASiteKey">SiteKey for which the Partner should be created (optional)</param>
/// <param name="APartnerKey">PartnerKey that the Partner should have (optional)</param>
/// <param name="APartnerClass">PartnerClass that the Partner should have (optional)</param>
/// <param name="ADesiredCountryCode">Country Code that the Partner's first address should have
/// (if <> '', this overrides the Country Code that would be found out from the
/// Site Key)</param>
/// <param name="AAcquisitionCode">AcquisitionCode that the Partner should have (optional)</param>
/// <param name="APrivatePartner">Set to true if this should become a Private Partner
/// of the current user</param>
/// <param name="AFamilyPartnerKey">PartnerKey of the Family (only needed if new Partner is of
/// Partner Class PERSON)</param>
/// <param name="AFamilySiteKey"></param>
/// <param name="AFamilyLocationKey">LocationKey of the selected Location of the Family
/// (only needed if new Partner is of Partner Class PERSON)
/// </param>
/// <param name="ASiteCountryCode"></param>
/// <returns>void</returns>
public PartnerEditTDS GetDataNewPartner(System.Int64 ASiteKey,
System.Int64 APartnerKey,
TPartnerClass APartnerClass,
String ADesiredCountryCode,
String AAcquisitionCode,
Boolean APrivatePartner,
Int64 AFamilyPartnerKey,
Int64 AFamilySiteKey,
Int32 AFamilyLocationKey,
out String ASiteCountryCode)
{
TDBTransaction ReadTransaction;
PPartnerRow PartnerRow;
PartnerEditTDSPPersonRow PersonRow;
PartnerEditTDSPFamilyRow FamilyRow;
PChurchRow ChurchRow;
POrganisationRow OrganisationRow;
PBankRow BankRow;
PUnitRow UnitRow;
PVenueRow VenueRow;
PPartnerRelationshipRow PartnerRelationshipRow;
PartnerEditTDSMiscellaneousDataTable MiscellaneousDataDT;
PartnerEditTDSMiscellaneousDataRow MiscellaneousDataDR;
PPartnerTable PersonFamilyPartnerDT;
PLocationTable SiteLocationDT;
StringCollection SiteLocationRequiredColumns;
DateTime CreationDate;
String CreationUserID;
String GiftReceiptingDefaults;
String ReceiptLetterFrequency;
String LanguageCode;
String[] GiftReceiptingDefaultsSplit;
Boolean ReceiptEachGift;
TPartnerFamilyIDHandling FamilyIDHandling;
int FamilyID;
String ProblemMessage;
Int32 ItemsCountAddresses = 0;
Int32 ItemsCountAddressesActive = 0;
Int32 ItemsCountSubscriptions = 0;
Int32 ItemsCountSubscriptionsActive = 0;
Int32 ItemsCountPartnerTypes = 0;
Int32 ItemsCountPartnerRelationships = 0;
Int32 ItemsCountFamilyMembers = 0;
Int32 ItemsCountInterests = 0;
Int32 ItemsCountContacts = 0;
DateTime LastContactDate = DateTime.Now;
Int64 FoundationOwner1Key = 0;
Int64 FoundationOwner2Key = 0;
bool HasEXWORKERPartnerType = false;
PFamilyTable PersonFamilyDT;
TOfficeSpecificDataLabelsUIConnector OfficeSpecificDataLabelsUIConnector;
Boolean OfficeSpecificDataLabelsAvailable;
ASiteCountryCode = "";
FNewPartnerPartnerKey = APartnerKey;
FNewPartnerPartnerClass = APartnerClass;
CreationDate = DateTime.Today;
CreationUserID = UserInfo.GUserInfo.UserID;
// create the FPartnerEditScreenDS DataSet that will later be passed to the Client
FPartnerEditScreenDS = new PartnerEditTDS(DATASETNAME);
FPartnerKey = FNewPartnerPartnerKey;
FPartnerClass = FNewPartnerPartnerClass;
ReadTransaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.RepeatableRead);
try
{
/*
* Create DataRow for PPartner
*/
#region Calculations
// Determine Gift Processing settings
GiftReceiptingDefaults = TSystemDefaultsCache.GSystemDefaultsCache.GetStringDefault(
TSystemDefaultsCache.PARTNER_GIFTRECEIPTINGDEFAULTS);
if (GiftReceiptingDefaults != "")
{
GiftReceiptingDefaultsSplit = GiftReceiptingDefaults.Split(',');
ReceiptLetterFrequency = GiftReceiptingDefaultsSplit[0];
if (GiftReceiptingDefaultsSplit[1] == "no")
{
ReceiptEachGift = false;
}
else
{
ReceiptEachGift = true;
}
}
else
{
ReceiptLetterFrequency = "Annual";
ReceiptEachGift = false;
}
// Determine LanguageCode
if (FPartnerClass != TPartnerClass.PERSON)
{
LanguageCode = TUserDefaults.GetStringDefault(MSysManConstants.PARTNER_LANGUAGE, "99");
}
else
{
PersonFamilyPartnerDT = PPartnerAccess.LoadByPrimaryKey(AFamilyPartnerKey, ReadTransaction);
if (PersonFamilyPartnerDT[0].LanguageCode == "99")
{
LanguageCode = TUserDefaults.GetStringDefault(MSysManConstants.PARTNER_LANGUAGE, "99");
}
else
{
LanguageCode = PersonFamilyPartnerDT[0].LanguageCode;
}
}
#endregion
// We get the default values for all DataColumns
// and then modify some.
PartnerRow = FPartnerEditScreenDS.PPartner.NewRowTyped(true);
PartnerRow.PartnerKey = FPartnerKey;
PartnerRow.DateCreated = CreationDate;
PartnerRow.CreatedBy = CreationUserID;
PartnerRow.PartnerClass = SharedTypes.PartnerClassEnumToString(APartnerClass);
PartnerRow.AcquisitionCode = AAcquisitionCode;
// logical DataColumns must be initialised for DataBinding to work
PartnerRow.NoSolicitations = false;
PartnerRow.DeletedPartner = false;
PartnerRow.ChildIndicator = false;
PartnerRow.ReceiptLetterFrequency = ReceiptLetterFrequency;
PartnerRow.ReceiptEachGift = ReceiptEachGift;
PartnerRow.LanguageCode = LanguageCode;
if (!APrivatePartner)
{
PartnerRow.StatusCode = SharedTypes.StdPartnerStatusCodeEnumToString(TStdPartnerStatusCode.spscACTIVE);
}
else
{
PartnerRow.StatusCode = SharedTypes.StdPartnerStatusCodeEnumToString(TStdPartnerStatusCode.spscPRIVATE);
PartnerRow.Restricted = SharedConstants.PARTNER_PRIVATE_USER;
PartnerRow.UserId = CreationUserID;
}
PartnerRow.StatusChange = CreationDate;
#region Partner Types
TLogging.LogAtLevel(7, "TPartnerEditUIConnector.GetDataNewPartner: before PartnerClass switch");
switch (APartnerClass)
{
case TPartnerClass.PERSON:
// Load p_family record of the FAMILY that the PERSON will belong to
PersonFamilyDT = PFamilyAccess.LoadByPrimaryKey(AFamilyPartnerKey, ReadTransaction);
// Create DataRow for PPerson using the default values for all DataColumns
TLogging.LogAtLevel(7, "TPartnerEditUIConnector.GetDataNewPartner: before adding Person DataRow");
PersonRow = FPartnerEditScreenDS.PPerson.NewRowTyped(true);
PersonRow.PartnerKey = FPartnerKey;
PersonRow.DateCreated = CreationDate;
PersonRow.CreatedBy = CreationUserID;
PersonRow.FamilyKey = AFamilyPartnerKey;
PersonRow.FamilyName = PersonFamilyDT[0].FamilyName;
FamilyIDHandling = new TPartnerFamilyIDHandling();
if (FamilyIDHandling.GetNewFamilyID(AFamilyPartnerKey, out FamilyID, out ProblemMessage) == TFamilyIDSuccessEnum.fiError)
{
// this should not really happen but we cannot continue if it does
throw new EPartnerFamilyIDException(ProblemMessage);
}
PersonRow.FamilyId = FamilyID;
PersonRow.OccupationCode = MPartnerConstants.DEFAULT_CODE_UNKNOWN;
FPartnerEditScreenDS.PPerson.Rows.Add(PersonRow);
GetFamilyMembersInternal(AFamilyPartnerKey, "", out ItemsCountFamilyMembers, true);
/*
* Remove other Partner Class Tables.
* This is needed for correct working of the creation of new Partners on the Client side (the ShowData Method of the 'Top Part'
* relies on null DataTables when determining which data of which DataTables to put into which Controls).
*/
FPartnerEditScreenDS.Tables.Remove(PFamilyTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(POrganisationTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PChurchTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PBankTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PUnitTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PVenueTable.GetTableName());
break;
case TPartnerClass.FAMILY:
TLogging.LogAtLevel(7, "TPartnerEditUIConnector.GetDataNewPartner: before adding Family DataRow");
// Create DataRow for PFamily using the default values for all DataColumns
FamilyRow = FPartnerEditScreenDS.PFamily.NewRowTyped(true);
FamilyRow.PartnerKey = FPartnerKey;
FamilyRow.DateCreated = CreationDate;
FamilyRow.CreatedBy = CreationUserID;
FPartnerEditScreenDS.PFamily.Rows.Add(FamilyRow);
/*
* Remove other Partner Class Tables.
* This is needed for correct working of the creation of new Partners on the Client side (the ShowData Method of the 'Top Part'
* relies on null DataTables when determining which data of which DataTables to put into which Controls).
*/
FPartnerEditScreenDS.Tables.Remove(PPersonTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(POrganisationTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PChurchTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PBankTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PUnitTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PVenueTable.GetTableName());
break;
case TPartnerClass.CHURCH:
// Create DataRow for PChurch using the default values for all DataColumns
ChurchRow = FPartnerEditScreenDS.PChurch.NewRowTyped(true);
ChurchRow.PartnerKey = FPartnerKey;
ChurchRow.DateCreated = CreationDate;
ChurchRow.CreatedBy = CreationUserID;
// logical DataColumns must be initialised for DataBinding to work
ChurchRow.Accomodation = false;
ChurchRow.PrayerGroup = false;
ChurchRow.MapOnFile = false;
FPartnerEditScreenDS.PChurch.Rows.Add(ChurchRow);
/*
* Remove other Partner Class Tables.
* This is needed for correct working of the creation of new Partners on the Client side (the ShowData Method of the 'Top Part'
* relies on null DataTables when determining which data of which DataTables to put into which Controls).
*/
FPartnerEditScreenDS.Tables.Remove(PPersonTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PFamilyTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(POrganisationTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PBankTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PUnitTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PVenueTable.GetTableName());
break;
case TPartnerClass.ORGANISATION:
// Create DataRow for POrganisation using the default values for all DataColumns
OrganisationRow = FPartnerEditScreenDS.POrganisation.NewRowTyped(true);
OrganisationRow.PartnerKey = FPartnerKey;
OrganisationRow.DateCreated = CreationDate;
OrganisationRow.CreatedBy = CreationUserID;
// logical DataColumns must be initialised for DataBinding to work
OrganisationRow.Religious = false;
OrganisationRow.Foundation = false;
FPartnerEditScreenDS.POrganisation.Rows.Add(OrganisationRow);
/*
* Remove other Partner Class Tables.
* This is needed for correct working of the creation of new Partners on the Client side (the ShowData Method of the 'Top Part'
* relies on null DataTables when determining which data of which DataTables to put into which Controls).
*/
FPartnerEditScreenDS.Tables.Remove(PPersonTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PFamilyTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PChurchTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PBankTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PUnitTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PVenueTable.GetTableName());
break;
case TPartnerClass.BANK:
// Create DataRow for PBank using the default values for all DataColumns
BankRow = FPartnerEditScreenDS.PBank.NewRowTyped(true);
BankRow.PartnerKey = FPartnerKey;
BankRow.DateCreated = CreationDate;
BankRow.CreatedBy = CreationUserID;
FPartnerEditScreenDS.PBank.Rows.Add(BankRow);
/*
* Remove other Partner Class Tables.
* This is needed for correct working of the creation of new Partners on the Client side (the ShowData Method of the 'Top Part'
* relies on null DataTables when determining which data of which DataTables to put into which Controls).
*/
FPartnerEditScreenDS.Tables.Remove(PPersonTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PFamilyTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(POrganisationTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PChurchTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PUnitTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PVenueTable.GetTableName());
break;
case TPartnerClass.UNIT:
// Create DataRow for PUnit using the default values for all DataColumns
UnitRow = FPartnerEditScreenDS.PUnit.NewRowTyped(true);
UnitRow.PartnerKey = FPartnerKey;
UnitRow.DateCreated = CreationDate;
UnitRow.CreatedBy = CreationUserID;
FPartnerEditScreenDS.PUnit.Rows.Add(UnitRow);
/*
* Remove other Partner Class Tables.
* This is needed for correct working of the creation of new Partners on the Client side (the ShowData Method of the 'Top Part'
* relies on null DataTables when determining which data of which DataTables to put into which Controls).
*/
FPartnerEditScreenDS.Tables.Remove(PPersonTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PFamilyTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PChurchTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PBankTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(POrganisationTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PVenueTable.GetTableName());
break;
case TPartnerClass.VENUE:
// Create DataRow for PVenue using the default values for all DataColumns
VenueRow = FPartnerEditScreenDS.PVenue.NewRowTyped(true);
VenueRow.PartnerKey = FPartnerKey;
VenueRow.DateCreated = CreationDate;
VenueRow.CreatedBy = CreationUserID;
// Makeup a VenueCode for now, as there is now way to let the user spec one quickly...
VenueRow.VenueCode = 'V' + FPartnerKey.ToString().Substring(1);
FPartnerEditScreenDS.PVenue.Rows.Add(VenueRow);
/*
* Remove other Partner Class Tables.
* This is needed for correct working of the creation of new Partners on the Client side (the ShowData Method of the 'Top Part'
* relies on null DataTables when determining which data of which DataTables to put into which Controls).
*/
FPartnerEditScreenDS.Tables.Remove(PPersonTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PFamilyTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PChurchTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PBankTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(POrganisationTable.GetTableName());
FPartnerEditScreenDS.Tables.Remove(PUnitTable.GetTableName());
break;
}
PartnerRow.AddresseeTypeCode = TSharedAddressHandling.GetDefaultAddresseeType(APartnerClass);
TLogging.LogAtLevel(7, "TPartnerEditUIConnector.GetDataNewPartner: before adding new Partner DataRow");
// Add DataRow for PPartner
FPartnerEditScreenDS.PPartner.Rows.Add(PartnerRow);
if (APartnerClass == TPartnerClass.PERSON)
{
/*
* Copy specified Family Address into the PLocation and PPartnerLocation
* table (is needed on the Client side to copy this address as the default
* address of the new Person and gets deleted there as soon as copying is
* done)
*/
// TLogging.LogAtLevel(7, "Getting Family Address - AFamilyPartnerKey: " + AFamilyPartnerKey.ToString() + "; AFamilyLocationKey: " + AFamilyLocationKey.ToString());
TPPartnerAddressAggregate.LoadByPrimaryKey(FPartnerEditScreenDS,
AFamilyPartnerKey,
AFamilySiteKey,
AFamilyLocationKey,
ReadTransaction);
// Copy Special Types from the PERSON'S FAMILY to the PERSON
TLogging.LogAtLevel(7, "TPartnerEditUIConnector.GetDataNewPartner: before loading Special Types from FAMILY");
GetPartnerTypesForNewPartnerFromFamily(AFamilyPartnerKey, ReadTransaction);
/*
* Create Relationship between Family and Person
*/
PartnerRelationshipRow = FPartnerEditScreenDS.PPartnerRelationship.NewRowTyped(true);
PartnerRelationshipRow.PartnerKey = AFamilyPartnerKey;
PartnerRelationshipRow.RelationKey = FPartnerKey;
PartnerRelationshipRow.RelationName = "FAMILY";
PartnerRelationshipRow.Comment = SharedConstants.ROW_IS_SYSTEM_GENERATED;
PartnerRelationshipRow.DateCreated = CreationDate;
PartnerRelationshipRow.CreatedBy = CreationUserID;
FPartnerEditScreenDS.PPartnerRelationship.Rows.Add(PartnerRelationshipRow);
}
#endregion
// Note: Location and PartnerLocation for a new Partner are set up on the Client side!
// Determine CountryCode for first Address of the Partner, if it is not overwritten
if (ADesiredCountryCode == "")
{
// TODO 1 oChristianK cPartner Edit / New Partner : Use a proper function to determine the 'Best' Address of the Unit...
SiteLocationRequiredColumns = new StringCollection();
SiteLocationRequiredColumns.Add(PLocationTable.GetLocationKeyDBName());
SiteLocationRequiredColumns.Add(PLocationTable.GetCountryCodeDBName());
SiteLocationDT = PLocationAccess.LoadViaPPartner(ASiteKey, SiteLocationRequiredColumns, ReadTransaction, null, 0, 0);
// For the moment just take the CountryCode that we find in the (random) first record...
ASiteCountryCode = SiteLocationDT[0].CountryCode;
}
/*
* Office Specific Data
*/
OfficeSpecificDataLabelsUIConnector = new TOfficeSpecificDataLabelsUIConnector(FPartnerKey,
MCommonTypes.PartnerClassEnumToOfficeSpecificDataLabelUseEnum(FPartnerClass));
OfficeSpecificDataLabelsAvailable =
(OfficeSpecificDataLabelsUIConnector.CountLabelUse(SharedTypes.PartnerClassEnumToString(FPartnerClass), ReadTransaction) != 0);
MiscellaneousDataDT = FPartnerEditScreenDS.MiscellaneousData;
MiscellaneousDataDR = MiscellaneousDataDT.NewRowTyped(false);
MiscellaneousDataDR.PartnerKey = FPartnerKey;
if (AFamilyLocationKey != 0)
{
MiscellaneousDataDR.SelectedSiteKey = AFamilySiteKey;
MiscellaneousDataDR.SelectedLocationKey = AFamilyLocationKey;
}
else
{
MiscellaneousDataDR.SelectedSiteKey = -1;
MiscellaneousDataDR.SelectedLocationKey = -1;
}
MiscellaneousDataDR.SetLastGiftDateNull();
MiscellaneousDataDR.LastGiftInfo = "";
MiscellaneousDataDR.ItemsCountAddresses = ItemsCountAddresses;
MiscellaneousDataDR.ItemsCountAddressesActive = ItemsCountAddressesActive;
MiscellaneousDataDR.ItemsCountSubscriptions = ItemsCountSubscriptions;
MiscellaneousDataDR.ItemsCountSubscriptionsActive = ItemsCountSubscriptionsActive;
MiscellaneousDataDR.ItemsCountPartnerTypes = ItemsCountPartnerTypes;
MiscellaneousDataDR.ItemsCountPartnerRelationships = ItemsCountPartnerRelationships;
MiscellaneousDataDR.ItemsCountFamilyMembers = ItemsCountFamilyMembers;
MiscellaneousDataDR.ItemsCountInterests = ItemsCountInterests;
MiscellaneousDataDR.OfficeSpecificDataLabelsAvailable = OfficeSpecificDataLabelsAvailable;
MiscellaneousDataDR.FoundationOwner1Key = FoundationOwner1Key;
MiscellaneousDataDR.FoundationOwner2Key = FoundationOwner2Key;
MiscellaneousDataDR.HasEXWORKERPartnerType = HasEXWORKERPartnerType;
MiscellaneousDataDR.ItemsCountContacts = ItemsCountContacts;
MiscellaneousDataDR.LastContactDate = LastContactDate;
MiscellaneousDataDT.Rows.Add(MiscellaneousDataDR);
MiscellaneousDataDT.AcceptChanges();
}
catch (Exception Exp)
{
TLogging.Log("Exception occured in GetDataNewPartner: " + Exp.ToString());
}
DBAccess.GDBAccessObj.CommitTransaction();
// Remove all Tables that were not filled with data before remoting them
// This will be the DataTables that exist for a certain Partner Class,
// eg. Person only one of those Tables will be filled, the other ones are
// not needed at the Client side.
// FPartnerEditScreenDS.RemoveEmptyTables;
// For the moment we only remove the following table so that the Partner
// Edit screen can discover the value of MiscellaneousDataDR.ItemsCountFamilyMembers
FPartnerEditScreenDS.Tables.Remove(PartnerEditTDSFamilyMembersTable.GetTableName());
return FPartnerEditScreenDS;
}
/// <summary>
/// Returns the values of the found partner.
/// </summary>
/// <param name="APartnerKey">Partner key</param>
/// <param name="AShortName">Partner short name</param>
/// <param name="APartnerClass">Partner Class.</param>
/// <param name="ALocationPK">Location key</param>
/// <param name="ABankingDetailsKey">Location key</param>
/// <returns></returns>
public Boolean GetReturnedParameters(out Int64 APartnerKey, out String AShortName, out TPartnerClass? APartnerClass,
out TLocationPK ALocationPK, out int ABankingDetailsKey)
{
DataRowView[] SelectedGridRow = grdResult.SelectedDataRowsAsDataRowView;
if (SelectedGridRow.Length <= 0)
{
// no Row is selected
APartnerKey = -1;
AShortName = "";
APartnerClass = null;
ALocationPK = new TLocationPK(-1, -1);
ABankingDetailsKey = -1;
}
else
{
// MessageBox.Show(SelectedGridRow[0]['p_partner_key_n'].ToString);
APartnerKey = Convert.ToInt64(SelectedGridRow[0][PPartnerTable.GetPartnerKeyDBName()]);
AShortName = Convert.ToString(SelectedGridRow[0][PPartnerTable.GetPartnerShortNameDBName()]);
APartnerClass = SharedTypes.PartnerClassStringToEnum(Convert.ToString(SelectedGridRow[0][PPartnerTable.GetPartnerClassDBName()]));
if (!FBankDetailsTab)
{
ALocationPK =
new TLocationPK(Convert.ToInt64(SelectedGridRow[0][PPartnerLocationTable.GetSiteKeyDBName()]),
Convert.ToInt32(SelectedGridRow[0][PPartnerLocationTable.GetLocationKeyDBName()]));
ABankingDetailsKey = -1;
}
else
{
ABankingDetailsKey = Convert.ToInt32(SelectedGridRow[0][PBankingDetailsTable.GetBankingDetailsKeyDBName()]);
ALocationPK = null;
}
}
return true;
}
/// <summary>
/// Set a default partner class
/// </summary>
/// <param name="ADefaultClass"></param>
public void SetDefaultPartnerClass(TPartnerClass ? ADefaultClass)
{
ucoPartnerFindCriteria.SetDefaultPartnerClass(ADefaultClass);
}
/// <summary>
/// Modifies menu items depending on the Recipeint's Partner class
/// </summary>
public static void OnRecipientPartnerClassChanged(TPartnerClass? APartnerClass, TtxtAutoPopulatedButtonLabel ATxtDetailRecipientKey,
TtxtAutoPopulatedButtonLabel AtxtDetailRecipientLedgerNumber, out bool ? AEnableRecipientGiftDestination)
{
AEnableRecipientGiftDestination = null;
string ItemText = Catalog.GetString("Open Recipient Gift Destination");
if ((APartnerClass == TPartnerClass.UNIT) || (APartnerClass == null))
{
ATxtDetailRecipientKey.CustomContextMenuItemsVisibility(ItemText, false);
AtxtDetailRecipientLedgerNumber.CustomContextMenuItemsVisibility(ItemText, false);
AEnableRecipientGiftDestination = false;
}
else if (APartnerClass == TPartnerClass.FAMILY)
{
ATxtDetailRecipientKey.CustomContextMenuItemsVisibility(ItemText, true);
AtxtDetailRecipientLedgerNumber.CustomContextMenuItemsVisibility(ItemText, true);
AEnableRecipientGiftDestination = true;
}
}
/// <summary>
/// overload
/// </summary>
/// <param name="APartnerKey"></param>
/// <param name="APartnerShortName"></param>
/// <param name="APartnerClass"></param>
/// <returns></returns>
public static Boolean GetPartnerShortName(Int64 APartnerKey, out String APartnerShortName, out TPartnerClass APartnerClass)
{
return(GetPartnerShortName(APartnerKey, out APartnerShortName, out APartnerClass, true));
}
/// <summary>
/// Validates the Gift Detail data.
/// </summary>
/// <param name="AContext">Context that describes where the data validation failed.</param>
/// <param name="ARow">The <see cref="DataRow" /> which holds the the data against which the validation is run.</param>
/// <param name="AVerificationResultCollection">Will be filled with any <see cref="TVerificationResult" /> items if
/// data validation errors occur.</param>
/// <param name="AValidationControlsDict">A <see cref="TValidationControlsDict" /> containing the Controls that
/// display data that is about to be validated.</param>
/// <param name="ARecipientPartnerClass">Recipient's Partner Class (used for Motivation Detail validation).</param>
/// <param name="ASetupForILT">Optional - Is the recipient set up for inter-ledger transfers.</param>
/// <param name="ACostCentres">Optional - a CostCentres table. Is required for import validation. </param>
/// <param name="AAccounts">Optional - a Accounts table. Is required for import validation. </param>
/// <param name="AMotivationGroups">Optional - a MotivationGroups table. Is required for import validation. </param>
/// <param name="AMotivationDetails">Optional - a MotivationDetails table. Is required for import validation. </param>
/// <param name="AMailingTable">Optional - a Mailing table. Is required for import validation. </param>
/// <param name="ARecipientField">Optional The recipient field for the gift. Is required for import validation. </param>
/// <returns>True if the validation found no data validation errors, otherwise false.</returns>
public static bool ValidateGiftDetailManual(object AContext,
GiftBatchTDSAGiftDetailRow ARow,
ref TVerificationResultCollection AVerificationResultCollection,
TValidationControlsDict AValidationControlsDict,
TPartnerClass? ARecipientPartnerClass,
bool? ASetupForILT = null,
ACostCentreTable ACostCentres = null,
AAccountTable AAccounts = null,
AMotivationGroupTable AMotivationGroups = null,
AMotivationDetailTable AMotivationDetails = null,
PMailingTable AMailingTable = null,
Int64 ARecipientField = -1)
{
DataColumn ValidationColumn;
TValidationControlsData ValidationControlsData;
TVerificationResult VerificationResult = null;
object ValidationContext;
int VerifResultCollAddedCount = 0;
bool ValidPartner = true;
// Don't validate deleted DataRows
if (ARow.RowState == DataRowState.Deleted)
{
return true;
}
bool isImporting = AContext.ToString().Contains("Importing");
// Check if valid recipient
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnRecipientKeyId];
ValidationContext = String.Format("Batch no. {0}, gift no. {1}, detail no. {2}",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
VerificationResult = TSharedPartnerValidation_Partner.IsValidPartner(
ARow.RecipientKey, new TPartnerClass[] { TPartnerClass.FAMILY, TPartnerClass.UNIT }, true,
isImporting ? Catalog.GetString("Recipient key") :
"Recipient of " + THelper.NiceValueDescription(ValidationContext.ToString()),
AContext, ValidationColumn, null);
if (VerificationResult != null)
{
AVerificationResultCollection.Remove(ValidationColumn);
AVerificationResultCollection.AddAndIgnoreNullValue(VerificationResult);
ValidPartner = false;
}
// 'Gift amount must be non-zero
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnGiftTransactionAmountId];
ValidationContext = String.Format("Batch Number {0} (transaction:{1} detail:{2})",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
VerificationResult = TNumericalChecks.IsNonZeroDecimal(ARow.GiftTransactionAmount,
ValidationControlsData.ValidationControlLabel + (isImporting ? String.Empty : " of " + ValidationContext),
AContext, ValidationColumn, ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
// If recipient is non-zero, field must also be non-zero. Only check for valid recipient keys.
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnRecipientLedgerNumberId];
ValidationContext = String.Format("batch:{0} transaction:{1} detail:{2}",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
if ((ARow.RecipientKey > 0) && ValidPartner && (ARow.RecipientLedgerNumber == 0))
{
VerificationResult = TNumericalChecks.IsGreaterThanZero(ARow.RecipientLedgerNumber,
"Recipient field of " + ValidationContext + " is 0",
AContext, ValidationColumn, ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
// Motivation Group code must exist
if (!ARow.IsMotivationGroupCodeNull() && (AMotivationGroups != null))
{
AMotivationGroupRow foundRow = (AMotivationGroupRow)AMotivationGroups.Rows.Find(
new object[] { ARow.LedgerNumber, ARow.MotivationGroupCode });
if ((foundRow == null) && AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Unknown motivation group code '{0}'."),
ARow.MotivationGroupCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
}
if (!isImporting)
{
// NOTE AlanP Oct 2014. This gets checked by standard validation so may no longer be necessary?
// (There was a bug in standard validation where NULL and empty string checks did not quite work as they should ...
// so maybe this was necessary before. Anyway I am leaving it in for now. I know that importing works fine,
// but maybe it is necessary in other circumstances?)
// Motivation Detail must not be null
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnMotivationDetailCodeId];
ValidationContext = String.Format("(batch:{0} transaction:{1} detail:{2})",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
if (ARow.IsMotivationDetailCodeNull() || (ARow.MotivationDetailCode == String.Empty))
{
VerificationResult = TGeneralChecks.ValueMustNotBeNullOrEmptyString(ARow.MotivationDetailCode,
(isImporting ? ValidationControlsData.ValidationControlLabel : "Motivation Detail code " + ValidationContext),
AContext, ValidationColumn, ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
}
}
// Motivation Detail must be valid
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnMotivationDetailCodeId];
ValidationContext = String.Format("(batch:{0} transaction:{1} detail:{2})",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
if (!ARow.IsMotivationDetailCodeNull() && (AMotivationDetails != null))
{
AMotivationDetailRow foundRow = (AMotivationDetailRow)AMotivationDetails.Rows.Find(
new object[] { ARow.LedgerNumber, ARow.MotivationGroupCode, ARow.MotivationDetailCode });
if ((foundRow == null) && AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Unknown motivation detail code '{0}' for group '{1}'."),
ARow.MotivationDetailCode, ARow.MotivationGroupCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
if ((foundRow != null) && (foundRow.MotivationStatus == false) && AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Motivation detail code '{0}' is no longer in use."),
ARow.MotivationDetailCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
if ((foundRow != null) && (foundRow.RecipientKey != 0) && (ARow.RecipientKey != 0) && (foundRow.RecipientKey != ARow.RecipientKey)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString(
"The recipient partner key for motivation detail code '{0}' does not match the recipient partner key in the import line."),
ARow.MotivationDetailCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
// Motivation Detail must not be 'Field' or 'Keymin' if the recipient is a Family partner
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnMotivationDetailCodeId];
ValidationContext = String.Format("(batch:{0} transaction:{1} detail:{2})",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
if (!ARow.IsMotivationDetailCodeNull()
&& (ARow.MotivationGroupCode == MFinanceConstants.MOTIVATION_GROUP_GIFT) && (ARecipientPartnerClass != null)
&& ((ARow.MotivationDetailCode == MFinanceConstants.GROUP_DETAIL_FIELD)
|| (ARow.MotivationDetailCode == MFinanceConstants.GROUP_DETAIL_KEY_MIN))
&& (ARecipientPartnerClass == TPartnerClass.FAMILY))
{
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
VerificationResult = new TVerificationResult(AContext,
String.Format(Catalog.GetString("Motivation Detail code '{0}' is not allowed for Family recipients."),
ARow.MotivationDetailCode),
TResultSeverity.Resv_Critical);
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext,
new TScreenVerificationResult(VerificationResult, ValidationColumn, ValidationControlsData.ValidationControl),
ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
}
// Cost Centre Code must exist and be active. Only required for importing because the GUI does this for us otherwise.
if (isImporting && (ACostCentres != null) && !ARow.IsCostCentreCodeNull())
{
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnCostCentreCodeId];
ValidationContext = ARow.CostCentreCode;
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
// We even need to check that the code exists!
DataRow foundRow = ACostCentres.Rows.Find(new object[] { ARow.LedgerNumber, ARow.CostCentreCode });
if ((foundRow == null)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TScreenVerificationResult(ValidationContext,
ValidationColumn,
String.Format(Catalog.GetString("Unknown cost centre code '{0}'."), ARow.CostCentreCode),
ValidationControlsData.ValidationControl,
TResultSeverity.Resv_Critical),
/*
* new TVerificationResult(ValidationContext,
* String.Format(Catalog.GetString("Unknown cost centre code '{0}'."), ARow.CostCentreCode),
* TResultSeverity.Resv_Critical),
*/
ValidationColumn))
{
VerifResultCollAddedCount++;
}
VerificationResult = (TScreenVerificationResult)TStringChecks.ValidateValueIsActive(ARow.LedgerNumber,
ACostCentres,
ValidationContext.ToString(),
ACostCentreTable.GetCostCentreActiveFlagDBName(),
AContext,
ValidationColumn,
ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if ((VerificationResult != null)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
}
// Account Code must exist and be active. Only required for importing because the GUI does this for us otherwise.
if (isImporting && (AAccounts != null) && !ARow.IsAccountCodeNull())
{
DataColumn[] ValidationColumns = new DataColumn[] {
ARow.Table.Columns[AGiftDetailTable.ColumnAccountCodeId], ARow.Table.Columns[AGiftDetailTable.ColumnTaxDeductibleAccountCodeId]
};
string[] AccountCodes = new string[] {
ARow.AccountCode, ARow.TaxDeductibleAccountCode
};
for (int i = 0; i < 2; i++)
{
if (AValidationControlsDict.TryGetValue(ValidationColumns[i], out ValidationControlsData))
{
// We even need to check that the code exists!
DataRow foundRow = AAccounts.Rows.Find(new object[] { ARow.LedgerNumber, AccountCodes[i] });
if ((foundRow == null)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TVerificationResult(AccountCodes[i],
String.Format(Catalog.GetString("Unknown account code '{0}'."), AccountCodes[i]),
TResultSeverity.Resv_Critical),
ValidationColumns[i]))
{
VerifResultCollAddedCount++;
}
VerificationResult = (TScreenVerificationResult)TStringChecks.ValidateValueIsActive(ARow.LedgerNumber,
AAccounts,
AccountCodes[i],
AAccountTable.GetAccountActiveFlagDBName(),
AContext,
ValidationColumns[i],
ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if ((VerificationResult != null)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumns[i], true))
{
VerifResultCollAddedCount++;
}
}
}
}
// Mailing code must exist
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnMailingCodeId];
ValidationContext = String.Format("(batch:{0} transaction:{1} detail:{2})",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
if (!ARow.IsMailingCodeNull() && (AMailingTable != null))
{
PMailingRow foundRow = (PMailingRow)AMailingTable.Rows.Find(ARow.MailingCode);
if ((foundRow == null) && AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Unknown mailing code '{0}'."),
ARow.MailingCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
// Detail comments type 1 must not be null if associated comment is not null
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnCommentOneTypeId];
ValidationContext = String.Format("(batch:{0} transaction:{1} detail:{2})",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
if (!ARow.IsGiftCommentOneNull() && (ARow.GiftCommentOne != String.Empty))
{
VerificationResult = TGeneralChecks.ValueMustNotBeNullOrEmptyString(ARow.CommentOneType,
(isImporting ? ValidationControlsData.ValidationControlLabel : "Comment 1 type " + ValidationContext),
AContext, ValidationColumn, ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
if (VerificationResult == null)
{
// There is a comment type for the comment - but it needs to be one of the valid types
if ((ARow.CommentOneType != MFinanceConstants.GIFT_COMMENT_TYPE_DONOR)
&& (ARow.CommentOneType != MFinanceConstants.GIFT_COMMENT_TYPE_RECIPIENT)
&& (ARow.CommentOneType != MFinanceConstants.GIFT_COMMENT_TYPE_BOTH)
&& (ARow.CommentOneType != MFinanceConstants.GIFT_COMMENT_TYPE_OFFICE)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Comment type must be one of '{0}', '{1}', '{2}' or '{3}'."),
MFinanceConstants.GIFT_COMMENT_TYPE_DONOR,
MFinanceConstants.GIFT_COMMENT_TYPE_RECIPIENT,
MFinanceConstants.GIFT_COMMENT_TYPE_BOTH,
MFinanceConstants.GIFT_COMMENT_TYPE_OFFICE),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
}
}
// Detail comments type 2 must not be null if associated comment is not null
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnCommentTwoTypeId];
ValidationContext = String.Format("(batch:{0} transaction:{1} detail:{2})",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
if (!ARow.IsGiftCommentTwoNull() && (ARow.GiftCommentTwo != String.Empty))
{
VerificationResult = TGeneralChecks.ValueMustNotBeNullOrEmptyString(ARow.CommentTwoType,
(isImporting ? ValidationControlsData.ValidationControlLabel : "Comment 2 type " + ValidationContext),
AContext, ValidationColumn, ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
if (VerificationResult == null)
{
// There is a comment type for the comment - but it needs to be one of the valid types
if ((ARow.CommentTwoType != MFinanceConstants.GIFT_COMMENT_TYPE_DONOR)
&& (ARow.CommentTwoType != MFinanceConstants.GIFT_COMMENT_TYPE_RECIPIENT)
&& (ARow.CommentTwoType != MFinanceConstants.GIFT_COMMENT_TYPE_BOTH)
&& (ARow.CommentTwoType != MFinanceConstants.GIFT_COMMENT_TYPE_OFFICE)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Comment type must be one of '{0}', '{1}', '{2}' or '{3}'."),
MFinanceConstants.GIFT_COMMENT_TYPE_DONOR,
MFinanceConstants.GIFT_COMMENT_TYPE_RECIPIENT,
MFinanceConstants.GIFT_COMMENT_TYPE_BOTH,
MFinanceConstants.GIFT_COMMENT_TYPE_OFFICE),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
}
}
// Detail comments type 3 must not be null if associated comment is not null
ValidationColumn = ARow.Table.Columns[AGiftDetailTable.ColumnCommentThreeTypeId];
ValidationContext = String.Format("(batch:{0} transaction:{1} detail:{2})",
ARow.BatchNumber,
ARow.GiftTransactionNumber,
ARow.DetailNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
if (!ARow.IsGiftCommentThreeNull() && (ARow.GiftCommentThree != String.Empty))
{
VerificationResult = TGeneralChecks.ValueMustNotBeNullOrEmptyString(ARow.CommentThreeType,
(isImporting ? ValidationControlsData.ValidationControlLabel : "Comment 3 type " + ValidationContext),
AContext, ValidationColumn, ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
if (VerificationResult == null)
{
// There is a comment type for the comment - but it needs to be one of the valid types
if ((ARow.CommentThreeType != MFinanceConstants.GIFT_COMMENT_TYPE_DONOR)
&& (ARow.CommentThreeType != MFinanceConstants.GIFT_COMMENT_TYPE_RECIPIENT)
&& (ARow.CommentThreeType != MFinanceConstants.GIFT_COMMENT_TYPE_BOTH)
&& (ARow.CommentThreeType != MFinanceConstants.GIFT_COMMENT_TYPE_OFFICE)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
AContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Comment type must be one of '{0}', '{1}', '{2}' or '{3}'."),
MFinanceConstants.GIFT_COMMENT_TYPE_DONOR,
MFinanceConstants.GIFT_COMMENT_TYPE_RECIPIENT,
MFinanceConstants.GIFT_COMMENT_TYPE_BOTH,
MFinanceConstants.GIFT_COMMENT_TYPE_OFFICE),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
}
}
return VerifResultCollAddedCount == 0;
}
private static void MergeJobs(long AFromPartnerKey, long AToPartnerKey, TPartnerClass AFromPartnerClass, TDBTransaction ATransaction)
{
// *** JOB ASSIGNMENT (PERSON) ***
PmJobAssignmentTable FromJobAssignmentTable = PmJobAssignmentAccess.LoadViaPPartner(AFromPartnerKey, ATransaction);
PmJobAssignmentTable ToJobAssignmentTable = PmJobAssignmentAccess.LoadViaPPartner(AToPartnerKey, ATransaction);
if (FromJobAssignmentTable.Rows.Count > 0)
{
foreach (DataRow FromRow in FromJobAssignmentTable.Rows)
{
PmJobAssignmentRow FromJobAssignmentRow = (PmJobAssignmentRow)FromRow;
bool ToJobAssignmentFound = false;
foreach (DataRow ToRow in ToJobAssignmentTable.Rows)
{
PmJobAssignmentRow ToJobAssignmentRow = (PmJobAssignmentRow)ToRow;
if ((ToJobAssignmentRow.FromDate == FromJobAssignmentRow.FromDate)
&& (ToJobAssignmentRow.PositionName == FromJobAssignmentRow.PositionName)
&& (ToJobAssignmentRow.PositionScope == FromJobAssignmentRow.PositionScope))
{
ToJobAssignmentFound = true;
break;
}
}
if (ToJobAssignmentFound)
{
FromRow.Delete();
}
else
{
FromJobAssignmentRow.PartnerKey = AToPartnerKey;
}
}
PmJobAssignmentAccess.SubmitChanges(FromJobAssignmentTable, ATransaction);
}
// The rest of this method only applies to Unit Partners so return if Partner is not a Unit
if (AFromPartnerClass != TPartnerClass.UNIT)
{
return;
}
// *** JOB (UNIT) ***
UmJobTable FromJobTable = UmJobAccess.LoadViaPUnit(AFromPartnerKey, ATransaction);
UmJobTable ToJobTable = UmJobAccess.LoadViaPUnit(AToPartnerKey, ATransaction);
if (FromJobTable.Rows.Count > 0)
{
foreach (DataRow FromRow in FromJobTable.Rows)
{
UmJobRow FromJobRow = (UmJobRow)FromRow;
bool ToJobFound = false;
foreach (DataRow ToRow in ToJobTable.Rows)
{
UmJobRow ToJobRow = (UmJobRow)ToRow;
if ((ToJobRow.PositionName == FromJobRow.PositionName)
&& (ToJobRow.PositionScope == FromJobRow.PositionScope))
{
ToJobFound = true;
break;
}
}
if (ToJobFound)
{
FromRow.Delete();
}
else
{
FromJobRow.UnitKey = AToPartnerKey;
}
}
UmJobAccess.SubmitChanges(FromJobTable, ATransaction);
}
// *** JOB ABILITY (UNIT) ***
UmJobRequirementTable FromJobRequirementTable = UmJobRequirementAccess.LoadViaPUnit(AFromPartnerKey, ATransaction);
UmJobRequirementTable ToJobRequirementTable = UmJobRequirementAccess.LoadViaPUnit(AToPartnerKey, ATransaction);
if (FromJobRequirementTable.Rows.Count > 0)
{
foreach (DataRow FromRow in FromJobRequirementTable.Rows)
{
UmJobRequirementRow FromJobRequirementRow = (UmJobRequirementRow)FromRow;
bool ToJobRequirementFound = false;
foreach (DataRow ToRow in ToJobRequirementTable.Rows)
{
UmJobRequirementRow ToJobRequirementRow = (UmJobRequirementRow)ToRow;
if ((ToJobRequirementRow.PositionName == FromJobRequirementRow.PositionName)
&& (ToJobRequirementRow.PositionScope == FromJobRequirementRow.PositionScope)
&& (ToJobRequirementRow.AbilityAreaName == FromJobRequirementRow.AbilityAreaName))
{
ToJobRequirementFound = true;
break;
}
}
if (ToJobRequirementFound)
{
FromRow.Delete();
}
else
{
FromJobRequirementRow.UnitKey = AToPartnerKey;
}
}
UmJobRequirementAccess.SubmitChanges(FromJobRequirementTable, ATransaction);
}
// *** JOB LANGUAGE (UNIT) ***
UmJobLanguageTable FromJobLanguageTable = UmJobLanguageAccess.LoadViaPUnit(AFromPartnerKey, ATransaction);
UmJobLanguageTable ToJobLanguageTable = UmJobLanguageAccess.LoadViaPUnit(AToPartnerKey, ATransaction);
if (FromJobLanguageTable.Rows.Count > 0)
{
foreach (DataRow FromRow in FromJobLanguageTable.Rows)
{
UmJobLanguageRow FromJobLanguageRow = (UmJobLanguageRow)FromRow;
bool ToJobLanguageFound = false;
foreach (DataRow ToRow in ToJobLanguageTable.Rows)
{
UmJobLanguageRow ToJobLanguageRow = (UmJobLanguageRow)ToRow;
if ((ToJobLanguageRow.PositionName == FromJobLanguageRow.PositionName)
&& (ToJobLanguageRow.PositionScope == FromJobLanguageRow.PositionScope)
&& (ToJobLanguageRow.LanguageCode == FromJobLanguageRow.LanguageCode))
{
ToJobLanguageFound = true;
break;
}
}
if (ToJobLanguageFound)
{
FromRow.Delete();
}
else
{
FromJobLanguageRow.UnitKey = AToPartnerKey;
}
}
UmJobLanguageAccess.SubmitChanges(FromJobLanguageTable, ATransaction);
}
// *** JOB Qualification (UNIT) ***
UmJobQualificationTable FromJobQualificationTable = UmJobQualificationAccess.LoadViaPUnit(AFromPartnerKey, ATransaction);
UmJobQualificationTable ToJobQualificationTable = UmJobQualificationAccess.LoadViaPUnit(AToPartnerKey, ATransaction);
if (FromJobQualificationTable.Rows.Count > 0)
{
foreach (DataRow FromRow in FromJobQualificationTable.Rows)
{
UmJobQualificationRow FromJobQualificationRow = (UmJobQualificationRow)FromRow;
bool ToJobQualificationFound = false;
foreach (DataRow ToRow in ToJobQualificationTable.Rows)
{
UmJobQualificationRow ToJobQualificationRow = (UmJobQualificationRow)ToRow;
if ((ToJobQualificationRow.PositionName == FromJobQualificationRow.PositionName)
&& (ToJobQualificationRow.PositionScope == FromJobQualificationRow.PositionScope))
{
ToJobQualificationFound = true;
break;
}
}
if (ToJobQualificationFound)
{
FromRow.Delete();
}
else
{
FromJobQualificationRow.UnitKey = AToPartnerKey;
}
}
UmJobQualificationAccess.SubmitChanges(FromJobQualificationTable, ATransaction);
}
}
public static Boolean VerifyPartner(Int64 APartnerKey,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out Boolean AIsMergedPartner,
out Boolean AUserCanAccessPartner)
{
APartnerShortName = "";
APartnerClass = TPartnerClass.FAMILY; // Default. This is not really correct but the best compromise if PartnerKey is 0 or Partner isn't found since we have an enum here.
AIsMergedPartner = false;
AUserCanAccessPartner = false;
TDBTransaction ReadTransaction;
Boolean NewTransaction;
StringCollection RequiredColumns;
PPartnerTable PartnerTable;
Boolean ReturnValue = true;
TStdPartnerStatusCode PartnerStatus = TStdPartnerStatusCode.spscACTIVE;
// initialise outout Arguments
if (APartnerKey != 0)
{
// only some fields are needed
RequiredColumns = new StringCollection();
RequiredColumns.Add(PPartnerTable.GetPartnerShortNameDBName());
RequiredColumns.Add(PPartnerTable.GetPartnerClassDBName());
RequiredColumns.Add(PPartnerTable.GetStatusCodeDBName());
RequiredColumns.Add(PPartnerTable.GetRestrictedDBName());
RequiredColumns.Add(PPartnerTable.GetUserIdDBName());
RequiredColumns.Add(PPartnerTable.GetGroupIdDBName());
ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
out NewTransaction);
try
{
PartnerTable = PPartnerAccess.LoadByPrimaryKey(APartnerKey, RequiredColumns, ReadTransaction, null, 0, 0);
}
finally
{
if (NewTransaction)
{
DBAccess.GDBAccessObj.CommitTransaction();
TLogging.LogAtLevel(7, "TPartnerServerLookups.VerifyPartner: committed own transaction.");
}
}
if (PartnerTable.Rows.Count == 0)
{
ReturnValue = false;
}
else
{
// since we loaded by primary key there must just be one partner row
APartnerShortName = PartnerTable[0].PartnerShortName;
APartnerClass = SharedTypes.PartnerClassStringToEnum(PartnerTable[0].PartnerClass);
PartnerStatus = SharedTypes.StdPartnerStatusCodeStringToEnum(PartnerTable[0].StatusCode);
// check if user can access partner
if (Ict.Petra.Server.MPartner.Common.TSecurity.CanAccessPartner(PartnerTable[0]) == TPartnerAccessLevelEnum.palGranted)
{
AUserCanAccessPartner = true;
}
// check if partner is merged
if (PartnerStatus == TStdPartnerStatusCode.spscMERGED)
{
AIsMergedPartner = true;
}
else
{
AIsMergedPartner = false;
}
ReturnValue = true;
}
}
else
{
// Return result as valid if Partner Key is 0.
ReturnValue = true;
}
return ReturnValue;
}
/// <summary>
/// convert partner class from enum to string
/// </summary>
/// <param name="APartnerClass"></param>
/// <returns></returns>
public static String PartnerClassEnumToString(TPartnerClass APartnerClass)
{
switch (APartnerClass)
{
case TPartnerClass.PERSON:
case TPartnerClass.FAMILY:
case TPartnerClass.CHURCH:
case TPartnerClass.ORGANISATION:
case TPartnerClass.BANK:
case TPartnerClass.UNIT:
case TPartnerClass.VENUE:
return APartnerClass.ToString();
}
return "##UNCONVERTABLE##";
}
public static bool MergeTwoPartners(long AFromPartnerKey,
long AToPartnerKey,
TPartnerClass AFromPartnerClass,
TPartnerClass AToPartnerClass,
long[] ASiteKeys,
int[] ALocationKeys,
int AMainBankingDetailsKey,
bool[] ACategories,
ref bool ADifferentFamilies)
{
decimal TrackerPercent;
int NumberOfCategories = 0;
foreach (bool Cat in ACategories)
{
if (Cat)
{
NumberOfCategories++;
}
}
bool TaxDeductiblePercentageEnabled = Convert.ToBoolean(
TSystemDefaults.GetSystemDefault(SharedConstants.SYSDEFAULT_TAXDEDUCTIBLEPERCENTAGE, "FALSE"));
// calculates each step's (optional and non-optional) percentage for the progress tracker
TrackerPercent = 100 / (NumberOfCategories + 3);
int CurrentCategory = 0;
TProgressTracker.InitProgressTracker(DomainManager.GClientID.ToString(), Catalog.GetString("Merging Partners"), 100);
TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.Serializable);
/* // TODO write original data to xml file
* string path = "../../log/OriginalRecordsBeforeMerge.xml";
* FileStream outStream = File.Create(Path.GetFullPath(path);
* MyWriter = new StreamWriter(outStream, Encoding.UTF8);*/
try
{
if (ACategories[0] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Gift Destination"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeGiftDestination(AFromPartnerKey, AToPartnerKey, AFromPartnerClass, Transaction);
}
if (ACategories[1] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Gift Info"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeGiftInfo(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[1] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: AP Info"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeAPInfo(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[2] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Motivations"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeMotivations(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[3] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Extracts"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeExtracts(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[4] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Greetings"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeGreetings(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[5] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Contacts and Reminders"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeContactsAndReminders(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[6] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Interests"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeInterests(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[7] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Partner Locations"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergePartnerLocations(AFromPartnerKey, AToPartnerKey, ASiteKeys, ALocationKeys, Transaction);
}
if (ACategories[8] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Types"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergePartnerTypes(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[9] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Subscriptions"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeSubscriptions(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[10] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Applications"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeApplications(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[11] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Personnel Data"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergePMData(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[12] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Jobs"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeJobs(AFromPartnerKey, AToPartnerKey, AFromPartnerClass, Transaction);
}
// merge Partner class records
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Partner") + " (" +
AFromPartnerClass.ToString() + ")", TrackerPercent * CurrentCategory);
CurrentCategory++;
if (AFromPartnerClass == TPartnerClass.UNIT)
{
if (AToPartnerClass == TPartnerClass.UNIT)
{
MergeUnit(AFromPartnerKey, AToPartnerKey, Transaction);
}
else
{
throw new Exception("Selected Partner Classes cannot be merged!");
}
}
else if (AFromPartnerClass == TPartnerClass.CHURCH)
{
if (AToPartnerClass == TPartnerClass.ORGANISATION)
{
MergeChurchToOrganisation(AFromPartnerKey, AToPartnerKey, Transaction);
}
else if (AToPartnerClass == TPartnerClass.FAMILY)
{
MergeChurchToFamily(AFromPartnerKey, AToPartnerKey, Transaction);
}
else if (AToPartnerClass == TPartnerClass.CHURCH)
{
MergeChurch(AFromPartnerKey, AToPartnerKey, Transaction);
}
else
{
throw new Exception("Selected Partner Classes cannot be merged!");
}
}
else if (AFromPartnerClass == TPartnerClass.VENUE)
{
if (AToPartnerClass == TPartnerClass.VENUE)
{
MergeVenue(AFromPartnerKey, AToPartnerKey, Transaction);
}
else
{
throw new Exception("Selected Partner Classes cannot be merged!");
}
}
else if (AFromPartnerClass == TPartnerClass.FAMILY)
{
if (AToPartnerClass == TPartnerClass.ORGANISATION)
{
MergeFamilyToOrganisation(AFromPartnerKey, AToPartnerKey, Transaction);
}
else if (AToPartnerClass == TPartnerClass.CHURCH)
{
MergeFamilyToChurch(AFromPartnerKey, AToPartnerKey, Transaction);
}
else if (AToPartnerClass == TPartnerClass.FAMILY)
{
MergeFamily(AFromPartnerKey, AToPartnerKey, Transaction);
}
else
{
throw new Exception("Selected Partner Classes cannot be merged!");
}
}
else if (AFromPartnerClass == TPartnerClass.PERSON)
{
if (AToPartnerClass == TPartnerClass.PERSON)
{
MergePerson(AFromPartnerKey, AToPartnerKey, ref ADifferentFamilies, Transaction);
}
else
{
throw new Exception("Selected Partner Classes cannot be merged!");
}
}
else if (AFromPartnerClass == TPartnerClass.ORGANISATION)
{
if (AToPartnerClass == TPartnerClass.CHURCH)
{
MergeOrganisationToChurch(AFromPartnerKey, AToPartnerKey, Transaction);
}
else if (AToPartnerClass == TPartnerClass.FAMILY)
{
MergeOrganisationToFamily(AFromPartnerKey, AToPartnerKey, Transaction);
}
else if (AToPartnerClass == TPartnerClass.BANK)
{
MergeOrganisationToBank(AFromPartnerKey, AToPartnerKey, Transaction);
}
else if (AToPartnerClass == TPartnerClass.ORGANISATION)
{
MergeOrganisation(AFromPartnerKey, AToPartnerKey, Transaction);
}
else
{
throw new Exception("Selected Partner Classes cannot be merged!");
}
}
else if (AFromPartnerClass == TPartnerClass.BANK)
{
if (AToPartnerClass == TPartnerClass.ORGANISATION)
{
MergeBankToOrganisation(AFromPartnerKey, AToPartnerKey, Transaction);
}
else if (AToPartnerClass == TPartnerClass.BANK)
{
MergeBank(AFromPartnerKey, AToPartnerKey, Transaction);
}
else
{
throw new Exception("Selected Partner Classes cannot be merged!");
}
}
if (ACategories[13] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Relationships"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeRelationships(AFromPartnerKey, AToPartnerKey, Transaction);
}
// merge PPartner records
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Partner (Common)"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergePartner(AFromPartnerKey, AToPartnerKey, Transaction);
if (ACategories[14] == true)
{
if (AFromPartnerClass == TPartnerClass.VENUE)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(),
Catalog.GetString("Merging: Venue - Buildings, Rooms and Allocations"), TrackerPercent * CurrentCategory);
MergeBuildingsAndRooms(AFromPartnerKey, AToPartnerKey, Transaction);
}
CurrentCategory++;
}
if (ACategories[15] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Partner - Bank Accounts"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeBankAccounts(AFromPartnerKey, AToPartnerKey, AMainBankingDetailsKey, Transaction);
}
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Partner - Bank Accounts"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeRecentAndLastPartnerInfo(AFromPartnerKey, AToPartnerKey, Transaction);
if (ACategories[16] == true)
{
if (TaxDeductiblePercentageEnabled
&& (((AFromPartnerClass == TPartnerClass.FAMILY) && (AToPartnerClass == TPartnerClass.FAMILY))
|| ((AFromPartnerClass == TPartnerClass.UNIT) && (AToPartnerClass == TPartnerClass.UNIT))))
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(),
Catalog.GetString("Merging: Tax Deductibility Percentage"),
TrackerPercent * CurrentCategory);
MergeTaxDeductibilityPercentage(AFromPartnerKey, AToPartnerKey, Transaction);
}
CurrentCategory++;
}
if (ACategories[17] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Link to Cost Centre"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeLinkToCostCentre(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (ACategories[18] == true)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(), Catalog.GetString("Merging: Graphic"),
TrackerPercent * CurrentCategory);
CurrentCategory++;
MergeGraphic(AFromPartnerKey, AToPartnerKey, Transaction);
}
if (TProgressTracker.GetCurrentState(DomainManager.GClientID.ToString()).CancelJob == true)
{
TProgressTracker.FinishJob(DomainManager.GClientID.ToString());
DBAccess.GDBAccessObj.RollbackTransaction();
throw new Exception("Partner merge was cancelled by the user");
}
DBAccess.GDBAccessObj.CommitTransaction();
TProgressTracker.FinishJob(DomainManager.GClientID.ToString());
//TODO MyWriter.Close();
}
catch (Exception e)
{
TLogging.Log(e.ToString());
DBAccess.GDBAccessObj.RollbackTransaction();
TProgressTracker.FinishJob(DomainManager.GClientID.ToString());
// TODO MyWriter.Close();
return false;
}
finally
{
TLogging.LogAtLevel(7, "TMergePartnersWebConnector.MergeTwoPartners: rollback own transaction.");
}
return true;
}
public static bool ActiveGiftDestination(long AFromPartnerKey,
long AToPartnerKey,
TPartnerClass APartnerClass,
out bool AFromGiftDestinationNeedsEnded,
out bool AToGiftDestinationNeedsEnded)
{
bool ReturnValue = true;
bool FromGiftDestinationNeedsEnded = false;
bool ToGiftDestinationNeedsEnded = false;
PPartnerGiftDestinationRow FromGiftDestinationRowNeedsEnded = null;
PPartnerGiftDestinationRow ToGiftDestinationRowNeedsEnded = null;
PPartnerGiftDestinationRow ActiveRow = null;
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.BeginAutoReadTransaction(IsolationLevel.ReadCommitted,
ref Transaction,
delegate
{
// if partners are Person's then find their family keys
if (APartnerClass == TPartnerClass.PERSON)
{
AFromPartnerKey = ((PPersonRow)PPersonAccess.LoadByPrimaryKey(AFromPartnerKey, Transaction).Rows[0]).FamilyKey;
AToPartnerKey = ((PPersonRow)PPersonAccess.LoadByPrimaryKey(AToPartnerKey, Transaction).Rows[0]).FamilyKey;
}
// check for an active gift destination for the 'From' partner
PPartnerGiftDestinationTable GiftDestinations = PPartnerGiftDestinationAccess.LoadViaPPartner(AFromPartnerKey, Transaction);
ActiveRow = GetActiveGiftDestination(GiftDestinations);
// return if no active record has been found
if (ActiveRow == null)
{
ReturnValue = false;
}
else
{
// check for clash with the 'To' partner
PPartnerGiftDestinationTable ToGiftDestinations = PPartnerGiftDestinationAccess.LoadViaPPartner(AToPartnerKey, Transaction);
CheckGiftDestinationClashes(ToGiftDestinations, ActiveRow, out FromGiftDestinationRowNeedsEnded,
out ToGiftDestinationRowNeedsEnded);
if (FromGiftDestinationRowNeedsEnded != null)
{
FromGiftDestinationNeedsEnded = true;
}
if (ToGiftDestinationRowNeedsEnded != null)
{
ToGiftDestinationNeedsEnded = true;
}
}
});
AFromGiftDestinationNeedsEnded = FromGiftDestinationNeedsEnded;
AToGiftDestinationNeedsEnded = ToGiftDestinationNeedsEnded;
return ReturnValue;
}
public static int CheckPartnerCommitments(long AFromPartnerKey, long AToPartnerKey, TPartnerClass APartnerClass)
{
PPersonTable FromPersonTable = null;
PPersonTable ToPersonTable = null;
int ReturnValue = 0;
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.BeginAutoReadTransaction(IsolationLevel.ReadCommitted,
ref Transaction,
delegate
{
if (APartnerClass == TPartnerClass.FAMILY)
{
FromPersonTable = PPersonAccess.LoadViaPFamily(AFromPartnerKey, Transaction);
ToPersonTable = PPersonAccess.LoadViaPFamily(AToPartnerKey, Transaction);
}
else if (APartnerClass == TPartnerClass.PERSON)
{
FromPersonTable = PPersonAccess.LoadViaPPartner(AFromPartnerKey, Transaction);
ToPersonTable = PPersonAccess.LoadViaPPartner(AToPartnerKey, Transaction);
}
// check if from partner has commitments
if (PersonHasCommitments(FromPersonTable, Transaction))
{
ReturnValue = 1;
// check if two persons are in same family
if ((APartnerClass == TPartnerClass.PERSON)
&& (((PPersonRow)FromPersonTable.Rows[0]).FamilyKey == ((PPersonRow)ToPersonTable.Rows[0]).FamilyKey))
{
ReturnValue = 3;
}
// check if to partner also has commitments
else if (PersonHasCommitments(ToPersonTable, Transaction))
{
ReturnValue = 2;
}
}
});
return ReturnValue;
}
// Check if selected partner class can be merged with any different partner classes
private void AllowedDifferentPartnerClasses(ref string AAllowedPartnerClasses, TPartnerClass ASelectedPartnerClass)
{
if (ASelectedPartnerClass == TPartnerClass.ORGANISATION)
{
AAllowedPartnerClasses += "," + TPartnerClass.FAMILY;
}
else if (ASelectedPartnerClass == TPartnerClass.FAMILY)
{
AAllowedPartnerClasses += "," + TPartnerClass.ORGANISATION;
}
if (ASelectedPartnerClass == TPartnerClass.ORGANISATION)
{
AAllowedPartnerClasses += "," + TPartnerClass.CHURCH;
}
else if (ASelectedPartnerClass == TPartnerClass.CHURCH)
{
AAllowedPartnerClasses += "," + TPartnerClass.ORGANISATION;
}
if (ASelectedPartnerClass == TPartnerClass.FAMILY)
{
AAllowedPartnerClasses += "," + TPartnerClass.CHURCH;
}
else if (ASelectedPartnerClass == TPartnerClass.CHURCH)
{
AAllowedPartnerClasses += "," + TPartnerClass.FAMILY;
}
if (ASelectedPartnerClass == TPartnerClass.ORGANISATION)
{
AAllowedPartnerClasses += "," + TPartnerClass.BANK;
}
else if (ASelectedPartnerClass == TPartnerClass.BANK)
{
AAllowedPartnerClasses += "," + TPartnerClass.ORGANISATION;
}
}
public static Boolean GetPartnerShortName(Int64 APartnerKey, out String APartnerShortName, out TPartnerClass APartnerClass)
{
return GetPartnerShortName(APartnerKey, out APartnerShortName, out APartnerClass, true);
}
public static Boolean MergedPartnerDetails(Int64 AMergedPartnerPartnerKey,
out String AMergedPartnerPartnerShortName,
out TPartnerClass AMergedPartnerPartnerClass,
out Int64 AMergedIntoPartnerKey,
out String AMergedIntoPartnerShortName,
out TPartnerClass AMergedIntoPartnerClass,
out String AMergedBy,
out DateTime AMergeDate)
{
TDBTransaction ReadTransaction;
Boolean NewTransaction;
StringCollection RequiredColumns;
PPartnerTable MergedPartnerTable;
PPartnerTable PartnerMergedIntoTable;
PPartnerMergeTable PartnerMergeTable;
Boolean ReturnValue = false;
// Initialise out Arguments
AMergedPartnerPartnerShortName = "";
AMergedPartnerPartnerClass = TPartnerClass.FAMILY; // Default. This is not really correct but the best compromise if PartnerKey is 0 or Partner isn't found since we have an enum here.
AMergedIntoPartnerKey = -1;
AMergedIntoPartnerShortName = "";
AMergedIntoPartnerClass = TPartnerClass.FAMILY; // Default. This is not really correct but the best compromise if PartnerKey is 0 or Partner isn't found since we have an enum here.
AMergedBy = "";
AMergeDate = DateTime.MinValue;
if (AMergedPartnerPartnerKey != 0)
{
/*
* First we look up the Partner that was Merged to get some details of it.
*/
// only some fields are needed
RequiredColumns = new StringCollection();
RequiredColumns.Add(PPartnerTable.GetPartnerShortNameDBName());
RequiredColumns.Add(PPartnerTable.GetStatusCodeDBName());
RequiredColumns.Add(PPartnerTable.GetPartnerClassDBName());
ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
out NewTransaction);
try
{
MergedPartnerTable = PPartnerAccess.LoadByPrimaryKey(
AMergedPartnerPartnerKey, RequiredColumns, ReadTransaction, null, 0, 0);
if (MergedPartnerTable.Rows.Count == 0)
{
ReturnValue = false;
}
else
{
if (SharedTypes.StdPartnerStatusCodeStringToEnum(
MergedPartnerTable[0].StatusCode) != TStdPartnerStatusCode.spscMERGED)
{
ReturnValue = false;
}
else
{
AMergedPartnerPartnerShortName = MergedPartnerTable[0].PartnerShortName;
AMergedPartnerPartnerClass = SharedTypes.PartnerClassStringToEnum(MergedPartnerTable[0].PartnerClass);
/*
* Now we look up the Partner that was Merged in the PartnerMerge DB Table
* to get the information about the Merged-Into Partner.
*/
PartnerMergeTable = PPartnerMergeAccess.LoadByPrimaryKey(AMergedPartnerPartnerKey, ReadTransaction);
if (PartnerMergeTable.Rows.Count == 0)
{
/*
* Although we didn't find the Merged Partner in the PartnerMerge
* DB Table it is still a valid, Merged Partner, so we return true
* in this case.
*/
ReturnValue = true;
}
else
{
/*
* Now we look up the Merged-Into Partner to get some details of it.
*/
PartnerMergedIntoTable = PPartnerAccess.LoadByPrimaryKey(
PartnerMergeTable[0].MergeTo, RequiredColumns,
ReadTransaction, null, 0, 0);
if (PartnerMergedIntoTable.Rows.Count == 0)
{
ReturnValue = false;
}
else
{
AMergedIntoPartnerKey = PartnerMergeTable[0].MergeTo;
AMergedBy = PartnerMergeTable[0].MergedBy;
AMergeDate = PartnerMergeTable[0].MergeDate.Value;
AMergedIntoPartnerShortName = PartnerMergedIntoTable[0].PartnerShortName;
AMergedIntoPartnerClass = SharedTypes.PartnerClassStringToEnum(PartnerMergedIntoTable[0].PartnerClass);
ReturnValue = true;
}
}
}
}
}
finally
{
if (NewTransaction)
{
DBAccess.GDBAccessObj.CommitTransaction();
TLogging.LogAtLevel(7, "TPartnerServerLookups.MergedPartnerDetails: committed own transaction.");
}
}
}
return ReturnValue;
}
public static string FormatHtmlReceipt(
String ADonorShortName,
Int64 ADonorKey,
TPartnerClass ADonorClass,
String AGiftCurrency,
string ALocalCountryCode,
AGiftTable AGiftsThisDonor,
string AHTMLTemplateFilename,
TDBTransaction ATransaction)
{
SortedList <string, List <string>>FormValues = new SortedList <string, List <string>>();
// These are the fields that can be printed in the letter:
FormValues.Add("AdresseeShortName", new List <string>());
FormValues.Add("AdresseeTitle", new List <string>());
FormValues.Add("AdresseeFirstName", new List <string>());
FormValues.Add("AdresseeFamilyName", new List <string>());
FormValues.Add("AdresseeStreetAddress", new List <string>());
FormValues.Add("AdresseeAddress3", new List <string>());
FormValues.Add("AdresseeCity", new List <string>());
FormValues.Add("AdresseePostCode", new List <string>());
FormValues.Add("AdresseeCountry", new List <string>());
FormValues.Add("FormattedAddress", new List <string>());
FormValues.Add("DateToday", new List <string>());
FormValues.Add("DateEntered", new List <string>());
FormValues.Add("GiftAmount", new List <string>());
FormValues.Add("GiftCurrency", new List <string>());
FormValues.Add("GiftTxd", new List <string>());
FormValues.Add("RecipientShortName", new List <string>());
FormValues.Add("MotivationDetail", new List <string>());
FormValues.Add("Reference", new List <string>());
FormValues.Add("DonorComment", new List <string>());
FormValues.Add("GiftTotalAmount", new List <string>());
FormValues.Add("GiftTotalCurrency", new List <string>());
FormValues.Add("TxdTotal", new List <string>());
FormValues.Add("NonTxdTotal", new List <string>());
// Donor Name:
FormValues["AdresseeShortName"].Add(ADonorShortName);
if (ADonorClass == TPartnerClass.PERSON)
{
PPersonTable Tbl = PPersonAccess.LoadByPrimaryKey(ADonorKey, ATransaction);
if (Tbl.Rows.Count > 0)
{
FormValues["AdresseeTitle"].Add(Tbl[0].Title);
FormValues["AdresseeFirstName"].Add(Tbl[0].FirstName);
FormValues["AdresseeFamilyName"].Add(Tbl[0].FamilyName);
}
}
else if (ADonorClass == TPartnerClass.FAMILY)
{
PFamilyTable Tbl = PFamilyAccess.LoadByPrimaryKey(ADonorKey, ATransaction);
if (Tbl.Rows.Count > 0)
{
FormValues["AdresseeTitle"].Add(Tbl[0].Title);
FormValues["AdresseeFirstName"].Add(Tbl[0].FirstName);
FormValues["AdresseeFamilyName"].Add(Tbl[0].FamilyName);
}
}
else
{
FormValues["AdresseeFamilyName"].Add(ADonorShortName);
}
FormValues["DateToday"].Add(DateTime.Now.ToString("dd MMMM yyyy"));
// Donor Adress:
PLocationTable Location;
string CountryName;
if (TAddressTools.GetBestAddress(ADonorKey, out Location, out CountryName, ATransaction))
{
PLocationRow LocRow = Location[0];
FormValues["AdresseeStreetAddress"].Add(LocRow.StreetName);
FormValues["AdresseeAddress3"].Add(LocRow.Address3);
FormValues["AdresseeCity"].Add(LocRow.City);
FormValues["AdresseePostCode"].Add(LocRow.PostalCode);
if (LocRow.CountryCode != ALocalCountryCode) // Don't add the Donor's country if it's also my country:
{
FormValues["AdresseeCountry"].Add(CountryName);
}
else
{
LocRow.CountryCode = "";
}
FormValues["FormattedAddress"].Add(Calculations.DetermineLocationString(LocRow,
Calculations.TPartnerLocationFormatEnum.plfHtmlLineBreak));
}
decimal GiftTotal = 0;
decimal TxdTotal = 0;
decimal NonTxdTotal = 0;
// Details per gift:
foreach (AGiftRow GiftRow in AGiftsThisDonor.Rows)
{
String DateEntered = GiftRow.DateEntered.ToString("dd MMM yyyy");
String GiftReference = GiftRow.Reference;
AGiftDetailTable DetailTbl = AGiftDetailAccess.LoadViaAGift(
GiftRow.LedgerNumber, GiftRow.BatchNumber, GiftRow.GiftTransactionNumber, ATransaction);
foreach (AGiftDetailRow DetailRow in DetailTbl.Rows)
{
FormValues["Reference"].Add(GiftReference);
FormValues["DateEntered"].Add(DateEntered);
GiftReference = ""; // Date and Reference are one-per-gift, not per detail
DateEntered = ""; // so if this gift has several details, I'll blank the subsequent lines.
string DonorComment = "";
FormValues["GiftAmount"].Add(StringHelper.FormatUsingCurrencyCode(DetailRow.GiftTransactionAmount, AGiftCurrency));
FormValues["GiftCurrency"].Add(AGiftCurrency);
FormValues["MotivationDetail"].Add(DetailRow.MotivationDetailCode);
GiftTotal += DetailRow.GiftTransactionAmount;
if (DetailRow.TaxDeductible)
{
FormValues["GiftTxd"].Add("Y");
TxdTotal += DetailRow.GiftTransactionAmount;
}
else
{
FormValues["GiftTxd"].Add(" ");
NonTxdTotal += DetailRow.GiftTransactionAmount;
}
// Recipient Short Name:
PPartnerTable RecipientTbl = PPartnerAccess.LoadByPrimaryKey(DetailRow.RecipientKey, ATransaction);
if (RecipientTbl.Rows.Count > 0)
{
String ShortName = Calculations.FormatShortName(RecipientTbl[0].PartnerShortName, eShortNameFormat.eReverseShortname);
FormValues["RecipientShortName"].Add(ShortName);
}
if (DetailRow.CommentOneType == "Donor")
{
DonorComment += DetailRow.GiftCommentOne;
}
if (DetailRow.CommentTwoType == "Donor")
{
if (DonorComment != "")
{
DonorComment += "\r\n";
}
DonorComment += DetailRow.GiftCommentTwo;
}
if (DetailRow.CommentThreeType == "Donor")
{
if (DonorComment != "")
{
DonorComment += "\r\n";
}
DonorComment += DetailRow.GiftCommentThree;
}
if (DonorComment != "")
{
DonorComment = "Comment: " + DonorComment;
}
FormValues["DonorComment"].Add(DonorComment);
} // foreach GiftDetail
} // foreach Gift
FormValues["GiftTotalAmount"].Add(StringHelper.FormatUsingCurrencyCode(GiftTotal, AGiftCurrency));
FormValues["GiftTotalCurrency"].Add(AGiftCurrency);
FormValues["TxdTotal"].Add(StringHelper.FormatUsingCurrencyCode(TxdTotal, AGiftCurrency));
FormValues["NonTxdTotal"].Add(StringHelper.FormatUsingCurrencyCode(NonTxdTotal, AGiftCurrency));
return TFormLettersTools.PrintSimpleHTMLLetter(AHTMLTemplateFilename, FormValues);
}
public static string PrintGiftReceipt(
String AGiftCurrency,
String ADonorShortName,
Int64 ADonorKey,
TPartnerClass ADonorClass,
AGiftTable GiftsThisDonor,
string AHTMLTemplateFilename
)
{
string HtmlDoc = string.Empty;
TDBTransaction Transaction = null;
try
{
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
ref Transaction,
delegate
{
string LocalCountryCode = TAddressTools.GetCountryCodeFromSiteLedger(Transaction);
HtmlDoc = FormatHtmlReceipt(
ADonorShortName,
ADonorKey,
ADonorClass,
AGiftCurrency,
LocalCountryCode,
GiftsThisDonor,
AHTMLTemplateFilename,
Transaction);
});
}
catch (Exception ex)
{
TLogging.Log(String.Format("Method:{0} - Unexpected error!{1}{1}{2}",
Utilities.GetMethodSignature(),
Environment.NewLine,
ex.Message));
throw ex;
}
return HtmlDoc;
}
public static void FillFormDataFromApplicant(Int64 AEventPartnerKey, Int64 APartnerKey,
TFormDataApplicant AFormDataApplicant,
TFormLetterInfo AFormLetterInfo,
TDBTransaction AReadTransaction,
Int64 ASiteKey = 0,
Int32 ALocationKey = 0)
{
TPartnerClass PartnerClass;
String ShortName;
TStdPartnerStatusCode PartnerStatusCode;
if (AFormDataApplicant == null)
{
return;
}
if (MCommonMain.RetrievePartnerShortName(APartnerKey, out ShortName, out PartnerClass, out PartnerStatusCode, AReadTransaction))
{
// first retrieve all personnel information
TFormLettersPersonnelWebConnector.FillFormDataFromPersonnel(APartnerKey,
AFormDataApplicant,
AFormLetterInfo,
AReadTransaction,
ASiteKey,
ALocationKey);
// retrieve Applicant information
PmShortTermApplicationTable ShortTermAppTable;
PmShortTermApplicationRow ShortTermAppRow;
PmShortTermApplicationRow template = new PmShortTermApplicationTable().NewRowTyped(false);
template.PartnerKey = APartnerKey;
template.StConfirmedOption = AEventPartnerKey;
ShortTermAppTable = PmShortTermApplicationAccess.LoadUsingTemplate(template, AReadTransaction);
if (ShortTermAppTable.Count > 0)
{
ShortTermAppRow = (PmShortTermApplicationRow)ShortTermAppTable.Rows[0];
AFormDataApplicant.EventPartnerKey = AEventPartnerKey.ToString("0000000000");
AFormDataApplicant.ArrivalDate = ShortTermAppRow.Arrival;
AFormDataApplicant.ArrivalTime = new DateTime(ShortTermAppRow.Arrival == null ? 0 : ((DateTime)ShortTermAppRow.Arrival).Year,
ShortTermAppRow.Arrival == null ? 0 : ((DateTime)ShortTermAppRow.Arrival).Month,
ShortTermAppRow.Arrival == null ? 0 : ((DateTime)ShortTermAppRow.Arrival).Day,
ShortTermAppRow.ArrivalHour, ShortTermAppRow.ArrivalMinute, 0);
AFormDataApplicant.ArrivalFlightNumber = ShortTermAppRow.FromCongTravelInfo;
AFormDataApplicant.ArrivalComment = ShortTermAppRow.ArrivalComments;
AFormDataApplicant.DepartureDate = ShortTermAppRow.Departure;
AFormDataApplicant.DepartureTime = new DateTime(ShortTermAppRow.Departure == null ? 0 : ((DateTime)ShortTermAppRow.Arrival).Year,
ShortTermAppRow.Departure == null ? 0 : ((DateTime)ShortTermAppRow.Arrival).Month,
ShortTermAppRow.Departure == null ? 0 : ((DateTime)ShortTermAppRow.Arrival).Day,
ShortTermAppRow.DepartureHour, ShortTermAppRow.DepartureMinute, 0);
AFormDataApplicant.DepartureFlightNumber = ShortTermAppRow.ToCongTravelInfo;
AFormDataApplicant.DepartureComment = ShortTermAppRow.DepartureComments;
AFormDataApplicant.EventRole = ShortTermAppRow.StCongressCode;
AFormDataApplicant.CampaignType = ShortTermAppRow.ConfirmedOptionCode.Substring(5, 6);
AFormDataApplicant.FellowshipGroup = ShortTermAppRow.StFgCode;
TPartnerClass PartnerClassDummy = new TPartnerClass();
AFormDataApplicant.ChargedFieldKey = ShortTermAppRow.StFieldCharged.ToString("0000000000");
string chargedFieldName = "";
if (!ShortTermAppRow.IsStCurrentFieldNull())
{
TPartnerServerLookups.GetPartnerShortName(ShortTermAppRow.StCurrentField, out chargedFieldName, out PartnerClassDummy);
}
AFormDataApplicant.SendingFieldName = chargedFieldName;
/*ApplicantFormData.SendingFieldKey = ShortTermAppRow.StCurrentField.ToString("0000000000");
*
*
* string sendingFieldName;
* TPartnerServerLookups.GetPartnerShortName(ShortTermAppRow.StCurrentField, out sendingFieldName, out PartnerClassDummy);
* ApplicantFormData.SendingFieldName = sendingFieldName;*/
//TODO: SendingFieldKey & -name; ReceivingFieldKey & -name
PmGeneralApplicationTable GeneralAppTable;
PmGeneralApplicationRow GeneralAppRow;
GeneralAppTable = PmGeneralApplicationAccess.LoadByPrimaryKey(APartnerKey,
ShortTermAppRow.ApplicationKey,
ShortTermAppRow.RegistrationOffice,
AReadTransaction);
if (GeneralAppTable.Count > 0)
{
GeneralAppRow = (PmGeneralApplicationRow)GeneralAppTable.Rows[0];
AFormDataApplicant.RegistrationDate = GeneralAppRow.GenAppDate;
AFormDataApplicant.ApplicationComment = GeneralAppRow.Comment;
}
}
}
}
/// <summary>
/// Load all the data of a partner into a TDS
/// </summary>
public static PartnerImportExportTDS ExportPartner(Int64 APartnerKey, TPartnerClass? APartnerClass = null)
{
PartnerImportExportTDS MainDS = new PartnerImportExportTDS();
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum,
ref Transaction,
delegate
{
PPartnerAccess.LoadByPrimaryKey(MainDS, APartnerKey, Transaction);
// APartnerClass is optional but if it was not provided we need to assign to it now
if (APartnerClass == null)
{
APartnerClass = SharedTypes.PartnerClassStringToEnum(MainDS.PPartner[0].PartnerClass);
}
if (APartnerClass == TPartnerClass.CHURCH)
{
PChurchAccess.LoadByPrimaryKey(MainDS, APartnerKey, Transaction);
}
else if (APartnerClass == TPartnerClass.FAMILY)
{
PFamilyAccess.LoadByPrimaryKey(MainDS, APartnerKey, Transaction);
PPartnerGiftDestinationAccess.LoadViaPPartner(MainDS, APartnerKey, Transaction);
}
else if (APartnerClass == TPartnerClass.PERSON)
{
PPersonAccess.LoadByPrimaryKey(MainDS, APartnerKey, Transaction);
PmPersonalDataAccess.LoadByPrimaryKey(MainDS, APartnerKey, Transaction);
PmPassportDetailsAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
PmDocumentAccess.LoadViaPPartner(MainDS, APartnerKey, Transaction);
PmDocumentTypeAccess.LoadAll(MainDS, Transaction);
PmPersonQualificationAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
PmSpecialNeedAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
PmPastExperienceAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
PmPersonLanguageAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
PmPersonAbilityAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
PmStaffDataAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
PmJobAssignmentAccess.LoadViaPPartner(MainDS, APartnerKey, Transaction);
PmPersonEvaluationAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
PmGeneralApplicationAccess.LoadViaPPersonPartnerKey(MainDS, APartnerKey, Transaction);
PtApplicationTypeAccess.LoadAll(MainDS, Transaction);
PmShortTermApplicationAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
PmYearProgramApplicationAccess.LoadViaPPerson(MainDS, APartnerKey, Transaction);
}
else if (APartnerClass == TPartnerClass.ORGANISATION)
{
POrganisationAccess.LoadByPrimaryKey(MainDS, APartnerKey, Transaction);
}
else if (APartnerClass == TPartnerClass.UNIT)
{
PUnitAccess.LoadByPrimaryKey(MainDS, APartnerKey, Transaction);
UmUnitStructureAccess.LoadViaPUnitChildUnitKey(MainDS, APartnerKey, Transaction);
UmUnitAbilityAccess.LoadViaPUnit(MainDS, APartnerKey, Transaction);
UmUnitLanguageAccess.LoadViaPUnit(MainDS, APartnerKey, Transaction);
UmUnitCostAccess.LoadViaPUnit(MainDS, APartnerKey, Transaction);
UmJobAccess.LoadViaPUnit(MainDS, APartnerKey, Transaction);
UmJobRequirementAccess.LoadViaPUnit(MainDS, APartnerKey, Transaction);
UmJobLanguageAccess.LoadViaPUnit(MainDS, APartnerKey, Transaction);
UmJobQualificationAccess.LoadViaPUnit(MainDS, APartnerKey, Transaction);
}
else if (APartnerClass == TPartnerClass.VENUE)
{
PVenueAccess.LoadByPrimaryKey(MainDS, APartnerKey, Transaction);
PcBuildingAccess.LoadViaPVenue(MainDS, APartnerKey, Transaction);
PcRoomAccess.LoadViaPVenue(MainDS, APartnerKey, Transaction);
}
PPartnerAttributeAccess.LoadViaPPartner(MainDS, APartnerKey, Transaction);
PLocationAccess.LoadViaPPartner(MainDS, APartnerKey, Transaction);
PPartnerLocationAccess.LoadViaPPartner(MainDS, APartnerKey, Transaction);
PPartnerCommentAccess.LoadViaPPartner(MainDS, APartnerKey, Transaction);
PPartnerTypeAccess.LoadViaPPartner(MainDS, APartnerKey, Transaction);
PPartnerInterestAccess.LoadViaPPartner(MainDS, APartnerKey, Transaction);
PInterestAccess.LoadAll(MainDS, Transaction);
});
return MainDS;
}
/// <summary>
/// Get short name for a partner. Boolean returns result if partner was found.
///
/// @Comment Calling this function should soon be no longer necessary since it
/// can be replaced with a call to Ict.Petra.Client.App.Core.ServerLookups!
///
/// </summary>
/// <param name="APartnerKey">PartnerKey to find the short name for</param>
/// <param name="APartnerShortName">short name found for partner key</param>
/// <param name="APartnerClass">Partner Class for partner that was found</param>
/// <returns>true if Partner was found in DB, otherwise false
/// </returns>
public Boolean GetPartnerShortName(Int64 APartnerKey, out String APartnerShortName, out TPartnerClass APartnerClass)
{
TStdPartnerStatusCode PartnerStatus;
return MCommonMain.RetrievePartnerShortName(APartnerKey, out APartnerShortName, out APartnerClass, out PartnerStatus);
}
public static bool CheckPartnersCanBeMerged(long AFromPartnerKey,
long AToPartnerKey,
TPartnerClass AFromPartnerClass,
TPartnerClass AToPartnerClass,
string AReasonForMerging,
out TVerificationResultCollection AVerificationResult)
{
AVerificationResult = new TVerificationResultCollection();
if (AFromPartnerClass != AToPartnerClass)
{
// confirm that user wants to merge partners from different partner classes
AVerificationResult.Add(new TVerificationResult(Catalog.GetString("Merge Partners"),
String.Format(Catalog.GetString("Do you really want to merge a Partner of class {0} into a Partner of class {1}?"),
AFromPartnerClass, AToPartnerClass),
TResultSeverity.Resv_Noncritical));
// Family Partner cannot be merged into a different partner class if family members, donations or bank accounts exist for that partner
if (AFromPartnerClass == TPartnerClass.FAMILY)
{
int FamilyMergeResult = CanFamilyMergeIntoDifferentClass(AFromPartnerKey);
if (FamilyMergeResult != 0)
{
string ErrorMessage = "";
if (FamilyMergeResult == 1)
{
ErrorMessage = Catalog.GetString(
"This Family record cannot be merged into a Partner with different class as Family members exist!");
}
else if (FamilyMergeResult == 2)
{
ErrorMessage = Catalog.GetString(
"This Family record cannot be merged into a Partner with different class as donations were received for it!");
}
else if (FamilyMergeResult == 3)
{
ErrorMessage = Catalog.GetString(
"This record cannot be merged into a Partner with different class as bank accounts exist for it!");
}
// critical error - only need to return this VerificationResult
AVerificationResult.Clear();
AVerificationResult.Add(new TVerificationResult(Catalog.GetString("Merge Partners"),
ErrorMessage,
TResultSeverity.Resv_Critical));
return false;
}
}
}
else // partner classes are the same
{
string FromPartnerSupplierCurrency;
string ToPartnerSupplierCurrency;
// if two partners are suppliers they must have the same currency
if ((GetSupplierCurrency(AFromPartnerKey, out FromPartnerSupplierCurrency) == true)
&& (GetSupplierCurrency(AToPartnerKey, out ToPartnerSupplierCurrency) == true))
{
if (FromPartnerSupplierCurrency != ToPartnerSupplierCurrency)
{
// critical error - only need to return this VerificationResult
AVerificationResult.Clear();
AVerificationResult.Add(new TVerificationResult(Catalog.GetString("Merge Partners"),
Catalog.GetString(
"These Partners cannot be merged. Partners that are suppliers must have the same currency in order to merge."),
TResultSeverity.Resv_Critical));
return false;
}
}
if (AFromPartnerClass == TPartnerClass.VENUE)
{
AVerificationResult.Add(new TVerificationResult(Catalog.GetString("Merge Partners"),
Catalog.GetString("You are about to merge VENUEs. This will imply merging of buildings, rooms and room " +
"allocations defined for these Venues in the Conference Module!") + "\n\n" + Catalog.GetString("Continue?"),
TResultSeverity.Resv_Noncritical));
}
if (AFromPartnerClass == TPartnerClass.BANK)
{
AVerificationResult.Add(new TVerificationResult(Catalog.GetString("Merge Partners"),
Catalog.GetString("You are about to merge BANKSs. This will imply that all bank accounts that were with the " +
"From-Bank Partner will become bank accounts of the To-Bank Partner. For this reason you should merge Banks only when "
+
"both Bank Partners actually represented the same Bank, or if two different Banks have merged their operations!") +
"\n\n" + Catalog.GetString("Continue?"), Catalog.GetString("Merge Partners"),
TResultSeverity.Resv_Noncritical));
}
}
if (AReasonForMerging == "Duplicate Record Exists")
{
if (AFromPartnerClass == TPartnerClass.FAMILY)
{
// AFromPartnerClass and AToPartnerClass are the same
int CheckCommitmentsResult = CheckPartnerCommitments(AFromPartnerKey, AToPartnerKey, AFromPartnerClass);
// if the from family Partner contains a person with an ongoing commitment
if (CheckCommitmentsResult != 0)
{
string FromPartnerShortName;
string ToPartnerShortName;
TPartnerClass PartnerClass;
TPartnerServerLookups.GetPartnerShortName(AFromPartnerKey, out FromPartnerShortName, out PartnerClass);
TPartnerServerLookups.GetPartnerShortName(AFromPartnerKey, out ToPartnerShortName, out PartnerClass);
string ErrorMessage = string.Format(Catalog.GetString("WARNING: You are about to change the family of {0} ({1}).") + "\n\n" +
Catalog.GetString(
"Changing a person's family can affect the person's ability to see their support information in" +
" the Intranet including any support that they may receive from other Fields."), FromPartnerShortName,
AFromPartnerKey);
if (CheckCommitmentsResult == 1)
{
ErrorMessage += "\n\n" + string.Format(Catalog.GetString("It is STRONGLY recommended that you do not continue and " +
"consider merging family {0} ({1}) into family {2} ({3})."),
ToPartnerShortName, AToPartnerKey, FromPartnerShortName, AFromPartnerKey);
}
ErrorMessage += "\n\n" + Catalog.GetString("Do you want to continue?");
AVerificationResult.Add(new TVerificationResult(Catalog.GetString("Merge Partners"),
ErrorMessage, Catalog.GetString("Merge Partners"),
TResultSeverity.Resv_Noncritical));
}
}
else if (AFromPartnerClass == TPartnerClass.PERSON)
{
// AFromPartnerClass and AToPartnerClass are the same
int CheckCommitmentsResult = CheckPartnerCommitments(AFromPartnerKey, AToPartnerKey, AFromPartnerClass);
// if the from Partner has an ongoing commitment
if (CheckCommitmentsResult != 0)
{
string ErrorMessage = "";
string FromPartnerShortName;
TPartnerClass PartnerClass;
TPartnerServerLookups.GetPartnerShortName(AFromPartnerKey, out FromPartnerShortName, out PartnerClass);
if (CheckCommitmentsResult == 3)
{
ErrorMessage = string.Format(Catalog.GetString("WARNING: You are about to change the family of {0} ({1}).") + "\n\n" +
Catalog.GetString(
"Changing a person's family can affect the person's ability to see their support information in" +
" the Intranet including any support that they may receive from other Fields."), FromPartnerShortName,
AFromPartnerKey);
}
else if (CheckCommitmentsResult == 2)
{
ErrorMessage = Catalog.GetString("WARNING: Both Persons have a current commitment. " +
"Be aware that merging these Persons may affect their usage of the Intranet.") +
"\n\n" + Catalog.GetString("Do you want to continue?");
}
else if (CheckCommitmentsResult == 1)
{
ErrorMessage = string.Format(Catalog.GetString("WARNING: Person {0} ({1}) has a current commitment. " +
"We strongly recommend merging the other way around."), FromPartnerShortName, AFromPartnerKey) +
"\n\n" + Catalog.GetString("Do you want to continue?");
}
AVerificationResult.Add(new TVerificationResult(Catalog.GetString("Merge Partners"),
ErrorMessage, Catalog.GetString("Merge Partners"),
TResultSeverity.Resv_Noncritical));
}
}
}
// checks if one of the partners is a Foundation organisation.
if ((AFromPartnerClass == TPartnerClass.ORGANISATION) || (AToPartnerClass == TPartnerClass.ORGANISATION))
{
PFoundationTable FromFoundationTable = null;
PFoundationTable ToFoundationTable = null;
string ErrorMessage = "";
if (AFromPartnerClass == TPartnerClass.ORGANISATION)
{
FromFoundationTable = GetOrganisationFoundation(AFromPartnerKey);
}
if (AToPartnerClass == TPartnerClass.ORGANISATION)
{
ToFoundationTable = GetOrganisationFoundation(AToPartnerKey);
}
// if both partners are Foundation organisations check permissions
if ((FromFoundationTable != null) && (ToFoundationTable != null))
{
if (!TSecurity.CheckFoundationSecurity((PFoundationRow)FromFoundationTable.Rows[0]))
{
ErrorMessage = Catalog.GetString("The Partner that you are merging from is a Foundation, but you do not " +
"have access rights to view its data. Therefore you are not allowed to merge these Foundations!") + "\n\n" +
Catalog.GetString("Access Denied");
}
else if (!TSecurity.CheckFoundationSecurity((PFoundationRow)ToFoundationTable.Rows[0]))
{
ErrorMessage = Catalog.GetString("The Partner that you are merging into is a Foundation, but you do not " +
"have access rights to view its data. Therefore you are not allowed to merge these Foundations!") + "\n\n" +
Catalog.GetString("Access Denied");
}
}
// none or both partners must be Foundation organisations
else if (FromFoundationTable != null)
{
ErrorMessage = Catalog.GetString("The Partner that you are merging from is a Foundation, but the Partner that you " +
"are merging into is not a Foundation. This is not allowed!") + "\n\n" +
Catalog.GetString("Both Merge Partners Need to be Foundations!");
}
else if (ToFoundationTable != null)
{
ErrorMessage = Catalog.GetString("The Partner that you are merging from isn't a Foundation, but the Partner that you " +
"are merging into is a Foundation. This is not allowed!") + "\n\n" +
Catalog.GetString("Both Merge Partners Need to be Foundations!");
}
if (ErrorMessage != "")
{
// critical error - only need to return this VerificationResult
AVerificationResult.Clear();
AVerificationResult.Add(new TVerificationResult(Catalog.GetString("Merge Partners"),
ErrorMessage,
TResultSeverity.Resv_Critical));
return false;
}
}
return true;
}
public static Boolean VerifyPartner(Int64 APartnerKey,
TPartnerClass[] AValidPartnerClasses,
out bool APartnerExists,
out String APartnerShortName,
out TPartnerClass APartnerClass,
out Boolean AIsMergedPartner)
{
Boolean ReturnValue;
TStdPartnerStatusCode PartnerStatus;
ReturnValue = APartnerExists = MCommonMain.RetrievePartnerShortName(APartnerKey,
out APartnerShortName,
out APartnerClass,
out PartnerStatus);
// TLogging.LogAtLevel(7, "TPartnerServerLookups.VerifyPartner: " + Convert.ToInt32(AValidPartnerClasses.Length));
if (AValidPartnerClasses.Length != 0)
{
if (Array.BinarySearch(AValidPartnerClasses, APartnerClass) < 0)
{
ReturnValue = false;
}
}
if (PartnerStatus == TStdPartnerStatusCode.spscMERGED)
{
AIsMergedPartner = true;
}
else
{
AIsMergedPartner = false;
}
return ReturnValue;
}
private void LoadData(Boolean ADelayedDataLoading, TPartnerEditTabPageEnum ATabPage)
{
PartnerEditTDSMiscellaneousDataTable MiscellaneousDataDT;
PartnerEditTDSMiscellaneousDataRow MiscellaneousDataDR;
TDBTransaction ReadTransaction;
DateTime LastGiftDate;
DateTime LastContactDate;
String LastGiftInfo;
TLocationPK LocationPK;
Boolean OfficeSpecificDataLabelsAvailable = false;
Int32 ItemsCountAddresses = 0;
Int32 ItemsCountAddressesActive = 0;
Int32 ItemsCountContactDetails = -1;
Int32 ItemsCountContactDetailsActive = -1;
Int32 ItemsCountSubscriptions = 0;
Int32 ItemsCountSubscriptionsActive = 0;
Int32 ItemsCountPartnerTypes = 0;
Int32 ItemsCountPartnerRelationships = 0;
Int32 ItemsCountFamilyMembers = 0;
Int32 ItemsCountPartnerInterests = 0;
Int32 ItemsCountInterests = 0;
Int32 ItemsCountPartnerBankingDetails = 0;
Int32 ItemsCountContacts = 0;
Int64 FoundationOwner1Key = 0;
Int64 FoundationOwner2Key = 0;
bool HasEXWORKERPartnerType = false;
// TLogging.LogAtLevel(7, "TPartnerEditUIConnector.LoadData called. ADelayedDataLoading: " + ADelayedDataLoading.ToString() + "; ATabPage: " +
// Enum.GetName(typeof(TPartnerEditTabPageEnum), ATabPage));
// create the FPartnerEditScreenDS DataSet that will later be passed to the Client
FPartnerEditScreenDS = new PartnerEditTDS(DATASETNAME);
try
{
ReadTransaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.RepeatableRead, 5);
try
{
#region Load data using the DataStore
// Partner
PPartnerAccess.LoadByPrimaryKey(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
if (FPartnerEditScreenDS.PPartner.Rows.Count != 0)
{
FPartnerClass = SharedTypes.PartnerClassStringToEnum(FPartnerEditScreenDS.PPartner[0].PartnerClass);
}
else
{
throw new EPartnerNotExistantException();
}
/*
* For Partners that aren't ORGANISATIONs we can check access to the Partner here.
* For Partners that *are* ORGANISATIONS we need to do a more elaborate check
* further down the code of this Method!
*/
if (FPartnerClass != TPartnerClass.ORGANISATION)
{
/*
* Check if access to Partner is granted; if not, an
* ESecurityPartnerAccessDeniedException will be thrown by the called Method!
*/
Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartnerExc(FPartnerEditScreenDS.PPartner[0], false, null);
}
// Partner Types
FPartnerEditScreenDS.Merge(GetPartnerTypesInternal(out ItemsCountPartnerTypes, false));
if ((ADelayedDataLoading) && (ATabPage != TPartnerEditTabPageEnum.petpPartnerTypes))
{
// Empty Tables again, we don't want to transfer the data contained in them
FPartnerEditScreenDS.PPartnerType.Rows.Clear();
}
// Subscriptions
FPartnerEditScreenDS.Merge(GetSubscriptionsInternal(out ItemsCountSubscriptions, false));
if ((ADelayedDataLoading) && (ATabPage != TPartnerEditTabPageEnum.petpSubscriptions))
{
// Only count Subscriptions
Calculations.CalculateTabCountsSubscriptions(FPartnerEditScreenDS.PSubscription,
out ItemsCountSubscriptions,
out ItemsCountSubscriptionsActive);
// Empty Tables again, we don't want to transfer the data contained in them
FPartnerEditScreenDS.PSubscription.Rows.Clear();
}
// Partner Attributes - those always need to get loaded!
FPartnerEditScreenDS.Merge(PPartnerAttributeAccess.LoadViaPPartner(FPartnerKey, ReadTransaction));
// Contact Details
GetPartnerContactDetailsInternal(out ItemsCountContactDetails);
if ((ADelayedDataLoading) && (ATabPage != TPartnerEditTabPageEnum.petpContactDetails))
{
// Count Contact Details
Calculations.CalculateTabCountsPartnerContactDetails(FPartnerEditScreenDS.PPartnerAttribute,
out ItemsCountContactDetails, out ItemsCountContactDetailsActive);
}
// Partner Relationships
FPartnerEditScreenDS.Merge(GetPartnerRelationshipsInternal(out ItemsCountPartnerRelationships, false));
if ((ADelayedDataLoading) && (ATabPage != TPartnerEditTabPageEnum.petpPartnerRelationships))
{
// Only count Relationships
Calculations.CalculateTabCountsPartnerRelationships(FPartnerEditScreenDS.PPartnerRelationship,
out ItemsCountPartnerRelationships);
// Empty Tables again, we don't want to transfer the data contained in them
FPartnerEditScreenDS.PPartnerRelationship.Rows.Clear();
}
// Locations and PartnerLocations
TLogging.LogAtLevel(9, "TPartnerEditUIConnector.LoadData: Before TPPartnerAddressAggregate.LoadAll");
TPPartnerAddressAggregate.LoadAll(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
if (FKeyForSelectingPartnerLocation.LocationKey > 0)
{
if (FPartnerEditScreenDS.PPartnerLocation.Rows.Find(new Object[] { FPartnerKey, FKeyForSelectingPartnerLocation.SiteKey,
FKeyForSelectingPartnerLocation.LocationKey }) == null)
{
throw new EPartnerLocationNotExistantException(
"PartnerLocation SiteKey " + FKeyForSelectingPartnerLocation.SiteKey.ToString() + " and LocationKey " +
FKeyForSelectingPartnerLocation.LocationKey.ToString());
}
}
if (((!ADelayedDataLoading)) || (ATabPage == TPartnerEditTabPageEnum.petpAddresses))
{
// Determination of the address list icons and the 'best' address (these calls change certain columns in some rows!)
Calculations.DeterminePartnerLocationsDateStatus((DataSet)FPartnerEditScreenDS);
LocationPK = Calculations.DetermineBestAddress((DataSet)FPartnerEditScreenDS);
}
else
{
// Only count
Calculations.CalculateTabCountsAddresses(FPartnerEditScreenDS.PPartnerLocation,
out ItemsCountAddresses,
out ItemsCountAddressesActive);
// Empty Tables again, we don't want to transfer the data contained in them
FPartnerEditScreenDS.PLocation.Rows.Clear();
FPartnerEditScreenDS.PPartnerLocation.Rows.Clear();
// location will be determined correctly on the Client side...
LocationPK = new TLocationPK(0, 0);
}
// PartnerInterests
if (((!ADelayedDataLoading)) || (ATabPage == TPartnerEditTabPageEnum.petpInterests))
{
DataRow InterestRow;
// Load data for Interests
FPartnerEditScreenDS.Merge(GetPartnerInterestsInternal(out ItemsCountPartnerInterests, false));
FPartnerEditScreenDS.Merge(GetInterestsInternal(out ItemsCountInterests, false));
// fill field for interest category in PartnerInterest table in dataset
foreach (PartnerEditTDSPPartnerInterestRow row in FPartnerEditScreenDS.PPartnerInterest.Rows)
{
InterestRow = FPartnerEditScreenDS.PInterest.Rows.Find(new object[] { row.Interest });
if (InterestRow != null)
{
row.InterestCategory = ((PInterestRow)InterestRow).Category;
}
}
}
else
{
// Only count Interests
GetPartnerInterestsInternal(out ItemsCountPartnerInterests, true);
}
#region Partner Details data according to PartnerClass
switch (FPartnerClass)
{
case TPartnerClass.PERSON:
// Disable some constraints that relate to other tables in the DataSet that are not filled with data.
// This applies for the DataTables that exist for a certain Partner Class, eg. Person, where all other
// DataTables that represent certain Partner Classes are not filled.
FPartnerEditScreenDS.DisableConstraint("FKPerson2");
// points to PFamily
FPartnerEditScreenDS.DisableConstraint("FKPerson4");
// points to PUnit
TLogging.LogAtLevel(9, "Disabled Constraints in Typed DataSet PartnerEditTDS.");
PPersonAccess.LoadByPrimaryKey(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
// Gift Destination
PPartnerGiftDestinationAccess.LoadViaPPartner(FPartnerEditScreenDS,
FPartnerEditScreenDS.PPerson[0].FamilyKey,
ReadTransaction);
// Determine whether the Partner has a 'EX-WORKER*' Partner Type
HasEXWORKERPartnerType = Ict.Petra.Shared.MPartner.Checks.PartnerIsExWorker(FPartnerEditScreenDS.PPartnerGiftDestination);
if (((!ADelayedDataLoading)) || (ATabPage == TPartnerEditTabPageEnum.petpFamilyMembers))
{
// Load data for Family Members
FPartnerEditScreenDS.Merge(GetFamilyMembersInternal(FPartnerEditScreenDS.PPerson[0].FamilyKey, "",
out ItemsCountFamilyMembers, false));
}
else
{
// Only count Family Members
GetFamilyMembersInternal(FPartnerEditScreenDS.PPerson[0].FamilyKey, "", out ItemsCountFamilyMembers, true);
}
break;
case TPartnerClass.FAMILY:
PFamilyAccess.LoadByPrimaryKey(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
// Gift Destination
PPartnerGiftDestinationAccess.LoadViaPPartner(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
// Determine whether the Partner has a 'EX-WORKER*' Partner Type
HasEXWORKERPartnerType = Ict.Petra.Shared.MPartner.Checks.PartnerIsExWorker(FPartnerEditScreenDS.PPartnerGiftDestination);
if (((!ADelayedDataLoading)) || (ATabPage == TPartnerEditTabPageEnum.petpFamilyMembers))
{
// Load data for Family Members
FPartnerEditScreenDS.Merge(GetFamilyMembersInternal(FPartnerEditScreenDS.PFamily[0].PartnerKey, "",
out ItemsCountFamilyMembers, false));
}
else
{
// Only count Family Members
GetFamilyMembersInternal(FPartnerEditScreenDS.PFamily[0].PartnerKey, "", out ItemsCountFamilyMembers, true);
}
break;
case TPartnerClass.CHURCH:
PChurchAccess.LoadByPrimaryKey(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
break;
case TPartnerClass.ORGANISATION:
POrganisationAccess.LoadByPrimaryKey(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
if (FPartnerEditScreenDS.POrganisation[0].Foundation)
{
if (!((UserInfo.GUserInfo.IsInModule(SharedConstants.PETRAMODULE_DEVUSER))
|| (UserInfo.GUserInfo.IsInModule(SharedConstants.PETRAMODULE_DEVADMIN))))
{
throw new ESecurityScreenAccessDeniedException(
// Some users won't have access to edit partners that are foundations. Foundations are a special type of organisation.
// They usually are important donors, and they should not be approached by any user in the
// office, but only by the person that has been assigned to do that job
Catalog.GetString(
"You do not have access to Partners of Partner Class 'ORGANISATION' that are 'Foundations'!"));
}
else
{
// User has access to open the screen, based on Module Security
if (((!ADelayedDataLoading)) || (ATabPage == TPartnerEditTabPageEnum.petpFoundationDetails))
{
// Load all data that there is for a Foundation (across several DataTables)
FPartnerEditScreenDS.Merge(GetDataFoundation(false));
}
else
{
// Load just p_foundation record (needed for security, see below)
FPartnerEditScreenDS.Merge(GetDataFoundation(true));
}
if (FPartnerEditScreenDS.PFoundation.Rows.Count != 0)
{
// Store Foundation Owner1 and Foundation Owner2 from the
// p_foundation record. This information will be evaluated in the
// Partner Edit screen to allow/disallow access to the Foundation
// Details Tab.
if (FPartnerEditScreenDS.PFoundation[0].IsOwner1KeyNull())
{
FoundationOwner1Key = 0;
}
else
{
FoundationOwner1Key = FPartnerEditScreenDS.PFoundation[0].Owner1Key;
}
if (FPartnerEditScreenDS.PFoundation[0].IsOwner2KeyNull())
{
FoundationOwner2Key = 0;
}
else
{
FoundationOwner2Key = FPartnerEditScreenDS.PFoundation[0].Owner2Key;
}
if ((ADelayedDataLoading) && (ATabPage != TPartnerEditTabPageEnum.petpFoundationDetails))
{
// We don't want to transfer the data of the table until it is
// needed on the Client side (also for security reasons).
FPartnerEditScreenDS.Tables.Remove(FPartnerEditScreenDS.PFoundation);
}
/*
* Check if access to Partner is granted; if not, an
* ESecurityPartnerAccessDeniedException will be thrown by the called Method!
*/
Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartnerExc(
FPartnerEditScreenDS.PPartner[0], true,
FPartnerEditScreenDS.PFoundation[0]);
}
else
{
// Althought the Organisation is marked to be a Foundation, no
// p_foundation record exists. This should of course not happen,
// but in case it does: mark the Organisation to be NO Foundation.
FPartnerEditScreenDS.POrganisation[0].Foundation = false;
/*
* Check if access to Partner is granted; if not, an
* ESecurityPartnerAccessDeniedException will be thrown by the called Method!
*/
Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartnerExc(
FPartnerEditScreenDS.PPartner[0], false, null);
}
}
}
else
{
/*
* Check if access to Partner is granted; if not, an
* ESecurityPartnerAccessDeniedException will be thrown by the called Method!
*/
Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartnerExc(FPartnerEditScreenDS.PPartner[0], false, null);
}
break;
case TPartnerClass.BANK:
// Get the main information about a BANK partner
PBankAccess.LoadByPrimaryKey(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
// Gain information about the BANK partner's banking details
// When dealing with this grid one has to consider that the Netherland do not
// know bank branches and that Credit Cards do not have branches as well.
// Last time I checked how many accounts one bank in the Netherlands had
// I ended up with some 9756. I was also puzzled what use this grid may have.
// It is very tedious to find the right bank account from some 9000 bank
// accounts. Therefore the paged grid would be needed. But Rob decided that
// we currently do not build this grid into this screen, since this sreen
// was hardly used anyway. We are happy to wait for the first complaints.
//
// FPartnerEditScreenDS := GetBankingDetailsInternal(ReadTransaction, FPartnerKey);
break;
case TPartnerClass.UNIT:
PUnitAccess.LoadByPrimaryKey(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
UmUnitStructureAccess.LoadViaPUnitChildUnitKey(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
break;
case TPartnerClass.VENUE:
PVenueAccess.LoadByPrimaryKey(FPartnerEditScreenDS, FPartnerKey, ReadTransaction);
break;
}
#endregion
// financial details
if ((!ADelayedDataLoading) || (ATabPage == TPartnerEditTabPageEnum.petpFinanceDetails))
{
FPartnerEditScreenDS.Merge(GetBankingDetails());
}
ItemsCountPartnerBankingDetails = PPartnerBankingDetailsAccess.CountViaPPartner(FPartnerKey, ReadTransaction);
// Office Specific Data
if ((!ADelayedDataLoading) || (ATabPage == TPartnerEditTabPageEnum.petpOfficeSpecific))
{
FPartnerEditScreenDS.Merge(GetDataLocalPartnerDataValuesInternal(out OfficeSpecificDataLabelsAvailable, false));
}
else
{
FPartnerEditScreenDS.Merge(GetDataLocalPartnerDataValuesInternal(out OfficeSpecificDataLabelsAvailable, true));
}
// Console.WriteLine('FPartnerEditScreenDS.PDataLabelValuePartner.Rows.Count: ' + FPartnerEditScreenDS.PDataLabelValuePartner.Rows.Count.ToString);
#region Individual Data (Personnel Tab)
if (((!ADelayedDataLoading)) || (ATabPage == TPartnerEditTabPageEnum.petpPersonnelIndividualData))
{
FPartnerEditScreenDS.Merge(TIndividualDataWebConnector.GetData(FPartnerKey, TIndividualDataItemEnum.idiSummary));
// Console.WriteLine("FPartnerEditScreenDS.PDataLabelValuePartner.Rows.Count: " + FPartnerEditScreenDS.Tables["SummaryData"].Rows.Count.ToString());
}
#endregion
#endregion
#region Process data
// Determination of Last Gift information
TGift.GetLastGiftDetails(FPartnerKey, out LastGiftDate, out LastGiftInfo);
// Determination of Last Contact Date
TMailroom.GetLastContactDate(FPartnerKey, out LastContactDate);
GetContactsInternal(out ItemsCountContacts, out LastContactDate);
// Create 'miscellaneous' DataRow
MiscellaneousDataDT = FPartnerEditScreenDS.MiscellaneousData;
MiscellaneousDataDR = MiscellaneousDataDT.NewRowTyped(false);
MiscellaneousDataDR.PartnerKey = FPartnerKey;
if (FKeyForSelectingPartnerLocation.LocationKey == 0)
{
MiscellaneousDataDR.SelectedSiteKey = LocationPK.SiteKey;
MiscellaneousDataDR.SelectedLocationKey = LocationPK.LocationKey;
}
else
{
// TLogging.LogAtLevel(6, "Passed in FKeyForSelectingPartnerLocation.SiteKey and FKeyForSelectingPartnerLocation.LocationKey: " +
// FKeyForSelectingPartnerLocation.SiteKey.ToString() + "/" + FKeyForSelectingPartnerLocation.LocationKey.ToString());
MiscellaneousDataDR.SelectedSiteKey = FKeyForSelectingPartnerLocation.SiteKey;
MiscellaneousDataDR.SelectedLocationKey = FKeyForSelectingPartnerLocation.LocationKey;
}
if (LastGiftDate != DateTime.MinValue)
{
MiscellaneousDataDR.LastGiftDate = LastGiftDate;
}
else
{
MiscellaneousDataDR.SetLastGiftDateNull();
}
if (LastContactDate != DateTime.MinValue)
{
MiscellaneousDataDR.LastContactDate = LastContactDate;
}
else
{
MiscellaneousDataDR.SetLastContactDateNull();
}
MiscellaneousDataDR.LastGiftInfo = LastGiftInfo;
MiscellaneousDataDR.ItemsCountAddresses = ItemsCountAddresses;
MiscellaneousDataDR.ItemsCountAddressesActive = ItemsCountAddressesActive;
MiscellaneousDataDR.ItemsCountContactDetails = ItemsCountContactDetails;
MiscellaneousDataDR.ItemsCountContactDetailsActive = ItemsCountContactDetailsActive;
MiscellaneousDataDR.ItemsCountSubscriptions = ItemsCountSubscriptions;
MiscellaneousDataDR.ItemsCountSubscriptionsActive = ItemsCountSubscriptionsActive;
MiscellaneousDataDR.ItemsCountContacts = ItemsCountContacts;
MiscellaneousDataDR.ItemsCountPartnerTypes = ItemsCountPartnerTypes;
MiscellaneousDataDR.ItemsCountPartnerRelationships = ItemsCountPartnerRelationships;
MiscellaneousDataDR.ItemsCountFamilyMembers = ItemsCountFamilyMembers;
MiscellaneousDataDR.ItemsCountInterests = ItemsCountPartnerInterests;
MiscellaneousDataDR.ItemsCountPartnerBankingDetails = ItemsCountPartnerBankingDetails;
MiscellaneousDataDR.OfficeSpecificDataLabelsAvailable = OfficeSpecificDataLabelsAvailable;
MiscellaneousDataDR.FoundationOwner1Key = FoundationOwner1Key;
MiscellaneousDataDR.FoundationOwner2Key = FoundationOwner2Key;
MiscellaneousDataDR.HasEXWORKERPartnerType = HasEXWORKERPartnerType;
MiscellaneousDataDT.Rows.Add(MiscellaneousDataDR);
#endregion
// Add this partner key to the list of recently used partners.
TRecentPartnersHandling.AddRecentlyUsedPartner(FPartnerKey, FPartnerClass, false, TLastPartnerUse.lpuMailroomPartner);
}
catch (EPartnerLocationNotExistantException)
{
// don't log this exception this is thrown on purpose here and the Client deals with it.
DBAccess.GDBAccessObj.RollbackTransaction();
throw;
}
catch (ESecurityPartnerAccessDeniedException)
{
// don't log this exception this is thrown on purpose here and the Client deals with it.
DBAccess.GDBAccessObj.RollbackTransaction();
throw;
}
catch (Exception Exp)
{
DBAccess.GDBAccessObj.RollbackTransaction();
TLogging.Log("TPartnerEditUIConnector.LoadData exception: " + Exp.ToString(), TLoggingType.ToLogfile);
TLogging.Log(Exp.StackTrace, TLoggingType.ToLogfile);
throw;
}
}
finally
{
if (DBAccess.GDBAccessObj.Transaction != null)
{
DBAccess.GDBAccessObj.CommitTransaction();
}
}
// Accept row changes here so that the Client gets 'unmodified' rows
FPartnerEditScreenDS.AcceptChanges();
// Remove all Tables that were not filled with data before remoting them.
// Examples for such DataTables are the ones that exist for a certain Partner
// Class, eg. Person only one of those Tables will be filled, the other ones
// are not needed at the Client side.
FPartnerEditScreenDS.RemoveEmptyTables();
}
private static void MergeGiftDestination(long AFromPartnerKey, long AToPartnerKey, TPartnerClass APartnerClass, TDBTransaction ATransaction)
{
PPartnerGiftDestinationRow ActiveRow = null;
PPartnerGiftDestinationRow FromGiftDestinationNeedsEnded = null;
PPartnerGiftDestinationRow ToGiftDestinationNeedsEnded = null;
// if partners are Person's then find their family keys
if (APartnerClass == TPartnerClass.PERSON)
{
AFromPartnerKey = ((PPersonRow)PPersonAccess.LoadByPrimaryKey(AFromPartnerKey, ATransaction).Rows[0]).FamilyKey;
AToPartnerKey = ((PPersonRow)PPersonAccess.LoadByPrimaryKey(AToPartnerKey, ATransaction).Rows[0]).FamilyKey;
}
// check for an active gift destination for the 'From' partner
PPartnerGiftDestinationTable FromGiftDestinations = PPartnerGiftDestinationAccess.LoadViaPPartner(AFromPartnerKey, ATransaction);
ActiveRow = TMergePartnersCheckWebConnector.GetActiveGiftDestination(FromGiftDestinations);
// return if no active record has been found (this should never happen!)
if (ActiveRow == null)
{
return;
}
// check for clash with the 'To' partner
PPartnerGiftDestinationTable ToGiftDestinations = PPartnerGiftDestinationAccess.LoadViaPPartner(AToPartnerKey, ATransaction);
TMergePartnersCheckWebConnector.CheckGiftDestinationClashes(
ToGiftDestinations, ActiveRow, out FromGiftDestinationNeedsEnded, out ToGiftDestinationNeedsEnded);
// edit expiry dates if needed (the user will have given permission to do this)
if (FromGiftDestinationNeedsEnded != null)
{
ActiveRow.DateExpires = FromGiftDestinationNeedsEnded.DateEffective.AddDays(-1);
}
if (ToGiftDestinationNeedsEnded != null)
{
ToGiftDestinationNeedsEnded.DateExpires = ActiveRow.DateEffective.AddDays(-1);
}
// move Active Gift Destination to new family
ActiveRow.PartnerKey = AToPartnerKey;
// submit changes
PPartnerGiftDestinationAccess.SubmitChanges(FromGiftDestinations, ATransaction);
PPartnerGiftDestinationAccess.SubmitChanges(ToGiftDestinations, ATransaction);
}
