static partial void ValidateGiftDetailManual(ref TVerificationResultCollection AVerificationResult,
TTypedDataTable ASubmitTable)
{
TValidationControlsDict ValidationControlsDict = new TValidationControlsDict();
ValidationControlsDict.Add(ASubmitTable.Columns[AGiftDetailTable.ColumnGiftCommentOneId],
new TValidationControlsData(null, AGiftDetailTable.GetGiftCommentOneDBName()));
TPartnerClass RecipientPartnerClass;
string RecipientDescription;
for (int Counter = 0; Counter < ASubmitTable.Rows.Count; Counter++)
{
if (ASubmitTable.Rows[Counter].RowState != DataRowState.Deleted)
{
TPartnerServerLookups.GetPartnerShortName(((GiftBatchTDSAGiftDetailRow)ASubmitTable.Rows[Counter]).RecipientKey,
out RecipientDescription,
out RecipientPartnerClass);
GiftBatchTDSAGiftDetailRow Row = (GiftBatchTDSAGiftDetailRow)ASubmitTable.Rows[Counter];
Row.RecipientClass = RecipientPartnerClass.ToString();
TSharedFinanceValidation_Gift.ValidateGiftDetailManual("TTransactionWebConnector" +
" (Error in Row #" + Counter.ToString() + ")", // No translation of message text since the server's messages should be all in English
Row, ref AVerificationResult,
ValidationControlsDict);
}
}
}
public void TestDeleteOrganisation()
{
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
String TextMessage;
Boolean CanDeletePartner;
PPartnerRow OrganisationPartnerRow;
TSubmitChangesResult result;
Int64 PartnerKey;
TPartnerEditUIConnector connector = new TPartnerEditUIConnector();
PartnerEditTDS MainDS = new PartnerEditTDS();
OrganisationPartnerRow = TCreateTestPartnerData.CreateNewOrganisationPartner(MainDS);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create organisation record");
// check if organisation partner can be deleted (still needs to be possible at this point)
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(OrganisationPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(CanDeletePartner);
// now test actual deletion of Organisation partner
PartnerKey = OrganisationPartnerRow.PartnerKey;
Assert.IsTrue(TPartnerWebConnector.DeletePartner(PartnerKey, out VerificationResult));
// check that Organisation record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(PartnerKey));
}
public void TestDeleteVenue()
{
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
String TextMessage;
Boolean CanDeletePartner;
PPartnerRow VenuePartnerRow;
TSubmitChangesResult result;
Int64 PartnerKey;
TPartnerEditUIConnector connector = new TPartnerEditUIConnector();
PartnerEditTDS MainDS = new PartnerEditTDS();
VenuePartnerRow = TCreateTestPartnerData.CreateNewVenuePartner(MainDS);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create venue record");
// check if Venue partner can be deleted (still needs to be possible at this point)
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(VenuePartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(CanDeletePartner);
// set up buildings for this venue so deletion is not allowed
PcBuildingTable BuildingTable = new PcBuildingTable();
PcBuildingRow BuildingRow = BuildingTable.NewRowTyped();
BuildingRow.VenueKey = VenuePartnerRow.PartnerKey;
BuildingRow.BuildingCode = "Test";
BuildingTable.Rows.Add(BuildingRow);
PcBuildingAccess.SubmitChanges(BuildingTable, DBAccess.GDBAccessObj.Transaction);
// now deletion must not be possible since a building is linked to the venue
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(VenuePartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(!CanDeletePartner);
// now test actual deletion of venue partner
VenuePartnerRow = TCreateTestPartnerData.CreateNewVenuePartner(MainDS);
PartnerKey = VenuePartnerRow.PartnerKey;
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create venue record for deletion");
// check if Venue record is being deleted
Assert.IsTrue(TPartnerWebConnector.DeletePartner(PartnerKey, out VerificationResult));
// check that Venue record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(PartnerKey));
}
public void TestDeleteUnit()
{
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
String TextMessage;
Boolean CanDeletePartner;
PPartnerRow UnitPartnerRow;
PUnitRow UnitRow;
TSubmitChangesResult result;
Int64 PartnerKey;
TDataBase db = DBAccess.Connect("TestDeleteUnit");
TPartnerEditUIConnector connector = new TPartnerEditUIConnector(db);
PartnerEditTDS MainDS = new PartnerEditTDS();
UnitPartnerRow = TCreateTestPartnerData.CreateNewUnitPartner(MainDS, db);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
// check if Unit partner can be deleted (still needs to be possible at this point)
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(UnitPartnerRow.PartnerKey, out TextMessage, db);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(CanDeletePartner);
// set unit type to Key Ministry which means it is not allowed to be deleted any longer
UnitRow = (PUnitRow)MainDS.PUnit.Rows[0];
UnitRow.UnitTypeCode = MPartnerConstants.UNIT_TYPE_KEYMIN;
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "set unit type to " + MPartnerConstants.UNIT_TYPE_KEYMIN);
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(UnitPartnerRow.PartnerKey, out TextMessage, db);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(!CanDeletePartner);
// now test actual deletion of Unit partner
UnitPartnerRow = TCreateTestPartnerData.CreateNewUnitPartner(MainDS, db);
PartnerKey = UnitPartnerRow.PartnerKey;
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create unit record for deletion");
// check if Unit record is being deleted
Assert.IsTrue(TPartnerWebConnector.DeletePartner(PartnerKey, out VerificationResult, db));
// check that Unit record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(PartnerKey));
}
/// <summary>
/// Retrieves the ShortName of a Partner.
/// </summary>
/// <param name="APartnerKey">PartnerKey of the Partner.</param>
/// <returns>ShortName of the specified Partner.</returns>
private static string GetPartnerShortName(long APartnerKey)
{
string ShortName = "";
Ict.Petra.Shared.TPartnerClass PartnerClass;
TPartnerServerLookups.GetPartnerShortName(APartnerKey, out ShortName, out PartnerClass);
return(ShortName);
}
private void DeletePartnerKeyWithUnit(Int64 APartnerKey)
{
TVerificationResultCollection VerificationResult;
// check if Unit record is being deleted
Assert.IsTrue(TPartnerWebConnector.DeletePartner(APartnerKey,
out VerificationResult), "Error deleting partner-key-with-unit " + APartnerKey.ToString());
// check that Unit record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(APartnerKey),
"Error. Partner-key-with-unit " + APartnerKey.ToString() + " still exists!");
}
public void TestDeleteBank()
{
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
String TextMessage;
Boolean CanDeletePartner;
PPartnerRow BankPartnerRow;
TSubmitChangesResult result;
Int64 PartnerKey;
TPartnerEditUIConnector connector = new TPartnerEditUIConnector();
PartnerEditTDS MainDS = new PartnerEditTDS();
BankPartnerRow = TCreateTestPartnerData.CreateNewBankPartner(MainDS);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create bank record");
// check if Bank partner can be deleted (still needs to be possible at this point)
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(BankPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(CanDeletePartner);
// set up details (e.g. bank account) for this Bank so deletion is not allowed
PBankingDetailsTable BankingDetailsTable = new PBankingDetailsTable();
PBankingDetailsRow BankingDetailsRow = BankingDetailsTable.NewRowTyped();
BankingDetailsRow.BankKey = BankPartnerRow.PartnerKey;
BankingDetailsRow.BankingType = 0;
BankingDetailsRow.BankingDetailsKey = Convert.ToInt32(TSequenceWebConnector.GetNextSequence(TSequenceNames.seq_bank_details));
BankingDetailsTable.Rows.Add(BankingDetailsRow);
PBankingDetailsAccess.SubmitChanges(BankingDetailsTable, DBAccess.GDBAccessObj.Transaction);
// now deletion must not be possible since a bank account is set up for the bank
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(BankPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(!CanDeletePartner);
// now test actual deletion of venue partner
BankPartnerRow = TCreateTestPartnerData.CreateNewBankPartner(MainDS);
PartnerKey = BankPartnerRow.PartnerKey;
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create bank partner for deletion");
// check if Venue record is being deleted
Assert.IsTrue(TPartnerWebConnector.DeletePartner(PartnerKey, out VerificationResult));
// check that Bank record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(PartnerKey));
}
public void TestDeleteChurch()
{
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
String TextMessage;
Boolean CanDeletePartner;
PPartnerRow ChurchPartnerRow;
PPartnerRow PartnerRow;
TSubmitChangesResult result;
Int64 PartnerKey;
TPartnerEditUIConnector connector = new TPartnerEditUIConnector();
PartnerEditTDS MainDS = new PartnerEditTDS();
ChurchPartnerRow = TCreateTestPartnerData.CreateNewChurchPartner(MainDS);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create church record");
// check if church partner can be deleted (still needs to be possible at this point)
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(ChurchPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(CanDeletePartner);
// create family partner and relationship to church partner
PartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS);
PPartnerRelationshipRow RelationshipRow = MainDS.PPartnerRelationship.NewRowTyped();
RelationshipRow.PartnerKey = ChurchPartnerRow.PartnerKey;
RelationshipRow.RelationName = "SUPPCHURCH";
RelationshipRow.RelationKey = PartnerRow.PartnerKey;
MainDS.PPartnerRelationship.Rows.Add(RelationshipRow);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "add relationship record to church record");
CommonNUnitFunctions.EnsureNullOrOnlyNonCriticalVerificationResults(VerificationResult,
"There was a critical error when saving:");
// now deletion must not be possible since relationship as SUPPCHURCH exists
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(ChurchPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(!CanDeletePartner);
// now test actual deletion of church partner
ChurchPartnerRow = TCreateTestPartnerData.CreateNewChurchPartner(MainDS);
PartnerKey = ChurchPartnerRow.PartnerKey;
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create church record for deletion");
// check if church record is being deleted
Assert.IsTrue(TPartnerWebConnector.DeletePartner(PartnerKey, out VerificationResult));
// check that church record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(PartnerKey));
}
public void TestDeletePerson()
{
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
String TextMessage;
Boolean CanDeletePartner;
PPartnerRow FamilyPartnerRow;
PPartnerRow UnitPartnerRow;
PPersonRow PersonRow;
TSubmitChangesResult result;
Int64 PartnerKey;
TPartnerEditUIConnector connector = new TPartnerEditUIConnector();
PartnerEditTDS MainDS = new PartnerEditTDS();
// create new family, location and person
FamilyPartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS);
TCreateTestPartnerData.CreateNewLocation(FamilyPartnerRow.PartnerKey, MainDS);
PersonRow = TCreateTestPartnerData.CreateNewPerson(MainDS,
FamilyPartnerRow.PartnerKey,
MainDS.PLocation[0].LocationKey,
"Mike",
"Mr",
0);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create family and person record");
// check if Family partner can be deleted (still needs to be possible at this point)
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(PersonRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(CanDeletePartner);
// add a commitment for the person which means the person is not allowed to be deleted any longer
UnitPartnerRow = TCreateTestPartnerData.CreateNewUnitPartner(MainDS);
PmStaffDataTable CommitmentTable = new PmStaffDataTable();
PmStaffDataRow CommitmentRow = CommitmentTable.NewRowTyped();
CommitmentRow.Key = Convert.ToInt32(TSequenceWebConnector.GetNextSequence(TSequenceNames.seq_staff_data));
CommitmentRow.PartnerKey = PersonRow.PartnerKey;
CommitmentRow.StartOfCommitment = DateTime.Today.Date;
CommitmentRow.EndOfCommitment = DateTime.Today.AddDays(90).Date;
CommitmentRow.OfficeRecruitedBy = UnitPartnerRow.PartnerKey;
CommitmentRow.HomeOffice = UnitPartnerRow.PartnerKey;
CommitmentRow.ReceivingField = UnitPartnerRow.PartnerKey;
CommitmentTable.Rows.Add(CommitmentRow);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create unit to be used in commitment");
PmStaffDataAccess.SubmitChanges(CommitmentTable, DBAccess.GDBAccessObj.Transaction);
// this should now not be allowed since person record has a commitment linked to it
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(PersonRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(!CanDeletePartner);
// now test actual deletion of Person partner
FamilyPartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS);
TCreateTestPartnerData.CreateNewLocation(FamilyPartnerRow.PartnerKey, MainDS);
PersonRow = TCreateTestPartnerData.CreateNewPerson(MainDS,
FamilyPartnerRow.PartnerKey,
MainDS.PLocation[0].LocationKey,
"Mary",
"Mrs",
0);
PartnerKey = PersonRow.PartnerKey;
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create family and person record to be deleted");
// check if Family record is being deleted
Assert.IsTrue(TPartnerWebConnector.DeletePartner(PartnerKey, out VerificationResult));
// check that Family record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(PartnerKey));
}
public void TestDeleteFamily()
{
DataSet ResponseDS = new PartnerEditTDS();
TVerificationResultCollection VerificationResult;
String TextMessage;
Boolean CanDeletePartner;
PPartnerRow FamilyPartnerRow;
PFamilyRow FamilyRow;
PPersonRow PersonRow;
TSubmitChangesResult result;
Int64 PartnerKey;
TPartnerEditUIConnector connector = new TPartnerEditUIConnector();
PartnerEditTDS MainDS = new PartnerEditTDS();
FamilyPartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "Create family record");
// check if Family partner can be deleted (still needs to be possible at this point)
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(FamilyPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(CanDeletePartner);
// add a person to the family which means the family is not allowed to be deleted any longer
FamilyRow = (PFamilyRow)MainDS.PFamily.Rows[0];
FamilyRow.FamilyMembers = true;
TCreateTestPartnerData.CreateNewLocation(FamilyPartnerRow.PartnerKey, MainDS);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create new location");
PartnerEditTDS PersonDS = new PartnerEditTDS();
PersonRow = TCreateTestPartnerData.CreateNewPerson(PersonDS, FamilyPartnerRow.PartnerKey,
MainDS.PLocation[0].LocationKey, "Adam", "Mr", 0);
PersonRow.FamilyKey = FamilyPartnerRow.PartnerKey;
result = connector.SubmitChanges(ref PersonDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create person record");
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(FamilyPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(!CanDeletePartner);
// create new family and create subscription given as gift from this family: not allowed to be deleted
FamilyPartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS);
PPublicationTable PublicationTable = PPublicationAccess.LoadByPrimaryKey("TESTPUBLICATION", DBAccess.GDBAccessObj.Transaction);
if (PublicationTable.Count == 0)
{
// first check if frequency "Annual" exists and if not then create it
if (!AFrequencyAccess.Exists("Annual", DBAccess.GDBAccessObj.Transaction))
{
// set up details (e.g. bank account) for this Bank so deletion is not allowed
AFrequencyTable FrequencyTable = new AFrequencyTable();
AFrequencyRow FrequencyRow = FrequencyTable.NewRowTyped();
FrequencyRow.FrequencyCode = "Annual";
FrequencyRow.FrequencyDescription = "Annual Frequency";
FrequencyTable.Rows.Add(FrequencyRow);
AFrequencyAccess.SubmitChanges(FrequencyTable, DBAccess.GDBAccessObj.Transaction);
}
// now add the publication "TESTPUBLICATION"
PPublicationRow PublicationRow = PublicationTable.NewRowTyped();
PublicationRow.PublicationCode = "TESTPUBLICATION";
PublicationRow.FrequencyCode = "Annual";
PublicationTable.Rows.Add(PublicationRow);
PPublicationAccess.SubmitChanges(PublicationTable, DBAccess.GDBAccessObj.Transaction);
}
// make sure that "reason subscription given" exists
if (!PReasonSubscriptionGivenAccess.Exists("FREE", DBAccess.GDBAccessObj.Transaction))
{
// set up details (e.g. bank account) for this Bank so deletion is not allowed
PReasonSubscriptionGivenTable ReasonTable = new PReasonSubscriptionGivenTable();
PReasonSubscriptionGivenRow ReasonRow = ReasonTable.NewRowTyped();
ReasonRow.Code = "FREE";
ReasonRow.Description = "Free Subscription";
ReasonTable.Rows.Add(ReasonRow);
PReasonSubscriptionGivenAccess.SubmitChanges(ReasonTable, DBAccess.GDBAccessObj.Transaction);
}
// now add the publication "TESTPUBLICATION" to the first family record and indicate it was a gift from newly created family record
PSubscriptionRow SubscriptionRow = MainDS.PSubscription.NewRowTyped();
SubscriptionRow.PublicationCode = "TESTPUBLICATION";
SubscriptionRow.PartnerKey = FamilyRow.PartnerKey; // link subscription with original family
SubscriptionRow.GiftFromKey = FamilyPartnerRow.PartnerKey; // indicate that subscription is a gift from newly created family
SubscriptionRow.ReasonSubsGivenCode = "FREE";
MainDS.PSubscription.Rows.Add(SubscriptionRow);
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "add publication to family record");
// this should now not be allowed since partner record has a subscription linked to it
CanDeletePartner = TPartnerWebConnector.CanPartnerBeDeleted(FamilyPartnerRow.PartnerKey, out TextMessage);
if (TextMessage.Length > 0)
{
TLogging.Log(TextMessage);
}
Assert.IsTrue(!CanDeletePartner);
// now test actual deletion of Family partner
FamilyPartnerRow = TCreateTestPartnerData.CreateNewFamilyPartner(MainDS);
PartnerKey = FamilyPartnerRow.PartnerKey;
result = connector.SubmitChanges(ref MainDS, ref ResponseDS, out VerificationResult);
Assert.AreEqual(TSubmitChangesResult.scrOK, result, "create family record");
// check if Family record is being deleted
Assert.IsTrue(TPartnerWebConnector.DeletePartner(PartnerKey, out VerificationResult));
// check that Family record is really deleted
Assert.IsTrue(!TPartnerServerLookups.VerifyPartner(PartnerKey));
}
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;
}
}
}
}
public static void FillFormDataFromPersonnel(Int64 APartnerKey,
TFormDataPerson AFormDataPerson,
TFormLetterInfo AFormLetterInfo,
TDBTransaction AReadTransaction,
Int64 ASiteKey = 0,
Int32 ALocationKey = 0)
{
TPartnerClass PartnerClass;
String ShortName;
TStdPartnerStatusCode PartnerStatusCode;
if (AFormDataPerson == null)
{
return;
}
if (MCommonMain.RetrievePartnerShortName(APartnerKey, out ShortName, out PartnerClass, out PartnerStatusCode, AReadTransaction))
{
// first retrieve all partner information
// we cannot reference MPartner connect because of SimplePartnerEdit, cyclic dependencies
#if DISABLED_TP_20180623
TFormLettersWebConnector.FillFormDataFromPerson(APartnerKey,
AFormDataPerson,
AFormLetterInfo,
AReadTransaction,
ASiteKey,
ALocationKey);
#endif
// retrieve Special Needs information
if (AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.eSpecialNeeds))
{
PmSpecialNeedTable SpecialNeedTable;
PmSpecialNeedRow SpecialNeedRow;
SpecialNeedTable = PmSpecialNeedAccess.LoadViaPPerson(APartnerKey, AReadTransaction);
if (SpecialNeedTable.Count > 0)
{
SpecialNeedRow = (PmSpecialNeedRow)SpecialNeedTable.Rows[0];
AFormDataPerson.DietaryNeeds = SpecialNeedRow.DietaryComment;
AFormDataPerson.MedicalNeeds = SpecialNeedRow.MedicalComment;
AFormDataPerson.OtherNeeds = SpecialNeedRow.OtherSpecialNeed;
AFormDataPerson.Vegetarian = SpecialNeedRow.VegetarianFlag;
}
}
// retrieve Personal Data information
if (AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.ePersonalData))
{
PmPersonalDataTable PersonalDataTable;
PmPersonalDataRow PersonalDataRow;
PersonalDataTable = PmPersonalDataAccess.LoadViaPPerson(APartnerKey, AReadTransaction);
if (PersonalDataTable.Count > 0)
{
PersonalDataRow = (PmPersonalDataRow)PersonalDataTable.Rows[0];
if (!PersonalDataRow.IsBelieverSinceYearNull() &&
(PersonalDataRow.BelieverSinceYear != 0))
{
AFormDataPerson.YearsBeliever = (DateTime.Today.Year - PersonalDataRow.BelieverSinceYear).ToString();
}
AFormDataPerson.CommentBeliever = PersonalDataRow.BelieverSinceComment;
}
}
// retrieve Passport information
if (AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.ePassport))
{
PmPassportDetailsTable PassportTable;
TFormDataPassport PassportRecord;
PassportTable = PmPassportDetailsAccess.LoadViaPPerson(APartnerKey, AReadTransaction);
Boolean MainPassportFound = false;
foreach (PmPassportDetailsRow PassportRow in PassportTable.Rows)
{
// only list "full" passports that have not expired yet
if ((PassportRow.IsDateOfExpirationNull() ||
(PassportRow.DateOfExpiration >= DateTime.Today)) &&
(PassportRow.PassportDetailsType == "P"))
{
PassportRecord = new TFormDataPassport();
PassportRecord.IsMainPassport = PassportRow.MainPassport;
PassportRecord.Number = PassportRow.PassportNumber;
PassportRecord.PassportName = PassportRow.FullPassportName;
PassportRecord.NationalityCode = PassportRow.PassportNationalityCode;
// retrieve country name from country table
TCacheable CachePopulator = new TCacheable();
PCountryTable CountryTable =
(PCountryTable)CachePopulator.GetCacheableTable(TCacheableCommonTablesEnum.CountryList);
PCountryRow CountryRow =
(PCountryRow)CountryTable.Rows.Find(new object[] { PassportRow.PassportNationalityCode });
if (CountryRow != null)
{
PassportRecord.NationalityName = CountryRow.CountryName;
}
PassportRecord.TypeCode = PassportRow.PassportDetailsType;
// retrieve passport type name from type table
TPersonnelCacheable PersonnelCachePopulator = new TPersonnelCacheable();
PtPassportTypeTable TypeTable =
(PtPassportTypeTable)PersonnelCachePopulator.GetCacheableTable(TCacheablePersonTablesEnum.
PassportTypeList);
PtPassportTypeRow TypeRow =
(PtPassportTypeRow)TypeTable.Rows.Find(new object[] { PassportRow.PassportDetailsType });
if (TypeRow != null)
{
PassportRecord.TypeDescription = TypeRow.Description;
}
PassportRecord.DateOfIssue = PassportRow.DateOfIssue;
PassportRecord.PlaceOfIssue = PassportRow.PlaceOfIssue;
PassportRecord.DateOfExpiry = PassportRow.DateOfExpiration;
PassportRecord.PlaceOfBirth = PassportRow.PlaceOfBirth;
// set number and nationality in main record (only for main passport or if there is just one)
if (PassportRow.MainPassport || (PassportTable.Count == 1))
{
AFormDataPerson.PassportNumber = PassportRecord.Number;
AFormDataPerson.PassportNationality = PassportRecord.NationalityName;
AFormDataPerson.PassportNationalityCode = PassportRecord.NationalityCode;
AFormDataPerson.PassportName = PassportRecord.PassportName;
AFormDataPerson.PassportDateOfIssue = PassportRecord.DateOfIssue;
AFormDataPerson.PassportPlaceOfIssue = PassportRecord.PlaceOfIssue;
AFormDataPerson.PassportDateOfExpiry = PassportRecord.DateOfExpiry;
AFormDataPerson.PassportPlaceOfBirth = PassportRecord.PlaceOfBirth;
MainPassportFound = true;
}
// If the PassportName has not been set yet then make sure it is set on Person level from at least one passport
// (this will not be necessary any longer once the tick box for "Main Passport" is implemented)
if (!MainPassportFound)
{
AFormDataPerson.PassportName = PassportRecord.PassportName;
}
AFormDataPerson.AddPassport(PassportRecord);
}
}
}
// retrieve Language information
if (AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.eLanguage))
{
PmPersonLanguageTable PersonLanguageTable;
TFormDataLanguage PersonLanguageRecord;
PersonLanguageTable = PmPersonLanguageAccess.LoadViaPPerson(APartnerKey, AReadTransaction);
foreach (PmPersonLanguageRow PersonLanguageRow in PersonLanguageTable.Rows)
{
PersonLanguageRecord = new TFormDataLanguage();
PersonLanguageRecord.Code = PersonLanguageRow.LanguageCode;
// retrieve language name from language table
TCacheable CachePopulator = new TCacheable();
PLanguageTable LanguageTable =
(PLanguageTable)CachePopulator.GetCacheableTable(TCacheableCommonTablesEnum.LanguageCodeList);
PLanguageRow LanguageRow = (PLanguageRow)LanguageTable.Rows.Find(new object[] { PersonLanguageRow.LanguageCode });
if (LanguageRow != null)
{
PersonLanguageRecord.Name = LanguageRow.LanguageDescription;
}
PersonLanguageRecord.Level = PersonLanguageRow.LanguageLevel.ToString();
// retrieve language level name from language level table
TPersonnelCacheable CachePopulatorPersonnel = new TPersonnelCacheable();
PtLanguageLevelTable LanguageLevelTable =
(PtLanguageLevelTable)CachePopulatorPersonnel.GetCacheableTable(TCacheablePersonTablesEnum.LanguageLevelList);
PtLanguageLevelRow LanguageLevelRow =
(PtLanguageLevelRow)LanguageLevelTable.Rows.Find(new object[] { PersonLanguageRow.LanguageLevel });
if (LanguageLevelRow != null)
{
PersonLanguageRecord.LevelDesc = LanguageLevelRow.LanguageLevelDescr;
}
PersonLanguageRecord.Comment = PersonLanguageRow.Comment;
AFormDataPerson.AddLanguage(PersonLanguageRecord);
}
}
// retrieve Skill information
if (AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.eSkill))
{
PmPersonSkillTable PersonSkillTable;
TFormDataSkill PersonSkillRecord;
TFormDataDegree PersonDegreeRecord;
PersonSkillTable = PmPersonSkillAccess.LoadViaPPerson(APartnerKey, AReadTransaction);
foreach (PmPersonSkillRow PersonSkillRow in PersonSkillTable.Rows)
{
PersonSkillRecord = new TFormDataSkill();
PersonSkillRecord.Category = PersonSkillRow.SkillCategoryCode;
PersonSkillRecord.Description = PersonSkillRow.DescriptionEnglish;
// if no description in local language then use english
PersonSkillRecord.DescriptionLocalOrDefault = PersonSkillRow.DescriptionLocal;
if (PersonSkillRow.DescriptionLocal != "")
{
PersonSkillRecord.DescriptionLocalOrDefault = PersonSkillRow.DescriptionEnglish;
}
PersonSkillRecord.Level = PersonSkillRow.SkillLevel;
// retrieve skill level name from skill level table
TPersonnelCacheable CachePopulatorPersonnel = new TPersonnelCacheable();
PtSkillLevelTable SkillLevelTable =
(PtSkillLevelTable)CachePopulatorPersonnel.GetCacheableTable(TCacheablePersonTablesEnum.SkillLevelList);
PtSkillLevelRow SkillLevelRow =
(PtSkillLevelRow)SkillLevelTable.Rows.Find(new object[] { PersonSkillRow.SkillLevel });
if (SkillLevelRow != null)
{
PersonSkillRecord.LevelDesc = SkillLevelRow.Description;
}
PersonSkillRecord.YearsExp = PersonSkillRow.YearsOfExperience;
PersonSkillRecord.Professional = PersonSkillRow.ProfessionalSkill;
PersonSkillRecord.Degree = PersonSkillRow.Degree;
PersonSkillRecord.Comment = PersonSkillRow.Comment;
AFormDataPerson.AddSkill(PersonSkillRecord);
// now add a degree record if a degree is mentioned
if (!PersonSkillRow.IsDegreeNull() &&
(PersonSkillRow.Degree.Length > 0))
{
PersonDegreeRecord = new TFormDataDegree();
PersonDegreeRecord.Name = PersonSkillRow.Degree;
PersonDegreeRecord.Year = PersonSkillRow.YearOfDegree.ToString();
AFormDataPerson.AddDegree(PersonDegreeRecord);
}
}
}
// retrieve past work experience information
if (AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.eWorkExperience))
{
TFormDataWorkExperience PersonExpRecord;
/*
* currently we don't include application records in the work experience data
*
* String UnitShortName;
* TPartnerClass UnitClass;
*
* // retrieve applications for short term events
* String SqlStmt = TDataBase.ReadSqlFile("Personnel.FormLetters.GetAppTravelDates.sql");
*
* OdbcParameter[] parameters = new OdbcParameter[1];
* parameters[0] = new OdbcParameter("PartnerKey", OdbcType.BigInt);
* parameters[0].Value = APartnerKey;
*
* DataTable travelData = DBAccess.GDBAccessObj.SelectDT(SqlStmt, "TravelDates", ReadTransaction, parameters);
*
* for (int i = 0; i < travelData.Rows.Count; i++)
* {
* PersonExpRecord = new TFormDataWorkExperience();
*
* if ((travelData.Rows[i][0]).GetType() == typeof(DateTime))
* {
* PersonExpRecord.StartDate = (DateTime?)travelData.Rows[i][0];
* }
*
* if ((travelData.Rows[i][1]).GetType() == typeof(DateTime))
* {
* PersonExpRecord.EndDate = (DateTime?)travelData.Rows[i][1];
* }
*
* PersonExpRecord.Organisation = "";
* PersonExpRecord.Role = "";
* PersonExpRecord.Category = "";
* PersonExpRecord.SameOrg = true;
* PersonExpRecord.SimilarOrg = true;
* PersonExpRecord.Comment = "";
*
* // check if unit exists and use unit name as location
* if (TPartnerServerLookups.GetPartnerShortName((Int64)travelData.Rows[i][2], out UnitShortName, out UnitClass))
* {
* PersonExpRecord.Location = UnitShortName;
* }
* else
* {
* PersonExpRecord.Location = travelData.Rows[i][3].ToString();
* }
*
* AFormDataPerson.AddWorkExperience(PersonExpRecord);
* }
*/
// retrieve actual past experience records
PmPastExperienceTable PersonExpTable;
PersonExpTable = PmPastExperienceAccess.LoadViaPPerson(APartnerKey, AReadTransaction);
PUnitTable UnitTable;
PUnitRow UnitRow;
foreach (PmPastExperienceRow PersonExpRow in PersonExpTable.Rows)
{
PersonExpRecord = new TFormDataWorkExperience();
PersonExpRecord.StartDate = PersonExpRow.StartDate;
PersonExpRecord.EndDate = PersonExpRow.EndDate;
PersonExpRecord.Location = PersonExpRow.PrevLocation;
PersonExpRecord.Organisation = PersonExpRow.OtherOrganisation;
PersonExpRecord.Role = PersonExpRow.PrevRole;
PersonExpRecord.Category = PersonExpRow.Category;
PersonExpRecord.SameOrg = PersonExpRow.PrevWorkHere;
PersonExpRecord.SimilarOrg = PersonExpRow.PrevWork;
PersonExpRecord.Comment = PersonExpRow.PastExpComments;
// check if previous experience came from an event with location set to event code
// -> in this case don't set event code as location but rather the event name
PUnitRow template = new PUnitTable().NewRowTyped(false);
template.OutreachCode = PersonExpRow.PrevLocation;
UnitTable = PUnitAccess.LoadUsingTemplate(template, AReadTransaction);
if (UnitTable.Rows.Count > 0)
{
UnitRow = (PUnitRow)UnitTable.Rows[0];
PersonExpRecord.Location = UnitRow.UnitName;
}
AFormDataPerson.AddWorkExperience(PersonExpRecord);
}
}
// retrieve Commitment information
if (AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.eCommitment) ||
AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.eFutureCommitment))
{
String FieldName;
TPartnerClass FieldPartnerClass;
PmStaffDataTable PersonCommitmentTable;
PmStaffDataRow PersonCommitmentRow;
TFormDataCommitment PersonCommitmentRecord;
PersonCommitmentTable = PmStaffDataAccess.LoadViaPPerson(APartnerKey, AReadTransaction);
PersonCommitmentTable.DefaultView.Sort = PmStaffDataTable.GetStartOfCommitmentDBName() + " DESC";
if (AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.eCommitment))
{
foreach (DataRowView rv in PersonCommitmentTable.DefaultView)
{
PersonCommitmentRow = (PmStaffDataRow)rv.Row;
PersonCommitmentRecord = new TFormDataCommitment();
PersonCommitmentRecord.StartDate = PersonCommitmentRow.StartOfCommitment;
PersonCommitmentRecord.EndDate = PersonCommitmentRow.EndOfCommitment;
PersonCommitmentRecord.Status = PersonCommitmentRow.StatusCode;
PersonCommitmentRecord.ReceivingFieldKey = PersonCommitmentRow.ReceivingField.ToString("0000000000");
TPartnerServerLookups.GetPartnerShortName(PersonCommitmentRow.ReceivingField, out FieldName,
out FieldPartnerClass);
PersonCommitmentRecord.ReceivingFieldName = FieldName;
PersonCommitmentRecord.SendingFieldKey = PersonCommitmentRow.HomeOffice.ToString("0000000000");
TPartnerServerLookups.GetPartnerShortName(PersonCommitmentRow.HomeOffice, out FieldName,
out FieldPartnerClass);
PersonCommitmentRecord.SendingFieldName = FieldName;
PersonCommitmentRecord.RecruitingFieldKey = PersonCommitmentRow.OfficeRecruitedBy.ToString("0000000000");
TPartnerServerLookups.GetPartnerShortName(PersonCommitmentRow.OfficeRecruitedBy, out FieldName,
out FieldPartnerClass);
PersonCommitmentRecord.RecruitingFieldName = FieldName;
PersonCommitmentRecord.Comment = PersonCommitmentRow.StaffDataComments;
AFormDataPerson.AddCommitment(PersonCommitmentRecord);
}
}
if (AFormLetterInfo.IsRetrievalRequested(TFormDataRetrievalSection.eFutureCommitment))
{
foreach (DataRowView rv in PersonCommitmentTable.DefaultView)
{
PersonCommitmentRow = (PmStaffDataRow)rv.Row;
if (PersonCommitmentRow.StartOfCommitment >= DateTime.Today)
{
TPartnerServerLookups.GetPartnerShortName(PersonCommitmentRow.ReceivingField, out FieldName,
out FieldPartnerClass);
AFormDataPerson.FutureFieldName = FieldName;
AFormDataPerson.FutureCommitStartDate = PersonCommitmentRow.StartOfCommitment;
AFormDataPerson.FutureCommitEndDate = PersonCommitmentRow.EndOfCommitment;
// only use the first commitment (list is sorted by start date)
break;
}
}
}
}
}
}
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 SelectConferenceTDS GetConferences(String AConferenceName, String APrefix)
{
SelectConferenceTDS ResultTable = new SelectConferenceTDS();
PcConferenceTable ConferenceTable = new PcConferenceTable();
PcConferenceRow TemplateRow = (PcConferenceRow)ConferenceTable.NewRow();
TDBTransaction ReadTransaction;
Boolean NewTransaction = false;
if (APrefix == "*")
{
APrefix = "";
}
if (AConferenceName == "*")
{
AConferenceName = "";
}
else if (AConferenceName.EndsWith("*"))
{
AConferenceName = AConferenceName.Substring(0, AConferenceName.Length - 1);
}
TLogging.LogAtLevel(9, "TConferenceOptions.GetConferences called!");
TDataBase db = DBAccess.Connect("GetConferences");
ReadTransaction = db.GetNewOrExistingTransaction(IsolationLevel.RepeatableRead,
out NewTransaction);
try
{
/* Load data */
if (APrefix.Length > 0)
{
APrefix = APrefix.Replace('*', '%') + "%";
TemplateRow.OutreachPrefix = APrefix;
StringCollection Operators = new StringCollection();
Operators.Add("LIKE");
ConferenceTable = PcConferenceAccess.LoadUsingTemplate(TemplateRow, Operators, null, ReadTransaction);
}
else
{
ConferenceTable = PcConferenceAccess.LoadAll(ReadTransaction);
}
}
finally
{
if (NewTransaction)
{
ReadTransaction.Commit();
TLogging.LogAtLevel(7, "TConferenceOptions.GetConferences: committed own transaction.");
}
}
String ShortName;
TPartnerClass PartnerClass;
foreach (PcConferenceRow ConferenceRow in ConferenceTable.Rows)
{
TPartnerServerLookups.GetPartnerShortName(ConferenceRow.ConferenceKey, out ShortName, out PartnerClass);
if ((AConferenceName.Length > 0) &&
(!ShortName.StartsWith(AConferenceName, true, null)))
{
continue;
}
ResultTable.PcConference.ImportRow(ConferenceRow);
DataRow NewRow = ResultTable.PPartner.NewRow();
NewRow[PPartnerTable.GetPartnerShortNameDBName()] = ShortName;
NewRow[PPartnerTable.GetPartnerKeyDBName()] = ConferenceRow.ConferenceKey;
ResultTable.PPartner.Rows.Add(NewRow);
}
return(ResultTable);
}
public static string CreateAnnualGiftReceipts(Int32 ALedgerNumber,
DateTime AStartDate,
DateTime AEndDate,
string AHTMLTemplate,
bool ADeceasedFirst = false,
string AExtract = null,
Int64 ADonorKey = 0)
{
TLanguageCulture.LoadLanguageAndCulture();
// get BaseCurrency
System.Type typeofTable = null;
TCacheable CachePopulator = new TCacheable();
ALedgerTable LedgerTable = (ALedgerTable)CachePopulator.GetCacheableTable(TCacheableFinanceTablesEnum.LedgerDetails,
"",
false,
ALedgerNumber,
out typeofTable);
string BaseCurrency = LedgerTable[0].BaseCurrency;
TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted);
try
{
// get the local country code
string LocalCountryCode = TAddressTools.GetCountryCodeFromSiteLedger(Transaction);
DataTable donorkeys = new DataTable();
string SqlStmt = "";
if (ADonorKey != 0)
{
TPartnerClass Class;
string ShortName;
TPartnerServerLookups.GetPartnerShortName(ADonorKey, out ShortName, out Class);
donorkeys.Columns.Add(new DataColumn("DonorKey"));
donorkeys.Columns.Add(new DataColumn("DonorName"));
DataRow SingleRow = donorkeys.NewRow();
SingleRow[0] = ADonorKey;
SingleRow[1] = ShortName;
donorkeys.Rows.Add(SingleRow);
}
else
{
SortedList <string, string> Defines = new SortedList <string, string>();
if (!string.IsNullOrEmpty(AExtract))
{
Defines.Add("BYEXTRACT", string.Empty);
}
// first get all donors in the given date range
SqlStmt = TDataBase.ReadSqlFile("Gift.ReceiptPrinting.GetDonors.sql", Defines);
OdbcParameter[] parameters = new OdbcParameter[4];
parameters[0] = new OdbcParameter("LedgerNumber", OdbcType.Int);
parameters[0].Value = ALedgerNumber;
parameters[1] = new OdbcParameter("StartDate", OdbcType.Date);
parameters[1].Value = AStartDate;
parameters[2] = new OdbcParameter("EndDate", OdbcType.Date);
parameters[2].Value = AEndDate;
parameters[3] = new OdbcParameter("Extract", OdbcType.VarChar);
parameters[3].Value = AExtract;
donorkeys = DBAccess.GDBAccessObj.SelectDT(SqlStmt, "DonorKeys", Transaction, parameters);
// put deceased partner's at the front (still sorted alphabetically)
if (ADeceasedFirst)
{
// create a new datatable with same structure as donorkeys
DataTable temp = donorkeys.Clone();
temp.Clear();
// add deceased donors to the temp table and delete from donorkeys
for (int i = 0; i < donorkeys.Rows.Count; i++)
{
if (SharedTypes.StdPartnerStatusCodeStringToEnum(donorkeys.Rows[i][2].ToString()) == TStdPartnerStatusCode.spscDIED)
{
temp.Rows.Add((object[])donorkeys.Rows[i].ItemArray.Clone());
donorkeys.Rows[i].Delete();
}
}
// add remaining partners to temp table
donorkeys.AcceptChanges();
temp.Merge(donorkeys);
donorkeys = temp;
}
}
string ResultDocument = "";
SqlStmt = TDataBase.ReadSqlFile("Gift.ReceiptPrinting.GetDonationsOfDonor.sql");
foreach (DataRow donorrow in donorkeys.Rows)
{
Int64 donorKey = Convert.ToInt64(donorrow[0]);
string donorName = donorrow[1].ToString();
OdbcParameter[] parameters = new OdbcParameter[4];
parameters[0] = new OdbcParameter("LedgerNumber", OdbcType.Int);
parameters[0].Value = ALedgerNumber;
parameters[1] = new OdbcParameter("StartDate", OdbcType.Date);
parameters[1].Value = AStartDate;
parameters[2] = new OdbcParameter("EndDate", OdbcType.Date);
parameters[2].Value = AEndDate;
parameters[3] = new OdbcParameter("DonorKey", OdbcType.BigInt);
parameters[3].Value = donorKey;
// TODO: should we print each gift detail, or just one row per gift?
DataTable donations = DBAccess.GDBAccessObj.SelectDT(SqlStmt, "Donations", Transaction, parameters);
if (donations.Rows.Count > 0)
{
string letter = FormatLetter(donorKey, donorName, donations, BaseCurrency, AHTMLTemplate, LocalCountryCode, Transaction);
if (TFormLettersTools.AttachNextPage(ref ResultDocument, letter))
{
// TODO: store somewhere that the receipt has been printed?
// TODO also store each receipt with the donor in document management, and in contact management?
}
}
}
TFormLettersTools.CloseDocument(ref ResultDocument);
return(ResultDocument);
}
finally
{
DBAccess.GDBAccessObj.RollbackTransaction();
}
}
