private PPartnerRow RetrieveDonorRow(long APartnerKey)
{
if (APartnerKey == 0)
{
return(null);
}
// find PPartnerRow from dataset
PPartnerRow DonorRow = (PPartnerRow)FMainDS.DonorPartners.Rows.Find(new object[] { APartnerKey });
// if PPartnerRow cannot be found, load it from db
if ((DonorRow == null) || (DonorRow[PPartnerTable.GetReceiptEachGiftDBName()] == DBNull.Value))
{
PPartnerTable PartnerTable = TRemote.MFinance.Gift.WebConnectors.LoadPartnerData(APartnerKey);
if ((PartnerTable == null) || (PartnerTable.Rows.Count == 0))
{
// invalid partner
return(null);
}
else
{
FMainDS.DonorPartners.Merge(PartnerTable);
}
DonorRow = PartnerTable[0];
}
return(DonorRow);
}
/// create a new church
public static PPartnerRow CreateNewChurchPartner(PartnerEditTDS AMainDS)
{
PPartnerRow PartnerRow = CreateNewPartner(AMainDS);
// make sure denomation "UNKNOWN" exists as this is the default value
if (!PDenominationAccess.Exists("UNKNOWN", DBAccess.GDBAccessObj.Transaction))
{
PDenominationTable DenominationTable = new PDenominationTable();
PDenominationRow DenominationRow = DenominationTable.NewRowTyped();
DenominationRow.DenominationCode = "UNKNOWN";
DenominationRow.DenominationName = "Unknown";
DenominationTable.Rows.Add(DenominationRow);
PDenominationAccess.SubmitChanges(DenominationTable, DBAccess.GDBAccessObj.Transaction);
}
PartnerRow.PartnerClass = MPartnerConstants.PARTNERCLASS_CHURCH;
PartnerRow.PartnerShortName = PartnerRow.PartnerKey.ToString() + ", TestChurch";
PChurchRow ChurchRow = AMainDS.PChurch.NewRowTyped();
ChurchRow.PartnerKey = PartnerRow.PartnerKey;
ChurchRow.ChurchName = "TestChurch";
ChurchRow.DenominationCode = "UNKNOWN";
AMainDS.PChurch.Rows.Add(ChurchRow);
return(PartnerRow);
}
public void Init()
{
CommonNUnitFunctions.ResetDatabase();
TPetraServerConnector.Connect("../../etc/TestServer.config");
TDataBase db = DBAccess.Connect("AddressToolsTest");
PPartnerRow Partner1 = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS, db);
TestPartnerKey = Partner1.PartnerKey;
//Guard assert: ensure database has been properly reset
TDBTransaction ATransaction = new TDBTransaction();
DataTable ResultTable = null;
string Query = string.Format("SELECT * FROM p_location WHERE p_site_key_n = {0} AND p_location_key_i = {1}",
DomainManager.GSiteKey,
LocationKey);
db.ReadTransaction(
ref ATransaction,
delegate
{
ResultTable = ATransaction.DataBaseObj.SelectDT(Query, "CheckLocations", ATransaction);
});
Assert.AreEqual(0, ResultTable.Rows.Count);
}
/// create a new church
public static PPartnerRow CreateNewChurchPartner(PartnerEditTDS AMainDS, TDataBase ADataBase = null)
{
PPartnerRow PartnerRow = CreateNewPartner(AMainDS, ADataBase);
TDataBase db = DBAccess.Connect("CreateNewChurchPartner", ADataBase);
TDBTransaction Transaction = db.BeginTransaction(IsolationLevel.Serializable);
// make sure denomination "UNKNOWN" exists as this is the default value
if (!PDenominationAccess.Exists("UNKNOWN", Transaction))
{
PDenominationTable DenominationTable = new PDenominationTable();
PDenominationRow DenominationRow = DenominationTable.NewRowTyped();
DenominationRow.DenominationCode = "UNKNOWN";
DenominationRow.DenominationName = "Unknown";
DenominationTable.Rows.Add(DenominationRow);
PDenominationAccess.SubmitChanges(DenominationTable, Transaction);
Transaction.Commit();
}
else
{
Transaction.Rollback();
}
PartnerRow.PartnerClass = MPartnerConstants.PARTNERCLASS_CHURCH;
PartnerRow.PartnerShortName = PartnerRow.PartnerKey.ToString() + ", TestChurch";
PChurchRow ChurchRow = AMainDS.PChurch.NewRowTyped();
ChurchRow.PartnerKey = PartnerRow.PartnerKey;
ChurchRow.ChurchName = "TestChurch";
ChurchRow.DenominationCode = "UNKNOWN";
AMainDS.PChurch.Rows.Add(ChurchRow);
return(PartnerRow);
}
/// create a new person
public static PPersonRow CreateNewPerson(PartnerEditTDS AMainDS,
Int64 AFamilyKey,
Int32 ALocationKey,
string AFirstName,
string ATitle,
int AFamilyID)
{
PPartnerRow PartnerRow = CreateNewPartner(AMainDS);
PartnerRow.PartnerClass = MPartnerConstants.PARTNERCLASS_PERSON;
PartnerRow.PartnerShortName = AFamilyKey.ToString() + ", " + AFirstName + ", " + ATitle;
PPersonRow PersonRow = AMainDS.PPerson.NewRowTyped();
PersonRow.PartnerKey = PartnerRow.PartnerKey;
PersonRow.FamilyKey = AFamilyKey;
PersonRow.FamilyName = AFamilyKey.ToString();
PersonRow.FirstName = AFirstName;
PersonRow.FamilyId = AFamilyID;
PersonRow.Title = ATitle;
AMainDS.PPerson.Rows.Add(PersonRow);
PPartnerLocationRow PartnerLocationRow = AMainDS.PPartnerLocation.NewRowTyped();
PartnerLocationRow.SiteKey = DomainManager.GSiteKey;
PartnerLocationRow.PartnerKey = PartnerRow.PartnerKey;
PartnerLocationRow.LocationKey = ALocationKey;
PartnerLocationRow.TelephoneNumber = PersonRow.PartnerKey.ToString();
AMainDS.PPartnerLocation.Rows.Add(PartnerLocationRow);
return(PersonRow);
}
public void TestSaveNewPartnerWithLocation()
{
TDataBase db = DBAccess.Connect("TestSaveNewPartnerWithLocation");
TDBTransaction Transaction = db.BeginTransaction(IsolationLevel.Serializable);
TPartnerEditUIConnector connector = new TPartnerEditUIConnector(db);
PartnerEditTDS MainDS = new PartnerEditTDS();
PPartnerRow PartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS, db);
TCreateTestPartnerData.CreateNewLocation(PartnerRow.PartnerKey, MainDS);
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
TSubmitChangesResult result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Transaction.Commit();
CommonNUnitFunctions.EnsureNullOrOnlyNonCriticalVerificationResults(VerificationResult,
"There was a critical error when saving:");
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "TPartnerEditUIConnector SubmitChanges return value");
// check the location key for this partner. should not be negative
Assert.AreEqual(1, MainDS.PPartnerLocation.Rows.Count, "TPartnerEditUIConnector SubmitChanges returns one location");
Assert.Greater(MainDS.PPartnerLocation[0].LocationKey, 0, "TPartnerEditUIConnector SubmitChanges returns valid location key");
}
private static SponsorshipTDS CreateNewChild()
{
Int64 SiteKey = DomainManager.GSiteKey;
SponsorshipTDS MainDS = new SponsorshipTDS();
Int64 PartnerKey = NewPartnerKey();
DateTime CreationDate = DateTime.Today;
string CreationUserID = UserInfo.GetUserInfo().UserID;
// Create DataRow for Partner using the default values for all DataColumns
// and then modify some.
PPartnerRow PartnerRow = MainDS.PPartner.NewRowTyped(true);
PartnerRow.PartnerKey = PartnerKey;
PartnerRow.DateCreated = CreationDate;
PartnerRow.CreatedBy = CreationUserID;
PartnerRow.PartnerClass = SharedTypes.PartnerClassEnumToString(TPartnerClass.FAMILY);
PartnerRow.StatusCode = SharedTypes.StdPartnerStatusCodeEnumToString(TStdPartnerStatusCode.spscACTIVE);
PartnerRow.UserId = CreationUserID;
MainDS.PPartner.Rows.Add(PartnerRow);
PFamilyRow FamilyRow = MainDS.PFamily.NewRowTyped(true);
FamilyRow.PartnerKey = PartnerKey;
FamilyRow.DateCreated = CreationDate;
FamilyRow.CreatedBy = CreationUserID;
MainDS.PFamily.Rows.Add(FamilyRow);
PPartnerTypeRow PartnerTypeRow = MainDS.PPartnerType.NewRowTyped(true);
PartnerTypeRow.PartnerKey = PartnerKey;
PartnerTypeRow.TypeCode = TYPE_SPONSOREDCHILD;
MainDS.PPartnerType.Rows.Add(PartnerTypeRow);
return(MainDS);
}
private static Int64 CreateFamily(ref PartnerEditTDS AMainDS, TApplicationFormData APartnerData)
{
PPartnerRow newPartner = AMainDS.PPartner.NewRowTyped();
Int64 SiteKey = DomainManager.GSiteKey;
// get a new partner key
Int64 newPartnerKey = -1;
do
{
newPartnerKey = TNewPartnerKey.GetNewPartnerKey(SiteKey);
TNewPartnerKey.SubmitNewPartnerKey(SiteKey, newPartnerKey, ref newPartnerKey);
newPartner.PartnerKey = newPartnerKey;
} while (newPartnerKey == -1);
// TODO: new status UNAPPROVED?
newPartner.StatusCode = MPartnerConstants.PARTNERSTATUS_ACTIVE;
AMainDS.PPartner.Rows.Add(newPartner);
PFamilyRow newFamily = AMainDS.PFamily.NewRowTyped();
newFamily.PartnerKey = newPartner.PartnerKey;
newFamily.FamilyName = APartnerData.lastname;
newFamily.FirstName = APartnerData.firstname;
newFamily.Title = APartnerData.title;
AMainDS.PFamily.Rows.Add(newFamily);
newPartner.PartnerClass = MPartnerConstants.PARTNERCLASS_FAMILY;
newPartner.AddresseeTypeCode = MPartnerConstants.PARTNERCLASS_FAMILY;
newPartner.PartnerShortName =
Calculations.DeterminePartnerShortName(newFamily.FamilyName, newFamily.Title, newFamily.FirstName);
return(newPartnerKey);
}
private Int64 CreateNewPartnerKeyWithUnit()
{
TVerificationResultCollection VerificationResult;
TSubmitChangesResult result;
DataSet ResponseDS = new PartnerEditTDS();
Int64 retVal = 0;
TPartnerEditUIConnector connector = new TPartnerEditUIConnector();
PartnerEditTDS MainDS = new PartnerEditTDS();
PPartnerRow UnitPartnerRow = TCreateTestPartnerData.CreateNewUnitPartnerWithTypeCode(MainDS, "KEY-MIN");
if (UnitPartnerRow != null)
{
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
if (result == TSubmitChangesResult.scrOK)
{
retVal = UnitPartnerRow.PartnerKey;
}
}
return(retVal);
}
public static PPartnerTable SharedBankAccountPartners(int ABankingDetailsKey, long APartnerKey)
{
PPartnerTable PartnerTable = new PPartnerTable();
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.BeginAutoReadTransaction(IsolationLevel.ReadCommitted,
ref Transaction,
delegate
{
PPartnerBankingDetailsTable PartnerBankingDetailsTable = PPartnerBankingDetailsAccess.LoadViaPBankingDetails(ABankingDetailsKey,
Transaction);
foreach (PPartnerBankingDetailsRow Row in PartnerBankingDetailsTable.Rows)
{
// if record exists with a different partner key then the Bank Account is shared
if (Row.PartnerKey != APartnerKey)
{
PPartnerRow PartnerRow = (PPartnerRow)PPartnerAccess.LoadByPrimaryKey(Row.PartnerKey, Transaction).Rows[0];
PPartnerRow NewRow = PartnerTable.NewRowTyped(false);
NewRow.PartnerKey = Row.PartnerKey;
NewRow.PartnerShortName = PartnerRow.PartnerShortName;
PartnerTable.Rows.Add(NewRow);
}
}
});
return(PartnerTable);
}
/// <summary>
/// Checks for the existance of a Partner.
/// </summary>
/// <param name="APartnerKey">PartnerKey of the Partner to check for.</param>
/// <param name="AMustNotBeMergedPartner">Set to true to check whether the Partner
/// must not be a Merged Partner.</param>
/// <returns>An instance of PPartnerRow if the Partner exists (taking AMustNotBeMergedPartner into consideration),
/// otherwise null.</returns>
/// <param name="ADataBase">An instantiated <see cref="TDataBase" /> object, or null (default = null). If null
/// gets passed then the Method executes DB commands with a new Database connection</param>
public static PPartnerRow CheckPartnerExists2(Int64 APartnerKey, bool AMustNotBeMergedPartner,
TDataBase ADataBase = null)
{
PPartnerRow ReturnValue = null;
TDBTransaction ReadTransaction = new TDBTransaction();
PPartnerTable PartnerTable = null;
if (APartnerKey != 0)
{
TDataBase db = DBAccess.Connect("CheckPartnerExists2", ADataBase);
db.ReadTransaction(ref ReadTransaction,
delegate
{
PartnerTable = PPartnerAccess.LoadByPrimaryKey(APartnerKey, ReadTransaction);
});
if (PartnerTable.Rows.Count != 0)
{
if (AMustNotBeMergedPartner)
{
if (SharedTypes.StdPartnerStatusCodeStringToEnum(
PartnerTable[0].StatusCode) != TStdPartnerStatusCode.spscMERGED)
{
ReturnValue = PartnerTable[0];
}
}
else
{
ReturnValue = PartnerTable[0];
}
}
}
return(ReturnValue);
}
public static bool GetPartnerReceiptingInfo(
Int64 APartnerKey,
out bool AReceiptEachGift,
out String AReceiptLetterFrequency,
out bool AEmailGiftStatement,
out bool AAnonymousDonor)
{
TDBTransaction ReadTransaction = null;
PPartnerTable PartnerTbl = null;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum, ref ReadTransaction,
delegate
{
PartnerTbl = PPartnerAccess.LoadByPrimaryKey(APartnerKey, ReadTransaction);
});
if (PartnerTbl.Rows.Count > 0)
{
PPartnerRow Row = PartnerTbl[0];
AReceiptEachGift = Row.ReceiptEachGift;
AReceiptLetterFrequency = Row.ReceiptLetterFrequency;
AEmailGiftStatement = Row.EmailGiftStatement;
AAnonymousDonor = Row.AnonymousDonor;
return(true);
}
else
{
AReceiptEachGift = false;
AReceiptLetterFrequency = "";
AEmailGiftStatement = false;
AAnonymousDonor = false;
return(false);
}
}
/// <summary>
/// Puts 'Head' data from a Partner DataRow into Partner Information data.
/// </summary>
/// <param name="APartnerDR">DataRow that contains the Partner data.</param>
/// <param name="APartnerInfoDS" >Typed PartnerInfoTDS DataSet</param>
private static void HeadInternal(PPartnerRow APartnerDR,
ref PartnerInfoTDS APartnerInfoDS)
{
PartnerInfoTDSPartnerHeadInfoRow PartnerHeadInfoDR;
if (APartnerInfoDS.PartnerHeadInfo.Rows.Count == 0)
{
PartnerHeadInfoDR = APartnerInfoDS.PartnerHeadInfo.NewRowTyped(false);
}
else
{
PartnerHeadInfoDR = APartnerInfoDS.PartnerHeadInfo[0];
}
PartnerHeadInfoDR.PartnerKey = APartnerDR.PartnerKey;
PartnerHeadInfoDR.PartnerShortName = APartnerDR.PartnerShortName;
PartnerHeadInfoDR.PartnerClass = APartnerDR.PartnerClass;
PartnerHeadInfoDR.StatusCode = APartnerDR.StatusCode;
PartnerHeadInfoDR.AcquisitionCode = APartnerDR.AcquisitionCode;
PartnerHeadInfoDR.PrivatePartnerOwner = APartnerDR.UserId;
if (APartnerInfoDS.PartnerHeadInfo.Rows.Count == 0)
{
APartnerInfoDS.PartnerHeadInfo.Rows.Add(PartnerHeadInfoDR);
}
}
/// <summary>
/// Tests whether the current user has access to a particular Partner.
/// </summary>
/// <remarks>
/// <para>Corresponds to Progress 4GL Method 'CanAccessPartner' in
/// common/sp_partn.p</para>
/// <para>A shared implementation of this Method exists that has two additional
/// Arguments. It needs the Foundation Row to be passed in, but has the
/// advantage of not needing a Server roundtrip for a DB lookup!</para>
/// </remarks>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <returns><see cref="T:TPartnerAccessLevelEnum.palGranted" /> if access
/// to the Partner is granted, otherwise a different
/// <see cref="T:TPartnerAccessLevelEnum" /> value.</returns>
public static TPartnerAccessLevelEnum CanAccessPartner(
PPartnerRow APartnerRow)
{
TDBTransaction ReadTransaction;
Boolean NewTransaction;
PFoundationTable FoundationTable;
if (APartnerRow.PartnerKey != 0)
{
// If PartnerClass is ORGANISATION, we need to check if it is a Foundation
if (APartnerRow.PartnerClass == SharedTypes.PartnerClassEnumToString(
TPartnerClass.ORGANISATION))
{
ReadTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(
IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
out NewTransaction);
// Load Foundation
try
{
FoundationTable = PFoundationAccess.LoadByPrimaryKey(APartnerRow.PartnerKey,
ReadTransaction);
if (FoundationTable.Rows.Count > 0)
{
// The ORGANISATION is a Foundation, we need to check Foundation Security
return Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartner(APartnerRow,
true, FoundationTable[0]);
}
else
{
// The ORGANISATION isn't a Foundation, we don't need to check Foundation Security
return Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartner(APartnerRow,
false, null);
}
}
finally
{
if (NewTransaction)
{
DBAccess.GDBAccessObj.CommitTransaction();
TLogging.LogAtLevel(8, "TSecurity.CanAccessPartnerByKey: committed own transaction.");
}
}
}
else
{
// PartnerClass isn't ORGANISATION, we don't need to check Foundation Security
return Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartner(APartnerRow,
false, null);
}
}
else
{
// Invalid Partner. Access Level is Granted in this case.
return TPartnerAccessLevelEnum.palGranted;
}
}
/// <summary>
/// Tests whether the current user has access to a particular Partner.
/// </summary>
/// <remarks>
/// <para>Corresponds to Progress 4GL Method 'CanAccessPartner' in
/// common/sp_partn.p</para>
/// <para>A shared implementation of this Method exists that has two additional
/// Arguments. It needs the Foundation Row to be passed in, but has the
/// advantage of not needing a Server roundtrip for a DB lookup!</para>
/// </remarks>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <param name="ADataBase">An instantiated <see cref="TDataBase" /> object, or null (default = null). If null
/// gets passed then the Method executes DB commands with a new Database connection</param>
/// <returns><see cref="T:TPartnerAccessLevelEnum.palGranted" /> if access
/// to the Partner is granted, otherwise a different
/// <see cref="T:TPartnerAccessLevelEnum" /> value.</returns>
public static TPartnerAccessLevelEnum CanAccessPartner(
PPartnerRow APartnerRow, TDataBase ADataBase = null)
{
TDBTransaction ReadTransaction;
Boolean NewTransaction;
PFoundationTable FoundationTable;
if (APartnerRow.PartnerKey != 0)
{
// If PartnerClass is ORGANISATION, we need to check if it is a Foundation
if (APartnerRow.PartnerClass == SharedTypes.PartnerClassEnumToString(
TPartnerClass.ORGANISATION))
{
TDataBase db = DBAccess.Connect("DetermineBestAddress", ADataBase);
ReadTransaction = db.GetNewOrExistingTransaction(
IsolationLevel.ReadCommitted,
out NewTransaction);
// Load Foundation
try
{
FoundationTable = PFoundationAccess.LoadByPrimaryKey(APartnerRow.PartnerKey,
ReadTransaction);
if (FoundationTable.Rows.Count > 0)
{
// The ORGANISATION is a Foundation, we need to check Foundation Security
return(Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartner(APartnerRow,
true, FoundationTable[0]));
}
else
{
// The ORGANISATION isn't a Foundation, we don't need to check Foundation Security
return(Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartner(APartnerRow,
false, null));
}
}
finally
{
if (NewTransaction)
{
ReadTransaction.Commit();
TLogging.LogAtLevel(8, "TSecurity.CanAccessPartnerByKey: committed own transaction.");
}
}
}
else
{
// PartnerClass isn't ORGANISATION, we don't need to check Foundation Security
return(Ict.Petra.Shared.MPartner.TSecurity.CanAccessPartner(APartnerRow,
false, null));
}
}
else
{
// Invalid Partner. Access Level is Granted in this case.
return(TPartnerAccessLevelEnum.palGranted);
}
}
/// <summary>
/// Looks for gifts where the donor is anoymous but the gift is not marked as confidential and asks the user if they want to continue.
/// (Make sure GetDataFromControls is called before this method so that AMainDS is up-to-date.)
/// </summary>
/// <param name="AMainDS"></param>
public static bool CanContinueWithAnyAnonymousDonors(GiftBatchTDS AMainDS)
{
GiftBatchTDSAGiftDetailTable UnConfidentialGiftsWithAnonymousDonors = new GiftBatchTDSAGiftDetailTable();
foreach (GiftBatchTDSAGiftDetailRow Row in AMainDS.AGiftDetail.Rows)
{
if (!Row.ConfidentialGiftFlag)
{
PPartnerRow PartnerRow = (PPartnerRow)AMainDS.DonorPartners.Rows.Find(Row.DonorKey);
if ((PartnerRow != null) && PartnerRow.AnonymousDonor)
{
UnConfidentialGiftsWithAnonymousDonors.Rows.Add((object[])Row.ItemArray.Clone());
}
}
}
if (UnConfidentialGiftsWithAnonymousDonors.Rows.Count > 0)
{
string Message = string.Empty;
DataView dv = UnConfidentialGiftsWithAnonymousDonors.DefaultView;
dv.Sort = GiftBatchTDSAGiftDetailTable.GetGiftTransactionNumberDBName() + " ASC";
DataTable sortedDT = dv.ToTable();
if (UnConfidentialGiftsWithAnonymousDonors.Rows.Count == 1)
{
Message = Catalog.GetString(
"The gift listed below in this batch is not marked as confidential but the donor has asked to remain anonymous.");
}
else
{
Message = Catalog.GetString(
"The gifts listed below in this batch are not marked as confidential but the donors have asked to remain anonymous.");
}
Message += "\n\n";
foreach (DataRow UnConfidentialGifts in sortedDT.Rows)
{
Message += Catalog.GetString("Batch: ") + UnConfidentialGifts[GiftBatchTDSAGiftDetailTable.GetBatchNumberDBName()] + "; " +
Catalog.GetString("Gift: ") + UnConfidentialGifts[GiftBatchTDSAGiftDetailTable.GetGiftTransactionNumberDBName()] +
"; " +
Catalog.GetString("Donor: ") + UnConfidentialGifts[GiftBatchTDSAGiftDetailTable.GetDonorNameDBName()] + " (" +
UnConfidentialGifts[GiftBatchTDSAGiftDetailTable.GetDonorKeyDBName()] + ")\n";
}
Message += "\n" + Catalog.GetString("Do you want to continue with posting anyway?");
if (MessageBox.Show(
Message, Catalog.GetString("Anonymous Donor Warning"), MessageBoxButtons.YesNo, MessageBoxIcon.Warning)
== DialogResult.No)
{
return(false);
}
}
return(true);
}
public void TestSaveNewPartnerWithExistingLocation()
{
TDataBase db = DBAccess.Connect("TestSaveNewPartnerWithExistingLocation");
TDBTransaction Transaction = db.BeginTransaction(IsolationLevel.Serializable);
TPartnerEditUIConnector connector = new TPartnerEditUIConnector(db);
PartnerEditTDS MainDS = new PartnerEditTDS();
PPartnerRow PartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS, db);
TCreateTestPartnerData.CreateNewLocation(PartnerRow.PartnerKey, MainDS);
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
TSubmitChangesResult result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Transaction.Commit();
CommonNUnitFunctions.EnsureNullOrOnlyNonCriticalVerificationResults(VerificationResult,
"There was a critical error when saving:");
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "saving the first partner with a location");
Int32 LocationKey = MainDS.PLocation[0].LocationKey;
MainDS = new PartnerEditTDS();
Transaction = db.BeginTransaction(IsolationLevel.Serializable);
PartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS, db);
PPartnerLocationRow PartnerLocationRow = MainDS.PPartnerLocation.NewRowTyped();
PartnerLocationRow.SiteKey = DomainManager.GSiteKey;
PartnerLocationRow.PartnerKey = PartnerRow.PartnerKey;
PartnerLocationRow.LocationKey = LocationKey;
MainDS.PPartnerLocation.Rows.Add(PartnerLocationRow);
ResponseDS = new PartnerEditTDS();
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Transaction.Commit();
CommonNUnitFunctions.EnsureNullOrOnlyNonCriticalVerificationResults(VerificationResult,
"There was a critical error when saving:");
TDBTransaction ReadTransaction = new TDBTransaction();
db.ReadTransaction(
ref ReadTransaction,
delegate
{
PPartnerTable PartnerAtAddress = PPartnerAccess.LoadViaPLocation(
DomainManager.GSiteKey, LocationKey, ReadTransaction);
Assert.AreEqual(2, PartnerAtAddress.Rows.Count, "there should be two partners at this location");
});
}
/// <summary>
/// Update all donor names in gift details table
/// </summary>
/// <param name="ABatchNumber"></param>
private void UpdateAllDonorNames(Int32 ABatchNumber)
{
Dictionary <Int32, Int64> GiftsDict = new Dictionary <Int32, Int64>();
Dictionary <Int64, string> DonorsDict = new Dictionary <Int64, string>();
DataView GiftDV = new DataView(FMainDS.AGift);
GiftDV.RowFilter = string.Format("{0}={1}",
AGiftTable.GetBatchNumberDBName(),
ABatchNumber);
GiftDV.Sort = string.Format("{0} ASC", AGiftTable.GetGiftTransactionNumberDBName());
foreach (DataRowView drv in GiftDV)
{
AGiftRow gr = (AGiftRow)drv.Row;
Int64 donorKey = gr.DonorKey;
GiftsDict.Add(gr.GiftTransactionNumber, donorKey);
if (!DonorsDict.ContainsKey(donorKey))
{
if (donorKey != 0)
{
PPartnerRow pr = RetrieveDonorRow(donorKey);
if (pr != null)
{
DonorsDict.Add(donorKey, pr.PartnerShortName);
}
}
else
{
DonorsDict.Add(0, "");
}
}
}
//Add donor info to gift details
DataView GiftDetailDV = new DataView(FMainDS.AGiftDetail);
GiftDetailDV.RowFilter = string.Format("{0}={1}",
AGiftDetailTable.GetBatchNumberDBName(),
ABatchNumber);
GiftDetailDV.Sort = string.Format("{0} ASC", AGiftDetailTable.GetGiftTransactionNumberDBName());
foreach (DataRowView drv in GiftDetailDV)
{
GiftBatchTDSAGiftDetailRow giftDetail = (GiftBatchTDSAGiftDetailRow)drv.Row;
Int64 donorKey = GiftsDict[giftDetail.GiftTransactionNumber];
giftDetail.DonorKey = donorKey;
giftDetail.DonorName = DonorsDict[donorKey];
}
}
/// <summary>
/// Tests whether the current user has access to a particular Partner.
/// </summary>
/// <remarks>This Method throws an <see cref="T:ESecurityPartnerAccessDeniedException" />
/// if access to the Partner is not granted, thereby ensuring that a denied access
/// doesn't go unnoticed.</remarks>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <param name="ADataBase">An instantiated <see cref="TDataBase" /> object, or null (default = null). If null
/// gets passed then the Method executes DB commands with a new Database connection</param>
/// <exception cref="T:ESecurityPartnerAccessDeniedException">Thrown if access is not granted.</exception>
public static void CanAccessPartnerExc(PPartnerRow APartnerRow, TDataBase ADataBase = null)
{
TPartnerAccessLevelEnum AccessLevel;
AccessLevel = CanAccessPartner(APartnerRow, ADataBase);
Ict.Petra.Shared.MPartner.TSecurity.AccessLevelExceptionEvaluatorAndThrower(
APartnerRow, AccessLevel);
}
/// <summary>
/// Create a Partner and a Person having this FamilyKey, living at this address.
/// </summary>
/// <param name="AFamilyKey"></param>
/// <param name="ALocationKey"></param>
/// <param name="ANode"></param>
/// <param name="AMainDS"></param>
/// <param name="ATransaction"></param>
private static Int64 CreateNewPerson(Int64 AFamilyKey, int ALocationKey, XmlNode ANode,
ref PartnerImportExportTDS AMainDS, TDBTransaction ATransaction)
{
AMainDS.PFamily.DefaultView.RowFilter = String.Format("{0}={1}", PFamilyTable.GetPartnerKeyDBName(), AFamilyKey);
PFamilyRow FamilyRow = (PFamilyRow)AMainDS.PFamily.DefaultView[0].Row;
AMainDS.PPartner.DefaultView.RowFilter = String.Format("{0}={1}", PPartnerTable.GetPartnerKeyDBName(), AFamilyKey);
PPartnerRow PartnerRow = (PPartnerRow)AMainDS.PPartner.DefaultView[0].Row;
PPartnerRow newPartner = AMainDS.PPartner.NewRowTyped();
AMainDS.PPartner.Rows.Add(newPartner);
newPartner.PartnerKey = (AMainDS.PPartner.Rows.Count + 1) * -1;
newPartner.PartnerClass = MPartnerConstants.PARTNERCLASS_PERSON;
newPartner.AddresseeTypeCode = PartnerRow.AddresseeTypeCode;
newPartner.PartnerShortName = PartnerRow.PartnerShortName;
newPartner.LanguageCode = PartnerRow.LanguageCode;
newPartner.Comment = TXMLParser.GetAttribute(ANode, MPartnerConstants.PARTNERIMPORT_NOTES);
newPartner.AcquisitionCode = PartnerRow.AcquisitionCode;
newPartner.StatusCode = MPartnerConstants.PARTNERSTATUS_ACTIVE;
PPersonRow newPerson = AMainDS.PPerson.NewRowTyped();
AMainDS.PPerson.Rows.Add(newPerson);
newPerson.PartnerKey = newPartner.PartnerKey;
newPerson.FamilyKey = AFamilyKey;
// When this record is imported, newPerson.FamilyId must be unique for this family!
newPerson.FirstName = FamilyRow.FirstName;
newPerson.FamilyName = FamilyRow.FamilyName;
newPerson.Title = FamilyRow.Title;
newPerson.Gender = GetGenderCode(ANode);
newPerson.MaritalStatus = FamilyRow.MaritalStatus;
PPartnerLocationRow newPartnerLocation = AMainDS.PPartnerLocation.NewRowTyped();
AMainDS.PPartnerLocation.Rows.Add(newPartnerLocation);
newPartnerLocation.LocationKey = ALocationKey; // This person lives at the same address as the family.
newPartnerLocation.SiteKey = 0;
newPartnerLocation.PartnerKey = newPartner.PartnerKey;
newPartnerLocation.DateEffective = DateTime.Now.Date;
newPartnerLocation.LocationType = MPartnerConstants.LOCATIONTYPE_HOME;
newPartnerLocation.SendMail = true;
newPartnerLocation["p_email_address_c"] =
TXMLParser.GetAttribute(ANode, MPartnerConstants.PARTNERIMPORT_EMAIL); // Important: Do not use 'newPartnerLocation.EmailAddress' as this Column will get removed once Contact Details conversion is finished!
newPartnerLocation["p_telephone_number_c"] =
TXMLParser.GetAttribute(ANode, MPartnerConstants.PARTNERIMPORT_PHONE); // Important: Do not use 'newPartnerLocation.TelephoneNumber' as this Column will get removed once Contact Details conversion is finished!
newPartnerLocation["p_mobile_number_c"] =
TXMLParser.GetAttribute(ANode, MPartnerConstants.PARTNERIMPORT_MOBILEPHONE); // Important: Do not use 'newPartnerLocation.MobileNumber' as this Column will get removed once Contact Details conversion is finished!
AddVerificationResult("Person Record Created.", TResultSeverity.Resv_Status);
return(newPerson.PartnerKey);
}
private void ParseEmergencyContactData(ref string AContact, PPartnerRelationshipRow ARelationshipRow)
{
string primaryPhone;
string primaryEmail;
PartnerEditTDS editTDS = TRemote.MPartner.Partner.WebConnectors.GetPartnerDetails(ARelationshipRow.PartnerKey,
false, false, out primaryPhone, out primaryEmail);
if ((editTDS.PPartner != null) && (editTDS.PPartner.Rows.Count > 0))
{
PPartnerRow partnerRow = (PPartnerRow)editTDS.PPartner.Rows[0];
AContact += String.Format("{0}{1}{1}", partnerRow.PartnerShortName, Environment.NewLine);
}
DateTime?dtLastModified = null;
if (!ARelationshipRow.IsDateModifiedNull())
{
// We have a modified date
dtLastModified = ARelationshipRow.DateModified;
// Just check to make sure that the created date is not later for some starnge reason
if (!ARelationshipRow.IsDateCreatedNull())
{
if (ARelationshipRow.DateCreated > dtLastModified)
{
dtLastModified = ARelationshipRow.DateCreated;
}
}
}
else if (!ARelationshipRow.IsDateCreatedNull())
{
// No date modifed but we do have the original creation date
dtLastModified = ARelationshipRow.DateCreated;
}
if (dtLastModified.HasValue)
{
AContact += String.Format(Catalog.GetString("This contact was last set on: {0}{1}{1}"),
StringHelper.DateToLocalizedString(dtLastModified.Value), Environment.NewLine);
}
if (primaryPhone.Length > 0)
{
AContact += String.Format(Catalog.GetString("Primary phone: {0}{1}"), primaryPhone, Environment.NewLine);
}
if (primaryEmail.Length > 0)
{
AContact += String.Format(Catalog.GetString("Primary email: {0}{1}"), primaryEmail, Environment.NewLine);
}
if (ARelationshipRow.Comment.Length > 0)
{
AContact += String.Format(Catalog.GetString("Extra information:{1} {0}{1}"), ARelationshipRow.Comment, Environment.NewLine);
}
}
/// <summary>
/// Tests whether the current user has access to a particular Partner.
/// </summary>
/// <remarks>This Method throws an <see cref="ESecurityPartnerAccessDeniedException" />
/// if access to the Partner is not granted, thereby ensuring that a denied access
/// doesn't go unnoticed.</remarks>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <param name="AIsFoundation">Set to true if Partner is a Foundation.</param>
/// <param name="AFoundationRow">Foundation Row needs to be passed in
/// if Partner is a Foundation.</param>
/// <returns>void</returns>
/// <exception cref="ESecurityPartnerAccessDeniedException">Thrown if access is not granted.</exception>
public static void CanAccessPartnerExc(PPartnerRow APartnerRow, bool AIsFoundation,
PFoundationRow AFoundationRow)
{
TPartnerAccessLevelEnum AccessLevel;
AccessLevel = CanAccessPartner(APartnerRow, AIsFoundation, AFoundationRow);
AccessLevelExceptionEvaluatorAndThrower(APartnerRow, AccessLevel);
}
private static PartnerDetails GetRecipient(Int64 APartnerKey)
{
if (RecipientList.ContainsKey(APartnerKey))
{
return(RecipientList[APartnerKey]);
}
PartnerDetails Ret = new PartnerDetails();
PPartnerTable PartnerTbl = PPartnerAccess.LoadByPrimaryKey(APartnerKey, FTransaction);
if (PartnerTbl.Rows.Count > 0)
{
PPartnerRow PartnerRow = PartnerTbl[0];
Ret.LastName = PartnerRow.PartnerShortName;
if (PartnerRow.PartnerClass == "PERSON")
{
PPersonTable PersonTbl = PPersonAccess.LoadByPrimaryKey(APartnerKey, FTransaction);
if (PersonTbl.Rows.Count > 0)
{
PPersonRow PersonRow = PersonTbl[0];
Ret.FirstName = PersonRow.FirstName;
Ret.LastName = PersonRow.FamilyName;
Ret.Class = "PERSON";
}
}
if (PartnerRow.PartnerClass == "FAMILY")
{
PFamilyTable FamilyTbl = PFamilyAccess.LoadByPrimaryKey(APartnerKey, FTransaction);
if (FamilyTbl.Rows.Count > 0)
{
PFamilyRow FamilyRow = FamilyTbl[0];
Ret.FirstName = FamilyRow.FirstName;
Ret.LastName = FamilyRow.FamilyName;
Ret.Class = "FAMILY";
}
}
PPartnerLocationRow LocationRow;
TLocationPK LocationKey = ServerCalculations.DetermineBestAddress(APartnerKey, out LocationRow);
if (LocationKey.LocationKey != -1)
{
Ret.Email = LocationRow.EmailAddress;
}
}
RecipientList.Add(APartnerKey, Ret);
return(Ret);
}
/// create a new family with one person
public static void CreateFamilyWithOnePersonRecord(PartnerEditTDS AMainDS)
{
PPartnerRow PartnerRow = CreateNewFamilyPartner(AMainDS);
CreateNewLocation(PartnerRow.PartnerKey, AMainDS);
CreateNewPerson(AMainDS,
PartnerRow.PartnerKey,
AMainDS.PLocation[0].LocationKey,
"Adam",
"Mr",
0);
}
/// <summary>
/// Evaluates the passed in AccessLevel and throws
/// <see cref="ESecurityPartnerAccessDeniedException" /> if the AccessLevel
/// isn't <see cref="TPartnerAccessLevelEnum.palGranted" />.
/// </summary>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <param name="AAccessLevel">AccessLevel as determined by caller.</param>
public static void AccessLevelExceptionEvaluatorAndThrower(
PPartnerRow APartnerRow, TPartnerAccessLevelEnum AAccessLevel)
{
switch (AAccessLevel)
{
case TPartnerAccessLevelEnum.palGranted:
return;
default:
throw new ESecurityPartnerAccessDeniedException("",
APartnerRow.PartnerKey, APartnerRow.PartnerShortName, AAccessLevel);
}
}
/// create a new bank
public static PPartnerRow CreateNewBankPartner(PartnerEditTDS AMainDS)
{
PPartnerRow PartnerRow = CreateNewPartner(AMainDS);
PartnerRow.PartnerClass = MPartnerConstants.PARTNERCLASS_BANK;
PartnerRow.PartnerShortName = PartnerRow.PartnerKey.ToString() + ", TestBank";
PBankRow BankRow = AMainDS.PBank.NewRowTyped();
BankRow.PartnerKey = PartnerRow.PartnerKey;
BankRow.BranchName = "TestBank";
AMainDS.PBank.Rows.Add(BankRow);
return(PartnerRow);
}
/// create a new organisation
public static PPartnerRow CreateNewOrganisationPartner(PartnerEditTDS AMainDS)
{
PPartnerRow PartnerRow = CreateNewPartner(AMainDS);
PartnerRow.PartnerClass = MPartnerConstants.PARTNERCLASS_ORGANISATION;
PartnerRow.PartnerShortName = PartnerRow.PartnerKey.ToString() + ", TestOrganisation";
POrganisationRow OrganisationRow = AMainDS.POrganisation.NewRowTyped();
OrganisationRow.PartnerKey = PartnerRow.PartnerKey;
OrganisationRow.OrganisationName = "TestOrganisation";
AMainDS.POrganisation.Rows.Add(OrganisationRow);
return(PartnerRow);
}
/// create a new unit
public static PPartnerRow CreateNewUnitPartner(PartnerEditTDS AMainDS)
{
PPartnerRow PartnerRow = CreateNewPartner(AMainDS);
PartnerRow.PartnerClass = MPartnerConstants.PARTNERCLASS_UNIT;
PartnerRow.PartnerShortName = PartnerRow.PartnerKey.ToString() + ", TestUnit";
PUnitRow UnitRow = AMainDS.PUnit.NewRowTyped();
UnitRow.PartnerKey = PartnerRow.PartnerKey;
UnitRow.UnitName = "TestUnit";
AMainDS.PUnit.Rows.Add(UnitRow);
return(PartnerRow);
}
/// create a new venue
public static PPartnerRow CreateNewVenuePartner(PartnerEditTDS AMainDS)
{
PPartnerRow PartnerRow = CreateNewPartner(AMainDS);
PartnerRow.PartnerClass = MPartnerConstants.PARTNERCLASS_VENUE;
PartnerRow.PartnerShortName = PartnerRow.PartnerKey.ToString() + ", TestVenue";
PVenueRow VenueRow = AMainDS.PVenue.NewRowTyped();
VenueRow.PartnerKey = PartnerRow.PartnerKey;
VenueRow.VenueCode = "TEST" + PartnerRow.PartnerKey.ToString();
VenueRow.VenueName = "TestVenue" + PartnerRow.PartnerKey.ToString();
AMainDS.PVenue.Rows.Add(VenueRow);
return(PartnerRow);
}
/// create a new unit
public static PPartnerRow CreateNewUnitPartnerWithTypeCode(PartnerEditTDS AMainDS, string AUnitType, TDataBase ADataBase = null)
{
PPartnerRow PartnerRow = CreateNewPartner(AMainDS, ADataBase);
PartnerRow.PartnerClass = MPartnerConstants.PARTNERCLASS_UNIT;
PartnerRow.PartnerShortName = PartnerRow.PartnerKey.ToString() + ", TestUnit";
PUnitRow UnitRow = AMainDS.PUnit.NewRowTyped();
UnitRow.PartnerKey = PartnerRow.PartnerKey;
UnitRow.UnitName = "TestUnit";
UnitRow.UnitTypeCode = AUnitType;
AMainDS.PUnit.Rows.Add(UnitRow);
return(PartnerRow);
}
/// <summary>
/// Tests whether the current user has access to a particular Partner.
/// </summary>
/// <remarks>
/// <para>Corresponds to Progress 4GL Method 'CanAccessPartner' in
/// common/sp_partn.p</para>
/// <para>A server-side implementation of this Method exists that has only the
/// <paramref name="APartnerRow" />parameter as an Argument. It
/// looks up the Foundation Row on its own if this is needed.</para>
/// </remarks>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <param name="AIsFoundation">Set to true if Partner is a Foundation.</param>
/// <param name="AFoundationRow">Foundation Row needs to be passed in
/// if Partner is a Foundation.</param>
/// <returns><see cref="TPartnerAccessLevelEnum.palGranted" /> if access
/// to the Partner is granted, otherwise a different
/// <see cref="TPartnerAccessLevelEnum" /> value.</returns>
public static TPartnerAccessLevelEnum CanAccessPartner(PPartnerRow APartnerRow, bool AIsFoundation,
PFoundationRow AFoundationRow)
{
TPetraPrincipal userinfo = UserInfo.GetUserInfo();
if ((APartnerRow.Restricted == PARTNER_RESTRICTED_TO_USER) &&
!((APartnerRow.UserId == userinfo.UserID) || userinfo.IsInModule("SYSMAN")))
{
TLogging.LogAtLevel(6,
"CanAccessPartner: Access DENIED - Partner " + APartnerRow.PartnerKey.ToString() + " is restriced to User " +
APartnerRow.UserId + "!");
return(TPartnerAccessLevelEnum.palRestrictedToUser);
}
else if ((APartnerRow.Restricted == PARTNER_RESTRICTED_TO_GROUP) &&
!((userinfo.IsInGroup(APartnerRow.GroupId)) || userinfo.IsInModule("SYSMAN")))
{
TLogging.LogAtLevel(6,
"CanAccessPartner: Access DENIED - Partner " + APartnerRow.PartnerKey.ToString() + " is restriced to Group " +
APartnerRow.GroupId +
"!");
return(TPartnerAccessLevelEnum.palRestrictedToGroup);
}
if (APartnerRow.PartnerClass == SharedTypes.PartnerClassEnumToString(TPartnerClass.ORGANISATION))
{
if (AIsFoundation)
{
if (AFoundationRow != null)
{
if (!CheckFoundationSecurity(AFoundationRow))
{
TLogging.LogAtLevel(6,
"CanAccessPartner: Access DENIED - Partner " + APartnerRow.PartnerKey.ToString() +
" is restriced by Foundation Ownership!");
return(TPartnerAccessLevelEnum.palRestrictedByFoundationOwnership);
}
}
else
{
throw new System.ArgumentException("AFoundationRow must not be null if AIsFoundation is true");
}
}
}
TLogging.LogAtLevel(6, "CanAccessPartner: Access to Partner " + APartnerRow.PartnerKey.ToString() + " is GRANTED!");
return(TPartnerAccessLevelEnum.palGranted);
}
/// <summary>
/// Tests whether the current user has access to a particular Partner.
/// </summary>
/// <remarks>
/// <para>Corresponds to Progress 4GL Method 'CanAccessPartner' in
/// common/sp_partn.p</para>
/// <para>A server-side implementation of this Method exists that has only the
/// <paramref name="APartnerRow" />parameter as an Argument. It
/// looks up the Foundation Row on its own if this is needed.</para>
/// </remarks>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <param name="AIsFoundation">Set to true if Partner is a Foundation.</param>
/// <param name="AFoundationRow">Foundation Row needs to be passed in
/// if Partner is a Foundation.</param>
/// <returns><see cref="TPartnerAccessLevelEnum.palGranted" /> if access
/// to the Partner is granted, otherwise a different
/// <see cref="TPartnerAccessLevelEnum" /> value.</returns>
public static TPartnerAccessLevelEnum CanAccessPartner(PPartnerRow APartnerRow, bool AIsFoundation,
PFoundationRow AFoundationRow)
{
if ((APartnerRow.Restricted == PARTNER_RESTRICTED_TO_USER)
&& !((APartnerRow.UserId == UserInfo.GUserInfo.UserID) || UserInfo.GUserInfo.IsInModule("SYSMAN")))
{
TLogging.LogAtLevel(6,
"CanAccessPartner: Access DENIED - Partner " + APartnerRow.PartnerKey.ToString() + " is restriced to User " +
APartnerRow.UserId + "!");
return TPartnerAccessLevelEnum.palRestrictedToUser;
}
else if ((APartnerRow.Restricted == PARTNER_RESTRICTED_TO_GROUP)
&& !((UserInfo.GUserInfo.IsInGroup(APartnerRow.GroupId)) || UserInfo.GUserInfo.IsInModule("SYSMAN")))
{
TLogging.LogAtLevel(6,
"CanAccessPartner: Access DENIED - Partner " + APartnerRow.PartnerKey.ToString() + " is restriced to Group " +
APartnerRow.GroupId +
"!");
return TPartnerAccessLevelEnum.palRestrictedToGroup;
}
if (APartnerRow.PartnerClass == SharedTypes.PartnerClassEnumToString(TPartnerClass.ORGANISATION))
{
if (AIsFoundation)
{
if (AFoundationRow != null)
{
if (!CheckFoundationSecurity(AFoundationRow))
{
TLogging.LogAtLevel(6,
"CanAccessPartner: Access DENIED - Partner " + APartnerRow.PartnerKey.ToString() +
" is restriced by Foundation Ownership!");
return TPartnerAccessLevelEnum.palRestrictedByFoundationOwnership;
}
}
else
{
throw new System.ArgumentException("AFoundationRow must not be null if AIsFoundation is true");
}
}
}
TLogging.LogAtLevel(6, "CanAccessPartner: Access to Partner " + APartnerRow.PartnerKey.ToString() + " is GRANTED!");
return TPartnerAccessLevelEnum.palGranted;
}
/// <summary>
/// Validates the Partner data of a Partner.
/// </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>
/// <returns>void</returns>
public static void ValidatePartnerManual(object AContext, PPartnerRow ARow,
ref TVerificationResultCollection AVerificationResultCollection, TValidationControlsDict AValidationControlsDict)
{
DataColumn ValidationColumn;
TValidationControlsData ValidationControlsData;
TScreenVerificationResult VerificationResult;
// Don't validate deleted DataRows
if (ARow.RowState == DataRowState.Deleted)
{
return;
}
// 'PartnerStatus' must not be set to MERGED
ValidationColumn = ARow.Table.Columns[PPartnerTable.ColumnStatusCodeId];
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
if (ARow.StatusCode == SharedTypes.StdPartnerStatusCodeEnumToString(TStdPartnerStatusCode.spscMERGED))
{
VerificationResult = new TScreenVerificationResult(new TVerificationResult(AContext,
ErrorCodes.GetErrorInfo(PetraErrorCodes.ERR_PARTNERSTATUSMERGEDCHANGEUNDONE)),
ValidationColumn, ValidationControlsData.ValidationControl);
// Note: The error code 'ERR_PARTNERSTATUSMERGEDCHANGEUNDONE' sets VerificationResult.ControlValueUndoRequested = true!
}
else
{
VerificationResult = null;
}
// Handle addition/removal to/from TVerificationResultCollection
AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn);
}
}
private static void CheckLanguage(PartnerImportExportTDS MainDS,
PPartnerRow PartnerRow,
ref TVerificationResultCollection ReferenceResults,
TDBTransaction Transaction)
{
// Language: we can only speak languages that we've heard of
StringCollection RequiredLanguages = new StringCollection();
if (!PLanguageAccess.Exists(PartnerRow.LanguageCode, Transaction))
{
RequiredLanguages.Add(PartnerRow.LanguageCode);
}
foreach (PmPersonLanguageRow rv in MainDS.PmPersonLanguage.Rows)
{
if ((!RequiredLanguages.Contains(rv.LanguageCode)) && (!PLanguageAccess.Exists(rv.LanguageCode, Transaction)))
{
RequiredLanguages.Add(rv.LanguageCode);
}
}
foreach (PmShortTermApplicationRow rv in MainDS.PmShortTermApplication.Rows)
{
if ((!RequiredLanguages.Contains(rv.StCongressLanguage)) && (!PLanguageAccess.Exists(rv.StCongressLanguage, Transaction)))
{
RequiredLanguages.Add(rv.StCongressLanguage);
}
}
foreach (String NewLanguage in RequiredLanguages)
{
if (NewLanguage != "")
{
MainDS.PLanguage.DefaultView.RowFilter = String.Format("{0}='{1}'", PLanguageTable.GetLanguageCodeDBName(), NewLanguage);
if (MainDS.PLanguage.DefaultView.Count == 0) // Check I've not just added this a moment ago..
{
AddVerificationResult(ref ReferenceResults, "Adding new Language Code " + NewLanguage);
PLanguageRow Row = MainDS.PLanguage.NewRowTyped();
Row.LanguageCode = NewLanguage;
Row.LanguageDescription = FNewRowDescription;
MainDS.PLanguage.Rows.Add(Row);
}
}
}
}
private void DisplayCurrentRecord()
{
if ((FMainDS == null) || (FCurrentNumberOfRecord < 1))
{
return;
}
if (grdMatchingRecords.InvokeRequired) // must be called from UI thread.
{
grdMatchingRecords.Invoke(new MethodInvoker(delegate { DisplayCurrentRecord(); }));
return;
}
// have we finished importing?
if (FCurrentNumberOfRecord > FTotalNumberOfRecords)
{
AddStatus(String.Format(Catalog.GetString("{0} Records processed - Import finished.\r\n"), FTotalNumberOfRecords));
SaveLogFile();
SetControlsIdle();
// finish the thread
FNeedUserFeedback = true;
grdMatchingRecords.DataSource = null;
txtHint.Text = String.Empty;
return;
}
do
{
FCurrentPartner = FMainDS.PPartner[FCurrentNumberOfRecord - 1];
if (FImportedUnits.Contains(FCurrentPartner.PartnerKey))
{
AddStatus(String.Format(Catalog.GetString("Unit [{0}] already imported.\r\n"), FCurrentPartner.PartnerKey));
FCurrentNumberOfRecord++;
}
} while (FImportedUnits.Contains(FCurrentPartner.PartnerKey));
string PartnerInfo = String.Format("[{0}] {1} ",
FCurrentPartner.PartnerClass,
FCurrentPartner.PartnerShortName);
if (FCurrentPartner.PartnerKey > 0)
{
PartnerInfo += FCurrentPartner.PartnerKey.ToString();
}
PartnerInfo += Environment.NewLine;
FMainDS.PPartnerLocation.DefaultView.RowFilter = String.Format("{0}={1}",
PPartnerLocationTable.GetPartnerKeyDBName(),
FCurrentPartner.PartnerKey);
foreach (DataRowView rv in FMainDS.PPartnerLocation.DefaultView)
{
PPartnerLocationRow PartnerLocationRow = (PPartnerLocationRow)rv.Row;
FMainDS.PLocation.DefaultView.RowFilter = String.Format("{0}={1} and {2}={3}",
PLocationTable.GetLocationKeyDBName(),
PartnerLocationRow.LocationKey,
PLocationTable.GetSiteKeyDBName(),
PartnerLocationRow.SiteKey);
foreach (DataRowView LocationRowView in FMainDS.PLocation.DefaultView)
{
PLocationRow LocationRow = (PLocationRow)LocationRowView.Row;
PartnerInfo += Calculations.DetermineLocationString(LocationRow, Calculations.TPartnerLocationFormatEnum.plfCommaSeparated);
PartnerInfo += Environment.NewLine;
if (PartnerLocationRow.EmailAddress != "")
{
PartnerInfo += PartnerLocationRow.EmailAddress + Environment.NewLine;
}
PartnerInfo += Environment.NewLine;
}
AddStatus(String.Format(Catalog.GetString("Processing record {0} of {1}:\r\n"), FCurrentNumberOfRecord, FTotalNumberOfRecords));
}
TLocationPK BestLocationPK = Ict.Petra.Shared.MPartner.Calculations.DetermineBestAddress(FMainDS.PPartnerLocation);
FMainDS.PLocation.DefaultView.RowFilter = String.Format("{0}={1} and {2}={3}",
PLocationTable.GetLocationKeyDBName(),
BestLocationPK.LocationKey,
PLocationTable.GetSiteKeyDBName(),
BestLocationPK.SiteKey);
PLocationRow BestLocation = null;
if (FMainDS.PLocation.DefaultView.Count > 0)
{
BestLocation = (PLocationRow)FMainDS.PLocation.DefaultView[0].Row;
}
AddStatus(PartnerInfo);
// TODO: several tabs, displaying count of numbers of partners with same name, different cities, etc? support Address change, etc
// get all partners with same surname in that city. using the first Plocation for the moment.
// TODO: should use getBestAddress?
grdMatchingRecords.Columns.Clear();
btnUseSelectedAddress.Enabled = false;
btnUseSelectedPerson.Enabled = false;
btnCreateNewPartner.Enabled = true;
btnUseSelectedFamily.Enabled = false;
bool FoundPartnerInDatabase = false;
bool FoundPossiblePartnersInDatabase = false;
// Try to find an existing partner and set the partner key
// Or if the address is found, the location record can be shared.
if ((BestLocation != null) && (FCurrentPartner.PartnerKey < 0))
{
PartnerFindTDS result =
TRemote.MPartner.Partner.WebConnectors.FindPartners(
"",
Ict.Petra.Shared.MPartner.Calculations.FormatShortName(FCurrentPartner.PartnerShortName, eShortNameFormat.eOnlySurname),
BestLocation.City,
new StringCollection());
if (result.SearchResult.DefaultView.Count > 0)
{
grdMatchingRecords.AddTextColumn(Catalog.GetString("Class"), result.SearchResult.ColumnPartnerClass, 70);
grdMatchingRecords.AddTextColumn(Catalog.GetString("Name"), result.SearchResult.ColumnPartnerShortName, 150);
grdMatchingRecords.AddTextColumn(Catalog.GetString("Address"), result.SearchResult.ColumnStreetName, 200);
grdMatchingRecords.AddTextColumn(Catalog.GetString("City"), result.SearchResult.ColumnCity, 100);
grdMatchingRecords.AddTextColumn(Catalog.GetString("Post Code"), result.SearchResult.ColumnPostalCode, 74);
grdMatchingRecords.SelectionMode = SourceGrid.GridSelectionMode.Row;
result.SearchResult.DefaultView.AllowNew = false;
//
// For any partner class OTHER THAN Person, I only want to see matching records of the same class.
if (FCurrentPartner.PartnerClass == MPartnerConstants.PARTNERCLASS_PERSON)
{
result.SearchResult.DefaultView.RowFilter = String.Empty;
}
else
{
result.SearchResult.DefaultView.RowFilter = String.Format("{0} = '{1}'",
PartnerFindTDSSearchResultTable.GetPartnerClassDBName(),
FCurrentPartner.PartnerClass);
}
grdMatchingRecords.DataSource = new DevAge.ComponentModel.BoundDataView(result.SearchResult.DefaultView);
txtHint.Text = "Create a new partner, or select an existing match for addtional options.";
}
else
{
btnCreateNewPartner.Focus();
txtHint.Text = "Select \"Create Partner\" to import this partner.";
}
FoundPartnerMatchingKey = -1;
FoundPossiblePartnersInDatabase = result.SearchResult.Rows.Count != 0;
// Check if the partner to import matches completely one of the search results
foreach (PartnerFindTDSSearchResultRow row in result.SearchResult.Rows)
{
if ((row.StreetName == BestLocation.StreetName)
&& (row.City == BestLocation.City)
&& (row.PostalCode == BestLocation.PostalCode)
&& (row.PartnerClass == FCurrentPartner.PartnerClass)
&& (row.PartnerShortName == FCurrentPartner.PartnerShortName))
{
FoundPartnerInDatabase = true;
FoundPartnerMatchingKey = row.PartnerKey;
break;
}
}
if (FoundPartnerInDatabase)
{
// Now I want to pre-select this item...
int MatchRow;
for (MatchRow = 0; MatchRow < result.SearchResult.DefaultView.Count; MatchRow++)
{
PartnerFindTDSSearchResultRow Row = (PartnerFindTDSSearchResultRow)result.SearchResult.DefaultView[MatchRow].Row;
if (Row.PartnerKey == FoundPartnerMatchingKey)
{
grdMatchingRecords.SelectRowInGrid(MatchRow + 1);
OnMatchingRecordSelChange(null, null);
break;
}
}
}
}
if (FThreadAutomaticImport != null)
{
if (FoundPartnerInDatabase)
{
// TODO: if any data is different, wait for user interaction, or update data automatically?
// otherwise go to next partner
NextRecord();
}
else if (!FoundPossiblePartnersInDatabase)
{
// Automatically create a new partner, and proceed to next partner
// TODO: create PERSON or FAMILY?
try
{
AddStatus("<Automatic import>" + Environment.NewLine);
CreateOrUpdatePartner(FCurrentPartner, true);
}
catch (Exception e)
{
TLogging.Log(e.Message);
TLogging.Log(e.StackTrace);
// TODO cleaner message box
MessageBox.Show(e.Message);
FNeedUserFeedback = true;
}
}
else
{
FNeedUserFeedback = true;
}
}
else // if "auto" is not selected, I'll stop here and wait for user input.
{
btnCreateNewPartner.Enabled = true;
btnSkip.Enabled = true;
}
}
private void ImportOptionalDetails(PPartnerRow APartnerRow, TFileVersionInfo APetraVersion, TDBTransaction ATransaction)
{
string KeyWord = ReadString();
while (KeyWord != "END")
{
if (KeyWord == "ABILITY")
{
ImportAbility(ATransaction);
}
else if (KeyWord == "ADDRESS")
{
ImportLocation(ATransaction);
}
else if (KeyWord == "APPLCTN")
{
ImportApplication(APetraVersion, ATransaction);
}
else if (KeyWord == "COMMENT")
{
ImportComment(APartnerRow);
}
else if (KeyWord == "COMMENTSEQ")
{
ImportCommentSeq();
}
else if (KeyWord == "COMMIT")
{
ImportStaffData(ATransaction);
}
else if (KeyWord == "JOB")
{
ImportJob(APetraVersion, ATransaction);
}
else if (KeyWord == "LANGUAGE")
{
ImportLanguage(APetraVersion, ATransaction);
}
else if (KeyWord == "PREVEXP")
{
ImportPreviousExperience(APetraVersion, ATransaction);
}
else if (KeyWord == "PASSPORT")
{
ImportPassport(APetraVersion, ATransaction);
}
else if (KeyWord == "PERSDOCUMENT")
{
ImportPersonalDocument(ATransaction);
}
else if (KeyWord == "PERSONAL")
{
ImportPersonalData(APetraVersion, ATransaction);
}
else if (KeyWord == "PROFESN")
{
ImportProfessionalData(ATransaction);
}
else if (KeyWord == "PROGREP")
{
ImportPersonEvaluation(ATransaction);
}
else if (KeyWord == "SPECNEED")
{
ImportSpecialNeeds(APetraVersion, ATransaction);
}
else if (KeyWord == "TYPE")
{
ImportPartnerType(ATransaction);
}
else if (KeyWord == "PARTNERATTRIBUTE")
{
ImportPartnerAttribute(ATransaction);
FParsingOfPartnerLocationsForContactDetailsNecessary = false;
}
else if (KeyWord == "INTEREST")
{
ImportInterest(ATransaction);
}
else if (KeyWord == "GIFTDESTINATION")
{
ImportGiftDestination(ATransaction);
}
else if (KeyWord == "U-ABILITY")
{
ImportUnitAbility(ATransaction);
}
else if (KeyWord == "U-COSTS")
{
ImportUnitCosts(ATransaction);
}
else if (KeyWord == "U-JOB")
{
ImportUnitJob();
}
else if (KeyWord == "UJ-ABIL")
{
ImportUnitJobAbility();
}
else if (KeyWord == "UJ-LANG")
{
ImportUnitJobLanguage();
}
else if (KeyWord == "UJ-QUAL")
{
ImportUnitJobQualification();
}
else if (KeyWord == "UJ-VISION")
{
ImportUnitJobVision();
}
else if (KeyWord == "U-LANG")
{
ImportUnitLanguage(ATransaction);
}
else if (KeyWord == "U-STRUCT")
{
ImportUnitStructure(ATransaction);
}
else if (KeyWord == "U-VISION")
{
ImportUnitVision(ATransaction);
}
else if (KeyWord == "V-BUILDING")
{
ImportBuilding(ATransaction);
}
else if (KeyWord == "V-ROOM")
{
ImportRoom(ATransaction);
}
else if (KeyWord == "VISION")
{
ImportVision(ATransaction);
}
else
{
throw new Exception("Found unknown option " + KeyWord);
}
KeyWord = ReadString();
}
}
private static void CheckAddresseeTypeCode(PartnerImportExportTDS MainDS,
PPartnerRow PartnerRow,
ref TVerificationResultCollection ReferenceResults,
TDBTransaction Transaction)
{
// Addresssee type: Check that we know how to address this partner:
if ((PartnerRow.AddresseeTypeCode != "") && (!PAddresseeTypeAccess.Exists(PartnerRow.AddresseeTypeCode, Transaction)))
{
AddVerificationResult(ref ReferenceResults, "Adding new Addressee Type Code " + PartnerRow.AddresseeTypeCode);
PAddresseeTypeRow Row = MainDS.PAddresseeType.NewRowTyped();
Row.AddresseeTypeCode = PartnerRow.AddresseeTypeCode;
Row.Description = FNewRowDescription;
MainDS.PAddresseeType.Rows.Add(Row);
}
}
/// <summary>
/// Copy this Partner, and all the data linked to it, from the large DataSet into a new one,
/// and send it back to the server for committing.
///
/// NOTE: May be called recursively to add parent records before adding children.
/// </summary>
/// <param name="APartnerRow">Row to import</param>
/// <param name="StepAfterImport">Go on to next record afterwards. (Usually true)</param>
/// <returns>Partner key of imported record (although no-one cares)</returns>
private Int64 CreateOrUpdatePartner(PPartnerRow APartnerRow, Boolean StepAfterImport)
{
if ((FCurrentNumberOfRecord < 1) || (FCurrentNumberOfRecord > FTotalNumberOfRecords))
{
return 0;
}
if (FImportedUnits.Contains(APartnerRow.PartnerKey))
{
return APartnerRow.PartnerKey;
}
PartnerImportExportTDS NewPartnerDS = new PartnerImportExportTDS();
NewPartnerDS.PPartner.ImportRow(APartnerRow);
Int64 OrigPartnerKey = APartnerRow.PartnerKey;
Int64 NewPartnerKey = OrigPartnerKey;
bool UpdateExistingRecord = false;
// If the import file had a negative PartnerKey, I need to create a new one here,
// and use it on all the dependent tables.
if (OrigPartnerKey < 0)
{
if (ExistingPartnerKey > 0) // This ExistingPartnerKey has been set by the UseSelectedPerson button.
{
NewPartnerKey = ExistingPartnerKey;
UpdateExistingRecord = true;
ExistingPartnerKey = -1; // Don't use this next time!
}
else
{
NewPartnerKey = TRemote.MPartner.Partner.WebConnectors.NewPartnerKey(-1);
}
}
if (UpdateExistingRecord)
{
NewPartnerDS.PPartner[0].PartnerKey = UserSelectedRow.PartnerKey;
NewPartnerDS.PPartner[0].DateCreated = UserSelectedRow.DateCreated;
NewPartnerDS.PPartner[0].CreatedBy = UserSelectedRow.CreatedBy;
NewPartnerDS.PPartner[0].ModificationId = UserSelectedRow.ModificationId;
NewPartnerDS.PPartner[0].AcceptChanges(); // This should reset the RowState, allowing me to Update rather than Add
}
NewPartnerDS.PPartner[0].PartnerKey = NewPartnerKey;
if (NewPartnerDS.PPartner[0].PartnerClass == MPartnerConstants.PARTNERCLASS_CHURCH)
{
ImportRecordsByPartnerKey(NewPartnerDS.PChurch, FMainDS.PChurch,
PChurchTable.GetPartnerKeyDBName(), OrigPartnerKey, NewPartnerKey, UpdateExistingRecord);
}
else if (NewPartnerDS.PPartner[0].PartnerClass == MPartnerConstants.PARTNERCLASS_FAMILY)
{
//
// Before I change the PartnerKey on this PFamily, I need to update any PPerson records that are linked to it,
// so that the links will still work...
FMainDS.PPerson.DefaultView.RowFilter = String.Format("{0}={1}", PartnerEditTDSPPersonTable.GetFamilyKeyDBName(), OrigPartnerKey);
foreach (DataRowView rv in FMainDS.PPerson.DefaultView)
{
PPersonRow RelatedPerson = (PPersonRow)rv.Row;
RelatedPerson.FamilyKey = NewPartnerKey;
}
ImportRecordsByPartnerKey(NewPartnerDS.PFamily, FMainDS.PFamily,
PFamilyTable.GetPartnerKeyDBName(), OrigPartnerKey, NewPartnerKey, UpdateExistingRecord);
}
else if (NewPartnerDS.PPartner[0].PartnerClass == MPartnerConstants.PARTNERCLASS_PERSON)
{
ImportRecordsByPartnerKey(NewPartnerDS.PPerson, FMainDS.PPerson,
PPersonTable.GetPartnerKeyDBName(), OrigPartnerKey, NewPartnerKey, UpdateExistingRecord);
NewPartnerDS.PPerson.DefaultView.RowFilter = String.Format("{0}={1}", PPersonTable.GetPartnerKeyDBName(), NewPartnerKey);
Int64 RelatedFamilyKey = ((PPersonRow)NewPartnerDS.PPerson.DefaultView[0].Row).FamilyKey;
// If there's an associated PFamily record that I've not imported yet, I could try to do that now,
// but it's problematic because it might end up getting imported twice.
// Anyway, I should not come to here because the family should have been imported first.
if (RelatedFamilyKey < 0) // There's a related family that's not been imported
{
AddStatus("Import Problem: PPerson record with no related PFamily.");
return 0;
}
}
else if (NewPartnerDS.PPartner[0].PartnerClass == MPartnerConstants.PARTNERCLASS_ORGANISATION)
{
ImportRecordsByPartnerKey(NewPartnerDS.POrganisation, FMainDS.POrganisation,
POrganisationTable.GetPartnerKeyDBName(), OrigPartnerKey, NewPartnerKey, UpdateExistingRecord);
}
else if (NewPartnerDS.PPartner[0].PartnerClass == MPartnerConstants.PARTNERCLASS_UNIT)
{
ImportRecordsByPartnerKey(NewPartnerDS.PUnit, FMainDS.PUnit,
PUnitTable.GetPartnerKeyDBName(), OrigPartnerKey, NewPartnerKey, UpdateExistingRecord);
/*
* // I'm doing this later, in AddUnitstructure
* ImportRecordsByPartnerKey(NewPartnerDS.UmUnitStructure, FMainDS.UmUnitStructure,
* UmUnitStructureTable.GetChildUnitKeyDBName(), OrigPartnerKey, NewPartnerKey, UpdateExistingRecord);
*/
FImportedUnits.Add(NewPartnerKey);
/*
* // I don't need this at all...
* foreach (UmUnitStructureRow UnitStructureRow in NewPartnerDS.UmUnitStructure.Rows)
* {
* UnitStructureRow.ChildUnitKey = NewPartnerKey;
* }
*/
}
else if (NewPartnerDS.PPartner[0].PartnerClass == MPartnerConstants.PARTNERCLASS_VENUE)
{
ImportRecordsByPartnerKey(NewPartnerDS.PVenue, FMainDS.PVenue,
PVenueTable.GetPartnerKeyDBName(), OrigPartnerKey, NewPartnerKey, UpdateExistingRecord);
}
else if (NewPartnerDS.PPartner[0].PartnerClass == MPartnerConstants.PARTNERCLASS_BANK)
{
ImportRecordsByPartnerKey(NewPartnerDS.PBank, FMainDS.PBank,
PBankTable.GetPartnerKeyDBName(), OrigPartnerKey, NewPartnerKey, UpdateExistingRecord);
}
// Add special types etc
AddAbility(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddApplication(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddAddresses(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddCommentSeq(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddStaffData(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddJobAssignment(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddPmPersonLanguage(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddPreviousExperience(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddPassport(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddPersonalDocument(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddPersonalData(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddProfessionalData(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddPersonalEvaluation(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddSpecialNeeds(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddPartnerType(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
foreach (PPartnerTypeRow PartnerTypeRow in NewPartnerDS.PPartnerType.Rows)
{
PartnerTypeRow.PartnerKey = NewPartnerKey;
}
AddInterest(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
// AddVision(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddGiftDestination(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddUnitstructure(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddBuilding(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddRoom(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddSubscriptions(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddContacts(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
AddBankingDetails(OrigPartnerKey, NewPartnerKey, ref NewPartnerDS);
TVerificationResultCollection VerificationResult;
bool CommitRes = TRemote.MPartner.ImportExport.WebConnectors.CommitChanges(NewPartnerDS, out VerificationResult);
AddStatus(FormatVerificationResult("Save Partner: ", VerificationResult));
if (!CommitRes)
{
String ResultString = "";
foreach (TVerificationResult row in VerificationResult)
{
if (row.ResultSeverity == TResultSeverity.Resv_Critical)
{
ResultString += row.ResultContext.ToString() + Environment.NewLine + " " + row.ResultText + Environment.NewLine;
}
}
MessageBox.Show(ResultString, Catalog.GetString("Error"), MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
// new record has been created, now load the next record
if (StepAfterImport)
{
NextRecord();
}
}
return NewPartnerKey;
}
/// <summary>
/// Tests whether the current user has access to a particular Partner.
/// </summary>
/// <remarks>This Method throws an <see cref="ESecurityPartnerAccessDeniedException" />
/// if access to the Partner is not granted, thereby ensuring that a denied access
/// doesn't go unnoticed.</remarks>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <param name="AIsFoundation">Set to true if Partner is a Foundation.</param>
/// <param name="AFoundationRow">Foundation Row needs to be passed in
/// if Partner is a Foundation.</param>
/// <returns>void</returns>
/// <exception cref="ESecurityPartnerAccessDeniedException">Thrown if access is not granted.</exception>
public static void CanAccessPartnerExc(PPartnerRow APartnerRow, bool AIsFoundation,
PFoundationRow AFoundationRow)
{
TPartnerAccessLevelEnum AccessLevel;
AccessLevel = CanAccessPartner(APartnerRow, AIsFoundation, AFoundationRow);
AccessLevelExceptionEvaluatorAndThrower(APartnerRow, AccessLevel);
}
private void ValidateDataManual(PPartnerRow ARow)
{
TVerificationResultCollection VerificationResultCollection = FPetraUtilsObject.VerificationResultCollection;
TSharedPartnerValidation_Partner.ValidatePartnerManual(this, ARow, ref VerificationResultCollection,
FValidationControlsDict);
if (FPartnerClass == "PERSON")
{
PPersonValidation.Validate(this, FMainDS.PPerson[0], ref VerificationResultCollection,
FValidationControlsDict);
}
else if (FPartnerClass == "FAMILY")
{
PFamilyValidation.Validate(this, FMainDS.PFamily[0], ref VerificationResultCollection,
FValidationControlsDict);
}
else if (FPartnerClass == "CHURCH")
{
PChurchValidation.Validate(this, FMainDS.PChurch[0], ref VerificationResultCollection,
FValidationControlsDict);
}
else if (FPartnerClass == "ORGANISATION")
{
POrganisationValidation.Validate(this, FMainDS.POrganisation[0], ref VerificationResultCollection,
FValidationControlsDict);
}
else if (FPartnerClass == "UNIT")
{
PUnitValidation.Validate(this, FMainDS.PUnit[0], ref VerificationResultCollection,
FValidationControlsDict);
}
else if (FPartnerClass == "BANK")
{
PBankValidation.Validate(this, FMainDS.PBank[0], ref VerificationResultCollection,
FValidationControlsDict);
}
else if (FPartnerClass == "VENUE")
{
PVenueValidation.Validate(this, FMainDS.PVenue[0], ref VerificationResultCollection,
FValidationControlsDict);
}
}
/// <summary>
/// Check that I seem to have the right partner tables for this PartnerClass.
///
/// If the child records (PPerson, PFamily, etc) have no ModificationID,
/// (because these are new records - not originally from the database)
/// I need to get the current one from the server to prevent it sulking.
/// </summary>
/// <param name="PartnerRow"></param>
/// <param name="MainDS"></param>
/// <param name="ReferenceResults"></param>
/// <param name="Transaction"></param>
/// <returns></returns>
private static bool CheckPartnerClass(PPartnerRow PartnerRow,
PartnerImportExportTDS MainDS,
ref TVerificationResultCollection ReferenceResults,
TDBTransaction Transaction)
{
if (PartnerRow.PartnerClass == MPartnerConstants.PARTNERCLASS_FAMILY)
{
if (MainDS.PFamily.Rows.Count < 1)
{
AddVerificationResult(ref ReferenceResults, "Internal Error - No Family row for FAMILY", TResultSeverity.Resv_Critical);
return false;
}
PFamilyTable Table = PFamilyAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, Transaction);
if (Table.Rows.Count > 0)
{
MainDS.PFamily[0].DateCreated = Table[0].DateCreated;
MainDS.PFamily[0].CreatedBy = Table[0].CreatedBy;
MainDS.PFamily[0].ModificationId = Table[0].ModificationId;
}
}
if (PartnerRow.PartnerClass == MPartnerConstants.PARTNERCLASS_PERSON)
{
if (MainDS.PPerson.Rows.Count < 1)
{
AddVerificationResult(ref ReferenceResults, "Internal Error - No Person row for PERSON", TResultSeverity.Resv_Critical);
return false;
}
PPersonTable Table = PPersonAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, Transaction);
if (Table.Rows.Count > 0)
{
MainDS.PPerson[0].DateCreated = Table[0].DateCreated;
MainDS.PPerson[0].CreatedBy = Table[0].CreatedBy;
MainDS.PPerson[0].ModificationId = Table[0].ModificationId;
}
if ((MainDS.PPerson[0].IsFamilyIdNull()) || (MainDS.PPerson[0].FamilyId == 0)) // Every Person must have a FamilyId..
{
bool FamilyIdOk = false;
if (MainDS.PPerson[0].PartnerKey > 0) // If I've got a real key, then my existing FamilyId might also be real
{
PPersonTable PersonTable = PPersonAccess.LoadByPrimaryKey(MainDS.PPerson[0].PartnerKey, Transaction);
if (PersonTable.Rows.Count != 0)
{
MainDS.PPerson[0].FamilyId = PersonTable[0].FamilyId;
FamilyIdOk = true;
}
}
if (!FamilyIdOk) // Otherwise I'll just grab one that's available.
{
TPartnerFamilyIDHandling IdFactory = new TPartnerFamilyIDHandling();
TFamilyIDSuccessEnum FamIdRes = TFamilyIDSuccessEnum.fiSuccess;
int NewFamilyId;
String NewFamilyMsg;
FamIdRes = IdFactory.GetNewFamilyID(MainDS.PPerson[0].FamilyKey, out NewFamilyId, out NewFamilyMsg);
if (FamIdRes != TFamilyIDSuccessEnum.fiError)
{
MainDS.PPerson[0].FamilyId = NewFamilyId;
}
else
{
AddVerificationResult(ref ReferenceResults,
"Problem generating family id: " + NewFamilyMsg,
TResultSeverity.Resv_Critical);
return false;
}
}
}
}
if (PartnerRow.PartnerClass == MPartnerConstants.PARTNERCLASS_UNIT)
{
if (MainDS.PUnit.Rows.Count < 1)
{
AddVerificationResult(ref ReferenceResults, "Internal Error - No Unit row for UNIT", TResultSeverity.Resv_Critical);
return false;
}
PUnitTable Table = PUnitAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, Transaction);
if (Table.Rows.Count > 0)
{
MainDS.PUnit[0].DateCreated = Table[0].DateCreated;
MainDS.PUnit[0].CreatedBy = Table[0].CreatedBy;
MainDS.PUnit[0].ModificationId = Table[0].ModificationId;
}
}
if (PartnerRow.PartnerClass == MPartnerConstants.PARTNERCLASS_CHURCH)
{
if (MainDS.PChurch.Rows.Count < 1)
{
AddVerificationResult(ref ReferenceResults, "Internal Error - No Church row for CHURCH", TResultSeverity.Resv_Critical);
return false;
}
PChurchTable Table = PChurchAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, Transaction);
if (Table.Rows.Count > 0)
{
MainDS.PChurch[0].DateCreated = Table[0].DateCreated;
MainDS.PChurch[0].CreatedBy = Table[0].CreatedBy;
MainDS.PChurch[0].ModificationId = Table[0].ModificationId;
}
}
if (PartnerRow.PartnerClass == MPartnerConstants.PARTNERCLASS_ORGANISATION)
{
if (MainDS.POrganisation.Rows.Count < 1)
{
AddVerificationResult(ref ReferenceResults,
"Internal Error - No Organisation row for ORGANISATION",
TResultSeverity.Resv_Critical);
return false;
}
POrganisationTable Table = POrganisationAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, Transaction);
if (Table.Rows.Count > 0)
{
MainDS.POrganisation[0].DateCreated = Table[0].DateCreated;
MainDS.POrganisation[0].CreatedBy = Table[0].CreatedBy;
MainDS.POrganisation[0].ModificationId = Table[0].ModificationId;
}
}
if (PartnerRow.PartnerClass == MPartnerConstants.PARTNERCLASS_BANK)
{
if (MainDS.PBank.Rows.Count < 1)
{
AddVerificationResult(ref ReferenceResults, "Internal Error - No Bank row for BANK", TResultSeverity.Resv_Critical);
return false;
}
PBankTable Table = PBankAccess.LoadByPrimaryKey(PartnerRow.PartnerKey, Transaction);
if (Table.Rows.Count > 0)
{
MainDS.PBank[0].DateCreated = Table[0].DateCreated;
MainDS.PBank[0].CreatedBy = Table[0].CreatedBy;
MainDS.PBank[0].ModificationId = Table[0].ModificationId;
}
}
return true;
}
private void CreateNewPartner(bool AUseSelectedAddress = false)
{
string ShortName = null;
TPartnerClass PartnerClass;
bool Merged;
bool UserCanAccessPartner;
// if a partner with this partner key already exists
if ((FCurrentPartner.PartnerKey >= 0)
&& TServerLookup.TMPartner.VerifyPartner(
FCurrentPartner.PartnerKey, out ShortName, out PartnerClass, out Merged, out UserCanAccessPartner))
{
if (MessageBox.Show(string.Format(Catalog.GetString("A partner with this partner key already exists in the database.{0}{0}" +
"Partner Key: {1}{0}Partner Name: {2}{0}Partner Class: {3}{0}{0}" +
"Do you want to continue creating this new partner with a new partner key?"),
"\r\n", FCurrentPartner.PartnerKey.ToString("0000000000"), ShortName, PartnerClass),
Catalog.GetString("Create Partner"),
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.No)
{
AddStatus(Catalog.GetString("Create new partner cancelled.") + "\r\n\r\n");
return;
}
else
{
// reload data from scratch using new partner key
TVerificationResultCollection VerificationResult = new TVerificationResultCollection();
Int64 NewPartnerKey = TRemote.MPartner.Partner.WebConnectors.NewPartnerKey(-1);
LoadDataSet(ref VerificationResult, FCurrentPartner.PartnerKey, NewPartnerKey);
FCurrentPartner = FMainDS.PPartner[FCurrentNumberOfRecord - 1];
}
}
if (AUseSelectedAddress)
{
// This expression uses the first location key in the imported data, which matches the method used
// to create the data grid from which the address was selected.
// Only this one address will be shared - if there are also other addresses,
// these will be created. (And checks on CommitChanges may catch them.) But in most cases it's probably useful.
((PPartnerLocationRow)FMainDS.PPartnerLocation.DefaultView[0].Row).LocationKey = UserSelLocationKey;
}
CreateOrUpdatePartner(FCurrentPartner, true);
}
private static void CheckMaritalStatus(PartnerImportExportTDS MainDS,
PPartnerRow PartnerRow,
ref TVerificationResultCollection ReferenceResults,
TDBTransaction Transaction)
{
// Marital Status: The Marital status code used must be present in PTMaritalStatus
String RequiredMaritalStatus = "";
if (PartnerRow.PartnerClass == MPartnerConstants.PARTNERCLASS_FAMILY)
{
RequiredMaritalStatus = ((PFamilyRow)MainDS.PFamily.Rows[0]).MaritalStatus;
}
if (PartnerRow.PartnerClass == MPartnerConstants.PARTNERCLASS_PERSON)
{
RequiredMaritalStatus = ((PPersonRow)MainDS.PPerson.Rows[0]).MaritalStatus;
}
if ((RequiredMaritalStatus != "") && (!PtMaritalStatusAccess.Exists(RequiredMaritalStatus, Transaction)))
{
AddVerificationResult(ref ReferenceResults, "Adding Marital Status " + RequiredMaritalStatus);
PtMaritalStatusRow Row = MainDS.PtMaritalStatus.NewRowTyped();
Row.Code = RequiredMaritalStatus;
Row.Description = FNewRowDescription;
MainDS.PtMaritalStatus.Rows.Add(Row);
}
}
/// <summary>
/// Puts 'Head' data from a Partner DataRow into Partner Information data.
/// </summary>
/// <param name="APartnerDR">DataRow that contains the Partner data.</param>
/// <param name="APartnerInfoDS" >Typed PartnerInfoTDS DataSet</param>
private static void HeadInternal(PPartnerRow APartnerDR,
ref PartnerInfoTDS APartnerInfoDS)
{
PartnerInfoTDSPartnerHeadInfoRow PartnerHeadInfoDR;
if (APartnerInfoDS.PartnerHeadInfo.Rows.Count == 0)
{
PartnerHeadInfoDR = APartnerInfoDS.PartnerHeadInfo.NewRowTyped(false);
}
else
{
PartnerHeadInfoDR = APartnerInfoDS.PartnerHeadInfo[0];
}
PartnerHeadInfoDR.PartnerKey = APartnerDR.PartnerKey;
PartnerHeadInfoDR.PartnerShortName = APartnerDR.PartnerShortName;
PartnerHeadInfoDR.PartnerClass = APartnerDR.PartnerClass;
PartnerHeadInfoDR.StatusCode = APartnerDR.StatusCode;
PartnerHeadInfoDR.AcquisitionCode = APartnerDR.AcquisitionCode;
PartnerHeadInfoDR.PrivatePartnerOwner = APartnerDR.UserId;
if (APartnerInfoDS.PartnerHeadInfo.Rows.Count == 0)
{
APartnerInfoDS.PartnerHeadInfo.Rows.Add(PartnerHeadInfoDR);
}
}
private void ImportComment(PPartnerRow APartnerRow)
{
APartnerRow.Comment = ReadString();
}
/// <summary>
/// Tests whether the current user has access to a particular Partner.
/// </summary>
/// <remarks>This Method throws an <see cref="T:ESecurityPartnerAccessDeniedException" />
/// if access to the Partner is not granted, thereby ensuring that a denied access
/// doesn't go unnoticed.</remarks>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <returns>void</returns>
/// <exception cref="T:ESecurityPartnerAccessDeniedException">Thrown if access is not granted.</exception>
public static void CanAccessPartnerExc(PPartnerRow APartnerRow)
{
TPartnerAccessLevelEnum AccessLevel;
AccessLevel = CanAccessPartner(APartnerRow);
Ict.Petra.Shared.MPartner.TSecurity.AccessLevelExceptionEvaluatorAndThrower(
APartnerRow, AccessLevel);
}
private void ShowDataManual(PPartnerRow ARow)
{
// Ensure that the PartnerKey, which is the PrimaryKey of the p_partner Table, is always read-only
// (Read-Only gets set to false in ShowData() for a NEW Partner because it is the PrimaryKey).
txtPartnerKey.ReadOnly = true;
}
/// <summary>
/// Evaluates the passed in AccessLevel and throws
/// <see cref="ESecurityPartnerAccessDeniedException" /> if the AccessLevel
/// isn't <see cref="TPartnerAccessLevelEnum.palGranted" />.
/// </summary>
/// <param name="APartnerRow">Partner for which access should be checked for.</param>
/// <param name="AAccessLevel">AccessLevel as determined by caller.</param>
public static void AccessLevelExceptionEvaluatorAndThrower(
PPartnerRow APartnerRow, TPartnerAccessLevelEnum AAccessLevel)
{
switch (AAccessLevel)
{
case TPartnerAccessLevelEnum.palGranted:
return;
default:
throw new ESecurityPartnerAccessDeniedException("",
APartnerRow.PartnerKey, APartnerRow.PartnerShortName, AAccessLevel);
}
}
private static void CheckAcquisitionCode(PartnerImportExportTDS MainDS,
PPartnerRow PartnerRow,
ref TVerificationResultCollection ReferenceResults,
TDBTransaction Transaction)
{
// Acquisition: Check that partner's acquisition code exists in database
if ((PartnerRow.AcquisitionCode != "") && (!PAcquisitionAccess.Exists(PartnerRow.AcquisitionCode, Transaction)))
{
AddVerificationResult(ref ReferenceResults, "Adding new Acquisition Code " + PartnerRow.AcquisitionCode);
PAcquisitionRow Row = MainDS.PAcquisition.NewRowTyped();
Row.AcquisitionCode = PartnerRow.AcquisitionCode;
Row.AcquisitionDescription = FNewRowDescription;
MainDS.PAcquisition.Rows.Add(Row);
}
}
/// <summary>
/// If the address I'm importing is already on file, I don't want to create another row.
/// </summary>
/// <param name="MainDS"></param>
/// <param name="PartnerRow"></param>
/// <param name="ReferenceResults"></param>
/// <param name="Transaction"></param>
private static void CheckAddresses(PartnerImportExportTDS MainDS,
PPartnerRow PartnerRow,
ref TVerificationResultCollection ReferenceResults,
TDBTransaction Transaction)
{
PLocationTable LocationTable = PLocationAccess.LoadViaPPartner(PartnerRow.PartnerKey, Transaction);
if (LocationTable.Rows.Count == 0)
{
return;
}
for (int ImportPartnerLocationRowIdx = 0; ImportPartnerLocationRowIdx < MainDS.PPartnerLocation.Rows.Count; )
{
PPartnerLocationRow ImportPartnerLocationRow = (PPartnerLocationRow)MainDS.PPartnerLocation[ImportPartnerLocationRowIdx];
MainDS.PLocation.DefaultView.RowFilter = String.Format("{0}={1}",
PLocationTable.GetLocationKeyDBName(), ImportPartnerLocationRow.LocationKey);
bool RowRemoved = false;
if (MainDS.PLocation.DefaultView.Count > 0)
{
PLocationRow ImportLocationRow = (PLocationRow)MainDS.PLocation.DefaultView[0].Row;
// Now I want to find out whether this row exists in my database.
foreach (PLocationRow DbLocationRow in LocationTable.Rows)
{
if (
(DbLocationRow.StreetName == ImportLocationRow.StreetName)
&& (DbLocationRow.Locality == ImportLocationRow.Locality)
&& (DbLocationRow.City == ImportLocationRow.City)
&& (DbLocationRow.PostalCode == ImportLocationRow.PostalCode)
)
{
String ExistingAddress = Calculations.DetermineLocationString(DbLocationRow,
Calculations.TPartnerLocationFormatEnum.plfCommaSeparated);
MainDS.PLocation.Rows.Remove(ImportLocationRow);
MainDS.PPartnerLocation.Rows.RemoveAt(ImportPartnerLocationRowIdx);
AddVerificationResult(ref ReferenceResults, "Existing address used: " + ExistingAddress, TResultSeverity.Resv_Status);
RowRemoved = true;
break; // If there's already a duplicate in the database, I can't fix that here...
}
}
}
if (!RowRemoved)
{
ImportPartnerLocationRowIdx++; // There is no auto-increment on the "for" loop.
}
}
}
private void GetDataFromControlsExtra(PPartnerRow ARow)
{
/*
* Extra logic is needed for FAMILY and PERSON Partners because ARow.NoSolicitations is overwritten in
* the auto-generated GetDataFromControls Method by the value of chkOtherNoSolicitations.Checked!
*/
if (FPartnerClass == SharedTypes.PartnerClassEnumToString(TPartnerClass.FAMILY))
{
ARow.NoSolicitations = chkFamilyNoSolicitations.Checked;
ARow.AddresseeTypeCode = cmbFamilyAddresseeTypeCode.GetSelectedString();
}
else if (FPartnerClass == SharedTypes.PartnerClassEnumToString(TPartnerClass.PERSON))
{
ARow.NoSolicitations = chkPersonNoSolicitations.Checked;
ARow.AddresseeTypeCode = cmbPersonAddresseeTypeCode.GetSelectedString();
}
}
/// <summary>
/// Retrieves 'Rest' of Partner Information data.
/// </summary>
/// <param name="APartnerDR">DataRow that contains the Partner data.</param>
/// <param name="AReadTransaction" >Open DB Transaction.</param>
/// <param name="APartnerInfoDS" >Typed PartnerInfoTDS DataSet</param>
private static void RestInternal(PPartnerRow APartnerDR,
TDBTransaction AReadTransaction,
ref PartnerInfoTDS APartnerInfoDS)
{
PartnerInfoTDSPartnerAdditionalInfoRow PartnerInfoDR;
TPartnerClass PartnerClass;
DateTime LastContactDate;
PPersonTable PersonDT;
PPartnerTable FamilyPartnerDT;
Int64 PartnerKey = APartnerDR.PartnerKey;
/*
* Load Special Types
*/
PPartnerTypeAccess.LoadViaPPartner(APartnerInfoDS, PartnerKey, AReadTransaction);
/*
* Load Subscriptions
*/
PSubscriptionAccess.LoadViaPPartnerPartnerKey(APartnerInfoDS, PartnerKey, AReadTransaction);
#region Populate PartnerAdditionalInfo Table
if (APartnerInfoDS.PartnerAdditionalInfo.Rows.Count == 0)
{
PartnerInfoDR = APartnerInfoDS.PartnerAdditionalInfo.NewRowTyped(false);
}
else
{
PartnerInfoDR = APartnerInfoDS.PartnerAdditionalInfo[0];
}
if (!APartnerDR.IsCommentNull())
{
PartnerInfoDR.Notes = APartnerDR.Comment.Trim();
}
if (!APartnerDR.IsDateCreatedNull())
{
PartnerInfoDR.DateCreated = APartnerDR.DateCreated;
}
if (!APartnerDR.IsDateModifiedNull())
{
PartnerInfoDR.DateModified = APartnerDR.DateModified;
}
if (!APartnerDR.IsLanguageCodeNull())
{
PartnerInfoDR.MainLanguages = APartnerDR.LanguageCode;
}
if (!APartnerDR.IsPreviousNameNull())
{
PartnerInfoDR.PreviousName = APartnerDR.PreviousName;
}
// Determination of Last Contact Date
TMailroom.GetLastContactDate(PartnerKey, out LastContactDate);
PartnerInfoDR.LastContact = LastContactDate;
/*
* Special Data according to Partner Class
*/
PartnerClass = SharedTypes.PartnerClassStringToEnum(APartnerDR.PartnerClass);
switch (PartnerClass)
{
case TPartnerClass.PERSON:
PersonDT = PPersonAccess.LoadByPrimaryKey(APartnerDR.PartnerKey, AReadTransaction);
if (PersonDT != null)
{
if (!PersonDT[0].IsDateOfBirthNull())
{
PartnerInfoDR.DateOfBirth = PersonDT[0].DateOfBirth;
}
// Get Family Members info
APartnerInfoDS.Merge(GetFamilyMembers(PersonDT[0].FamilyKey, AReadTransaction));
// Get Family Partner info
FamilyPartnerDT = PPartnerAccess.LoadByPrimaryKey(PersonDT[0].FamilyKey, AReadTransaction);
if (FamilyPartnerDT != null)
{
PartnerInfoDR.Family = FamilyPartnerDT[0].PartnerShortName;
PartnerInfoDR.FamilyKey = FamilyPartnerDT[0].PartnerKey;
}
// Get the Languages of a Person from Personnel
PartnerInfoDR.AdditionalLanguages = GetPersonLanguagesFromPersonnel(
APartnerDR.PartnerKey, PartnerInfoDR.MainLanguages, AReadTransaction);
}
break;
case TPartnerClass.FAMILY:
// Get Family Members info
APartnerInfoDS.Merge(GetFamilyMembers(PartnerKey, AReadTransaction));
break;
case TPartnerClass.UNIT:
// Get Unit structure info
APartnerInfoDS.Merge(GetUnitStructure(PartnerKey, AReadTransaction));
break;
}
// Get Partners' PartnerAttributes
PartnerAttributesInternal(PartnerKey, ref APartnerInfoDS, false);
// TODO: Apply Contact Details Security
if (APartnerInfoDS.PartnerAdditionalInfo.Rows.Count == 0)
{
APartnerInfoDS.PartnerAdditionalInfo.Rows.Add(PartnerInfoDR);
}
#endregion
}
private void GetDataFromControlsManual(PPartnerRow ARow)
{
GetDataFromControls();
}
