private void NewRecord(Object sender, EventArgs e)
{
// We need to check that we do have a language that we do not yet have a calendar definition for
Type DataTableType;
// Load Data
PLanguageTable allLanguages = new PLanguageTable();
DataTable CacheDT = TDataCache.GetCacheableDataTableFromCache("LanguageCodeList", String.Empty, null, out DataTableType);
allLanguages.Merge(CacheDT);
Int32 languageCount = allLanguages.Rows.Count - 1; // exclude the '99' row
languageCount = 3;
if (grdDetails.Rows.Count <= languageCount)
{
CreateNewSLanguageSpecific();
}
else
{
MessageBox.Show(Catalog.GetString("You already have a row for every specified language in the database."),
Catalog.GetString("Add new Month Names"));
}
}
private void NewRowManual(ref SLanguageSpecificRow ARow)
{
// Deal with primary key. LanguageCode is unique and is 10 characters.
// We use the first unused language code from our language code list
Type DataTableType;
// Load Data
PLanguageTable allLanguages = new PLanguageTable();
DataTable CacheDT = TDataCache.GetCacheableDataTableFromCache("LanguageCodeList", String.Empty, null, out DataTableType);
allLanguages.Merge(CacheDT);
// Because of the checking code in NewRecord, we know there is at least one spare language we can use
int rowIndex = 1; // first row is invalid 99 code
while (FMainDS.SLanguageSpecific.Rows.Find(new object[] { allLanguages.Rows[rowIndex][0].ToString() }) != null)
{
rowIndex++;
}
ARow.LanguageCode = allLanguages.Rows[rowIndex][0].ToString();
ARow.MonthName1 = Catalog.GetString("January");
ARow.MonthName2 = Catalog.GetString("February");
ARow.MonthName3 = Catalog.GetString("March");
ARow.MonthName4 = Catalog.GetString("April");
ARow.MonthName5 = Catalog.GetString("May");
ARow.MonthName6 = Catalog.GetString("June");
ARow.MonthName7 = Catalog.GetString("July");
ARow.MonthName8 = Catalog.GetString("August");
ARow.MonthName9 = Catalog.GetString("September");
ARow.MonthName10 = Catalog.GetString("October");
ARow.MonthName11 = Catalog.GetString("November");
ARow.MonthName12 = Catalog.GetString("December");
ARow.MonthNameShort1 = Catalog.GetString("Jan");
ARow.MonthNameShort2 = Catalog.GetString("Feb");
ARow.MonthNameShort3 = Catalog.GetString("Mar");
ARow.MonthNameShort4 = Catalog.GetString("Apr");
ARow.MonthNameShort5 = Catalog.GetString("May");
ARow.MonthNameShort6 = Catalog.GetString("Jun");
ARow.MonthNameShort7 = Catalog.GetString("Jul");
ARow.MonthNameShort8 = Catalog.GetString("Aug");
ARow.MonthNameShort9 = Catalog.GetString("Sep");
ARow.MonthNameShort10 = Catalog.GetString("Oct");
ARow.MonthNameShort11 = Catalog.GetString("Nov");
ARow.MonthNameShort12 = Catalog.GetString("Dec");
}
private void NewRowManual(ref SLanguageSpecificRow ARow)
{
// Deal with primary key. LanguageCode is unique and is 10 characters.
// We use the first unused language code from our language code list
Type DataTableType;
// Load Data
PLanguageTable allLanguages = new PLanguageTable();
DataTable CacheDT = TDataCache.GetCacheableDataTableFromCache("LanguageCodeList", String.Empty, null, out DataTableType);
allLanguages.Merge(CacheDT);
// Because of the checking code in NewRecord, we know there is at least one spare language we can use
int rowIndex = 1; // first row is invalid 99 code
while (FMainDS.SLanguageSpecific.Rows.Find(new object[] { allLanguages.Rows[rowIndex][0].ToString() }) != null)
{
rowIndex++;
}
ARow.LanguageCode = allLanguages.Rows[rowIndex][0].ToString();
ARow.MonthName1 = Catalog.GetString("January");
ARow.MonthName2 = Catalog.GetString("February");
ARow.MonthName3 = Catalog.GetString("March");
ARow.MonthName4 = Catalog.GetString("April");
ARow.MonthName5 = Catalog.GetString("May");
ARow.MonthName6 = Catalog.GetString("June");
ARow.MonthName7 = Catalog.GetString("July");
ARow.MonthName8 = Catalog.GetString("August");
ARow.MonthName9 = Catalog.GetString("September");
ARow.MonthName10 = Catalog.GetString("October");
ARow.MonthName11 = Catalog.GetString("November");
ARow.MonthName12 = Catalog.GetString("December");
ARow.MonthNameShort1 = Catalog.GetString("Jan");
ARow.MonthNameShort2 = Catalog.GetString("Feb");
ARow.MonthNameShort3 = Catalog.GetString("Mar");
ARow.MonthNameShort4 = Catalog.GetString("Apr");
ARow.MonthNameShort5 = Catalog.GetString("May");
ARow.MonthNameShort6 = Catalog.GetString("Jun");
ARow.MonthNameShort7 = Catalog.GetString("Jul");
ARow.MonthNameShort8 = Catalog.GetString("Aug");
ARow.MonthNameShort9 = Catalog.GetString("Sep");
ARow.MonthNameShort10 = Catalog.GetString("Oct");
ARow.MonthNameShort11 = Catalog.GetString("Nov");
ARow.MonthNameShort12 = Catalog.GetString("Dec");
}
/// <summary>
/// todoComment
/// </summary>
public void SpecialInitUserControl(IndividualDataTDS AMainDS)
{
FMainDS = AMainDS;
LoadDataOnDemand();
grdDetails.Columns.Clear();
grdDetails.AddTextColumn("Language", FMainDS.PmPersonLanguage.ColumnLanguageDescription);
grdDetails.AddTextColumn("Language Level", FMainDS.PmPersonLanguage.ColumnLanguageLevel);
grdDetails.AddTextColumn("Years Of Experience", FMainDS.PmPersonLanguage.ColumnYearsOfExperience);
grdDetails.AddDateColumn("as of", FMainDS.PmPersonLanguage.ColumnYearsOfExperienceAsOf);
FLanguageCodeDT = (PLanguageTable)TDataCache.TMCommon.GetCacheableCommonTable(TCacheableCommonTablesEnum.LanguageCodeList);
// make sure action can be taken when data is saved successfully
FPetraUtilsObject.DataSaved += new TDataSavedHandler(FPetraUtilsObject_DataSaved);
}
/// <summary>
/// todoComment
/// </summary>
public void SpecialInitUserControl(IndividualDataTDS AMainDS)
{
FMainDS = AMainDS;
LoadDataOnDemand();
grdDetails.Columns.Clear();
grdDetails.AddTextColumn("Language", FMainDS.PmPersonLanguage.ColumnLanguageDescription);
grdDetails.AddTextColumn("Language Level", FMainDS.PmPersonLanguage.ColumnLanguageLevel);
//grdDetails.AddTextColumn("Years Of Experience", FMainDS.PmPersonLanguage.ColumnYearsOfExperience);
//grdDetails.AddDateColumn("as of", FMainDS.PmPersonLanguage.ColumnYearsOfExperienceAsOf);
FLanguageCodeDT = (PLanguageTable)TDataCache.TMCommon.GetCacheableCommonTable(TCacheableCommonTablesEnum.LanguageCodeList);
// make sure action can be taken when data is saved successfully
FPetraUtilsObject.DataSaved += new TDataSavedHandler(FPetraUtilsObject_DataSaved);
this.SizeChanged += TUC_IndividualData_PersonalLanguages_SizeChanged;
// This can go here because InitUserControl does not mess with the columns
grdDetails.AutoResizeGrid();
}
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;
}
}
}
}
}
}
/// <summary>
/// Passes data as a Typed DataSet to the caller, containing a DataTable that corresponds with <paramref name="AIndivDataItem"></paramref>.
/// </summary>
/// <param name="APartnerKey">PartnerKey of the Person to load data for.</param>
/// <param name="AIndivDataItem">The Individual Data Item for which data should be returned.</param>
/// <param name="AReadTransaction">Open Database transaction.</param>
/// <returns>A Typed DataSet containing a DataTable that corresponds with <paramref name="AIndivDataItem"></paramref>.</returns>
private static IndividualDataTDS GetData(Int64 APartnerKey, TIndividualDataItemEnum AIndivDataItem, TDBTransaction AReadTransaction)
{
IndividualDataTDS IndividualDataDS = new IndividualDataTDS("IndividualData"); // create the IndividualDataTDS DataSet that will later be passed to the Client
IndividualDataTDSMiscellaneousDataTable MiscellaneousDataDT;
IndividualDataTDSMiscellaneousDataRow MiscellaneousDataDR;
#region Create 'Miscellaneous' DataRow
MiscellaneousDataDT = IndividualDataDS.MiscellaneousData;
MiscellaneousDataDR = MiscellaneousDataDT.NewRowTyped(false);
MiscellaneousDataDR.PartnerKey = APartnerKey;
MiscellaneousDataDT.Rows.Add(MiscellaneousDataDR);
#endregion
switch (AIndivDataItem)
{
case TIndividualDataItemEnum.idiSummary:
BuildSummaryData(APartnerKey, ref IndividualDataDS, AReadTransaction);
DetermineItemCounts(MiscellaneousDataDR, AReadTransaction);
break;
case TIndividualDataItemEnum.idiPersonalLanguages:
PmPersonLanguageAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
PLanguageTable LanguageTable = (PLanguageTable)TSharedDataCache.TMCommon.GetCacheableCommonTable(
TCacheableCommonTablesEnum.LanguageCodeList);
PLanguageRow LanguageRow;
foreach (IndividualDataTDSPmPersonLanguageRow PersonLanguageRow in IndividualDataDS.PmPersonLanguage.Rows)
{
LanguageRow = (PLanguageRow)LanguageTable.Rows.Find(new object[] { PersonLanguageRow.LanguageCode });
if (LanguageRow != null)
{
PersonLanguageRow.LanguageDescription = LanguageRow.LanguageDescription;
}
}
break;
case TIndividualDataItemEnum.idiSpecialNeeds:
PmSpecialNeedAccess.LoadByPrimaryKey(IndividualDataDS, APartnerKey, AReadTransaction);
break;
case TIndividualDataItemEnum.idiPreviousExperiences:
PmPastExperienceAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
PUnitTable UnitTable;
PUnitRow UnitRow;
// For outreaches the event code is currently stored in the location field. Try to retrieve the correct
// outreach event and return it's actual name (as the event does not mean much to anybody).
foreach (IndividualDataTDSPmPastExperienceRow PastExpRow in IndividualDataDS.PmPastExperience.Rows)
{
PUnitRow template = new PUnitTable().NewRowTyped(false);
template.OutreachCode = PastExpRow.PrevLocation;
UnitTable = PUnitAccess.LoadUsingTemplate(template, AReadTransaction);
if (UnitTable.Rows.Count > 0)
{
UnitRow = (PUnitRow)UnitTable.Rows[0];
PastExpRow.EventName = UnitRow.UnitName;
}
}
break;
case TIndividualDataItemEnum.idiPersonalDocuments:
PmDocumentAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
break;
case TIndividualDataItemEnum.idiJobAssignments:
PmJobAssignmentAccess.LoadViaPPartner(IndividualDataDS, APartnerKey, AReadTransaction);
break;
case TIndividualDataItemEnum.idiLocalPersonnelData:
// TODO: Fix this so LocalPersonnelData can actually load some data
bool labelsAvailable;
TOfficeSpecificDataLabelsUIConnector OfficeSpecificDataLabelsUIConnector;
OfficeSpecificDataLabelsUIConnector = new TOfficeSpecificDataLabelsUIConnector(APartnerKey,
TOfficeSpecificDataLabelUseEnum.Personnel);
IndividualDataDS.Merge(OfficeSpecificDataLabelsUIConnector.GetDataLocalPartnerDataValues(APartnerKey, out labelsAvailable, false,
AReadTransaction));
break;
case TIndividualDataItemEnum.idiProgressReports:
PmPersonEvaluationAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
break;
case TIndividualDataItemEnum.idiCommitmentPeriods:
PmStaffDataAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
break;
case TIndividualDataItemEnum.idiPersonSkills:
PmPersonSkillAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
break;
case TIndividualDataItemEnum.idiPersonalAbilities:
PmPersonAbilityAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
break;
case TIndividualDataItemEnum.idiPassportDetails:
PmPassportDetailsAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
PCountryTable CountryTable = (PCountryTable)TSharedDataCache.TMCommon.GetCacheableCommonTable(
TCacheableCommonTablesEnum.CountryList);
PCountryRow CountryRow;
foreach (IndividualDataTDSPmPassportDetailsRow PassportRow in IndividualDataDS.PmPassportDetails.Rows)
{
CountryRow = (PCountryRow)CountryTable.Rows.Find(new object[] { PassportRow.PassportNationalityCode });
if (CountryRow != null)
{
PassportRow.PassportNationalityName = CountryRow.CountryName;
}
}
break;
case TIndividualDataItemEnum.idiPersonalData:
PmPersonalDataAccess.LoadByPrimaryKey(IndividualDataDS, APartnerKey, AReadTransaction);
break;
case TIndividualDataItemEnum.idiEmergencyData:
PmPersonalDataAccess.LoadByPrimaryKey(IndividualDataDS, APartnerKey, AReadTransaction);
break;
case TIndividualDataItemEnum.idiApplications:
PmGeneralApplicationAccess.LoadViaPPersonPartnerKey(IndividualDataDS, APartnerKey, AReadTransaction);
PmShortTermApplicationAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
PmYearProgramApplicationAccess.LoadViaPPerson(IndividualDataDS, APartnerKey, AReadTransaction);
IndividualDataTDSPmGeneralApplicationRow GenAppRow;
TPartnerClass PartnerClass;
TStdPartnerStatusCode PartnerStatus;
String EventOrFieldName;
//TODO: now go through all short and long term apps and set the
// two fields in general app for EventOrFieldName and ApplicationForEventOrField
foreach (PmShortTermApplicationRow ShortTermRow in IndividualDataDS.PmShortTermApplication.Rows)
{
GenAppRow = (IndividualDataTDSPmGeneralApplicationRow)IndividualDataDS.PmGeneralApplication.Rows.Find
(new object[] { ShortTermRow.PartnerKey,
ShortTermRow.ApplicationKey, ShortTermRow.RegistrationOffice });
GenAppRow.ApplicationForEventOrField = Catalog.GetString("Event");
if (!ShortTermRow.IsStConfirmedOptionNull())
{
Ict.Petra.Server.MCommon.MCommonMain.RetrievePartnerShortName
(ShortTermRow.StConfirmedOption, out EventOrFieldName, out PartnerClass, out PartnerStatus);
GenAppRow.EventOrFieldName = EventOrFieldName;
}
}
foreach (PmYearProgramApplicationRow LongTermRow in IndividualDataDS.PmYearProgramApplication.Rows)
{
GenAppRow = (IndividualDataTDSPmGeneralApplicationRow)IndividualDataDS.PmGeneralApplication.Rows.Find
(new object[] { LongTermRow.PartnerKey,
LongTermRow.ApplicationKey, LongTermRow.RegistrationOffice });
GenAppRow.ApplicationForEventOrField = Catalog.GetString("Field");
if (!GenAppRow.IsGenAppPossSrvUnitKeyNull())
{
Ict.Petra.Server.MCommon.MCommonMain.RetrievePartnerShortName
(GenAppRow.GenAppPossSrvUnitKey, out EventOrFieldName, out PartnerClass, out PartnerStatus);
GenAppRow.EventOrFieldName = EventOrFieldName;
}
}
break;
// TODO: work on all cases/load data for all Individual Data items
}
return(IndividualDataDS);
}
/// <summary>
/// todoComment
/// </summary>
public void SpecialInitUserControl(IndividualDataTDS AMainDS)
{
FMainDS = AMainDS;
LoadDataOnDemand();
grdDetails.Columns.Clear();
grdDetails.AddTextColumn("Language", FMainDS.PmPersonLanguage.ColumnLanguageDescription);
grdDetails.AddTextColumn("Language Level", FMainDS.PmPersonLanguage.ColumnLanguageLevel);
grdDetails.AddTextColumn("Years Of Experience", FMainDS.PmPersonLanguage.ColumnYearsOfExperience);
grdDetails.AddDateColumn("as of", FMainDS.PmPersonLanguage.ColumnYearsOfExperienceAsOf);
FLanguageCodeDT = (PLanguageTable)TDataCache.TMCommon.GetCacheableCommonTable(TCacheableCommonTablesEnum.LanguageCodeList);
// make sure action can be taken when data is saved successfully
FPetraUtilsObject.DataSaved += new TDataSavedHandler(FPetraUtilsObject_DataSaved);
}
private void NewRecord(Object sender, EventArgs e)
{
// We need to check that we do have a language that we do not yet have a calendar definition for
Type DataTableType;
// Load Data
PLanguageTable allLanguages = new PLanguageTable();
DataTable CacheDT = TDataCache.GetCacheableDataTableFromCache("LanguageCodeList", String.Empty, null, out DataTableType);
allLanguages.Merge(CacheDT);
Int32 languageCount = allLanguages.Rows.Count - 1; // exclude the '99' row
languageCount = 3;
if (grdDetails.Rows.Count <= languageCount)
{
CreateNewSLanguageSpecific();
}
else
{
MessageBox.Show(Catalog.GetString("You already have a row for every specified language in the database."),
Catalog.GetString("Add new Month Names"));
}
}
