private void mitImportExcel_Click(object sender, RoutedEventArgs e)
{
Excel.Application xlDropOrder;
Excel.Workbook xlDropBook;
Excel.Worksheet xlDropSheet;
Excel.Range range;
int intColumnRange = 0;
int intCounter;
int intNumberOfRecords;
int intPayID = 0;
decimal decHours = 0;
string strValueForValidation;
string strEmployeeName;
bool blnNextRecord;
bool blnFatalError;
try
{
TheImportHoursDataSet.employees.Rows.Clear();
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
dlg.FileName = "Document"; // Default file name
dlg.DefaultExt = ".xlsx"; // Default file extension
dlg.Filter = "Excel (.xlsx)|*.xlsx"; // Filter files by extension
// Show open file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process open file dialog box results
if (result == true)
{
// Open document
string filename = dlg.FileName;
}
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
xlDropOrder = new Excel.Application();
xlDropBook = xlDropOrder.Workbooks.Open(dlg.FileName, 0, true, 5, "", "", true, Microsoft.Office.Interop.Excel.XlPlatform.xlWindows, "\t", false, false, 0, true, 1, 0);
xlDropSheet = (Excel.Worksheet)xlDropOrder.Worksheets.get_Item(1);
range = xlDropSheet.UsedRange;
intNumberOfRecords = range.Rows.Count;
intColumnRange = range.Columns.Count;
for (intCounter = 2; intCounter <= intNumberOfRecords; intCounter++)
{
blnNextRecord = true;
strEmployeeName = Convert.ToString((range.Cells[intCounter, 1] as Excel.Range).Value2);
if (strEmployeeName == "")
{
blnNextRecord = false;
}
strValueForValidation = Convert.ToString((range.Cells[intCounter, 2] as Excel.Range).Value2);
blnFatalError = TheDataValidationClass.VerifyIntegerData(strValueForValidation);
if (blnFatalError == true)
{
blnNextRecord = false;
}
else
{
intPayID = Convert.ToInt32(strValueForValidation);
}
strValueForValidation = Convert.ToString((range.Cells[intCounter, 3] as Excel.Range).Value2);
blnFatalError = TheDataValidationClass.VerifyDoubleData(strValueForValidation);
if (blnFatalError == true)
{
blnNextRecord = false;
}
else
{
decHours = Convert.ToDecimal(strValueForValidation);
}
if (blnNextRecord == true)
{
TheFindEmployeeByPayIDDataSet = TheEmployeeClass.FindEmployeeByPayID(intPayID);
ImportHoursDataSet.employeesRow NewEmployeeRow = TheImportHoursDataSet.employees.NewemployeesRow();
NewEmployeeRow.EmployeeID = TheFindEmployeeByPayIDDataSet.FindEmployeeByPayID[0].EmployeeID;
NewEmployeeRow.FirstName = TheFindEmployeeByPayIDDataSet.FindEmployeeByPayID[0].FirstName;
NewEmployeeRow.LastName = TheFindEmployeeByPayIDDataSet.FindEmployeeByPayID[0].LastName;
NewEmployeeRow.PayID = intPayID;
NewEmployeeRow.Hours = decHours;
TheImportHoursDataSet.employees.Rows.Add(NewEmployeeRow);
}
}
PleaseWait.Close();
dgrResults.ItemsSource = TheImportHoursDataSet.employees;
blnFatalError = TheEmployeeDateEntryClass.InsertIntoEmployeeDateEntry(MainWindow.TheVerifyLogonDataSet.VerifyLogon[0].EmployeeID, "Blue Jay ERP // Import Employee Hours // Import Excel Menu Item ");
if (blnFatalError == true)
{
throw new Exception();
}
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Import Employee Hours // Import Excel Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
}
private void mitGenerateReport_Click(object sender, RoutedEventArgs e)
{
//setting local variables
string strProjectID;
int intRecordsReturned;
int intCounter;
int intNumberOfRecords;
DateTime datTransactionDate;
string strWorkTask;
int intSecondCounter;
int intSecondNumberOfRecords;
bool blnItemFound;
int intFootage;
int intSummaryCounter;
decimal decHours;
decimal decLaborCosts;
DateTime datStartDate = DateTime.Now;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
strProjectID = txtEnterProjectID.Text;
TheCompleteProjectInfoDataSet.projectinfo.Rows.Clear();
TheProjectWorkSummaryDataSet.worksummary.Rows.Clear();
gintSummaryCounter = 0;
gintSummaryUpperLimit = 0;
gdecTotalHours = 0;
gdecLaborCosts = 0;
TheFindProjectByAssignedProjectIDDataSet = TheProjectClass.FindProjectByAssignedProjectID(strProjectID);
intRecordsReturned = TheFindProjectByAssignedProjectIDDataSet.FindProjectByAssignedProjectID.Rows.Count;
if (intRecordsReturned == 0)
{
TheMessagesClass.ErrorMessage("Project Not Found");
return;
}
MainWindow.gintProjectID = TheFindProjectByAssignedProjectIDDataSet.FindProjectByAssignedProjectID[0].ProjectID;
datStartDate = TheDateSearchClass.SubtractingDays(datStartDate, 1500);
TheFindProjectHoursDataSet = TheEmployeeProjectAssignmentClass.FindProjectHours(MainWindow.gintProjectID, datStartDate);
intNumberOfRecords = TheFindProjectHoursDataSet.FindProjectHours.Rows.Count - 1;
intSecondNumberOfRecords = 0;
if (intNumberOfRecords > -1)
{
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
blnItemFound = false;
gdecTotalHours += TheFindProjectHoursDataSet.FindProjectHours[intCounter].TotalHours;
gdecLaborCosts += TheFindProjectHoursDataSet.FindProjectHours[intCounter].TotalEmployeeCost;
datTransactionDate = TheFindProjectHoursDataSet.FindProjectHours[intCounter].TransactionDate;
strWorkTask = TheFindProjectHoursDataSet.FindProjectHours[intCounter].WorkTask;
decHours = TheFindProjectHoursDataSet.FindProjectHours[intCounter].TotalHours;
decLaborCosts = TheFindProjectHoursDataSet.FindProjectHours[intCounter].TotalEmployeeCost;
if (intSecondNumberOfRecords > 0)
{
for (intSecondCounter = 0; intSecondCounter < intSecondNumberOfRecords; intSecondCounter++)
{
if (strWorkTask == TheCompleteProjectInfoDataSet.projectinfo[intSecondCounter].WorkTask)
{
if (datTransactionDate == TheCompleteProjectInfoDataSet.projectinfo[intSecondCounter].TransactionDate)
{
TheCompleteProjectInfoDataSet.projectinfo[intSecondCounter].Hours += decHours;
TheCompleteProjectInfoDataSet.projectinfo[intSecondCounter].LaborCosts += decLaborCosts;
blnItemFound = true;
}
}
}
}
if (blnItemFound == false)
{
CompleteProjectInfoDataSet.projectinfoRow NewTaskRow = TheCompleteProjectInfoDataSet.projectinfo.NewprojectinfoRow();
NewTaskRow.FootagePieces = 0;
NewTaskRow.TransactionDate = datTransactionDate;
NewTaskRow.WorkTask = strWorkTask;
NewTaskRow.Hours = decHours;
NewTaskRow.LaborCosts = decLaborCosts;
TheCompleteProjectInfoDataSet.projectinfo.Rows.Add(NewTaskRow);
intSecondNumberOfRecords++;
}
}
}
intNumberOfRecords = TheCompleteProjectInfoDataSet.projectinfo.Rows.Count - 1;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
intFootage = 0;
strWorkTask = TheCompleteProjectInfoDataSet.projectinfo[intCounter].WorkTask;
datTransactionDate = TheCompleteProjectInfoDataSet.projectinfo[intCounter].TransactionDate;
TheFindWorkTaskByWorkTaskDataSet = TheWorkTaskClass.FindWorkTaskByWorkTask(strWorkTask);
MainWindow.gintWorkTaskID = TheFindWorkTaskByWorkTaskDataSet.FindWorkTaskByWorkTask[0].WorkTaskID;
TheFindSpecificProjectWorkTaskDataSet = TheProjectTaskClass.FindSpecificProjectWorkTask(MainWindow.gintProjectID, MainWindow.gintWorkTaskID);
intSecondNumberOfRecords = TheFindSpecificProjectWorkTaskDataSet.FindSpecificProjectWorkTask.Rows.Count - 1;
for (intSecondCounter = 0; intSecondCounter <= intSecondNumberOfRecords; intSecondCounter++)
{
if (TheCompleteProjectInfoDataSet.projectinfo[intCounter].FootagePieces == 0)
{
if (datTransactionDate == TheFindSpecificProjectWorkTaskDataSet.FindSpecificProjectWorkTask[intSecondCounter].TransactionDate)
{
intFootage = Convert.ToInt32(TheFindSpecificProjectWorkTaskDataSet.FindSpecificProjectWorkTask[intSecondCounter].FootagePieces);
TheCompleteProjectInfoDataSet.projectinfo[intCounter].FootagePieces = intFootage;
}
}
}
}
intNumberOfRecords = TheCompleteProjectInfoDataSet.projectinfo.Rows.Count - 1;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
blnItemFound = false;
strWorkTask = TheCompleteProjectInfoDataSet.projectinfo[intCounter].WorkTask;
if (gintSummaryCounter > 0)
{
for (intSummaryCounter = 0; intSummaryCounter <= gintSummaryUpperLimit; intSummaryCounter++)
{
if (strWorkTask == TheProjectWorkSummaryDataSet.worksummary[intSummaryCounter].WorkTask)
{
TheProjectWorkSummaryDataSet.worksummary[intSummaryCounter].FootagePieces += TheCompleteProjectInfoDataSet.projectinfo[intCounter].FootagePieces;
TheProjectWorkSummaryDataSet.worksummary[intSummaryCounter].Hours += TheCompleteProjectInfoDataSet.projectinfo[intCounter].Hours;
blnItemFound = true;
}
}
}
if (blnItemFound == false)
{
ProjectWorkSummaryDataSet.worksummaryRow NewTaskRow = TheProjectWorkSummaryDataSet.worksummary.NewworksummaryRow();
NewTaskRow.FootagePieces = TheCompleteProjectInfoDataSet.projectinfo[intCounter].FootagePieces;
NewTaskRow.WorkTask = strWorkTask;
NewTaskRow.Hours = TheCompleteProjectInfoDataSet.projectinfo[intCounter].Hours;
NewTaskRow.LaborCosts = TheCompleteProjectInfoDataSet.projectinfo[intCounter].LaborCosts;
TheProjectWorkSummaryDataSet.worksummary.Rows.Add(NewTaskRow);
gintSummaryUpperLimit = gintSummaryCounter;
gintSummaryCounter++;
}
}
dgrResults.ItemsSource = TheProjectWorkSummaryDataSet.worksummary;
txtTotalHours.Text = Convert.ToString(gdecTotalHours);
txtLaborCosts.Text = Convert.ToString(gdecLaborCosts);
PleaseWait.Close();
}
catch (Exception Ex)
{
PleaseWait.Close();
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Find Project Hours // Generate Report Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
}
private void cboSelectCrew_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
int intSelectedIndex;
int intCounter;
int intNumberOfRecords;
int intEmployeeID;
int intProjectID;
if (gblnLoadComplete == true)
{
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
intSelectedIndex = cboSelectCrew.SelectedIndex;
gdecTotalHours = 0;
TheCrewHoursDataSet.crewhours.Rows.Clear();
if (gblnLoadComplete == true)
{
gstrCrewID = cboSelectCrew.SelectedItem.ToString();
TheFindEmployeeCrewByCrewIDDataSet = TheEmployeeCrewAssignmentClass.FindEmployeeCrewByCrewID(gstrCrewID, gdatStartDate, gdatEndDate);
intNumberOfRecords = TheFindEmployeeCrewByCrewIDDataSet.FindEmployeeCrewByCrewID.Rows.Count - 1;
if (intNumberOfRecords == -1)
{
TheMessagesClass.ErrorMessage("There is a Problem with Crew Assignments");
PleaseWait.Close();
return;
}
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
intEmployeeID = TheFindEmployeeCrewByCrewIDDataSet.FindEmployeeCrewByCrewID[intCounter].EmployeeID;
intProjectID = TheFindEmployeeCrewByCrewIDDataSet.FindEmployeeCrewByCrewID[intCounter].ProjectID;
TheFindEmployeeProjectHourDateRangeSummaryDataSet = TheEmployeeProductiivityStatsClass.FindEmployeeProjectHourDateRangeSummary(intEmployeeID, intProjectID, gdatStartDate, gdatEndDate);
CrewHoursDataSet.crewhoursRow NewHoursRow = TheCrewHoursDataSet.crewhours.NewcrewhoursRow();
NewHoursRow.AssignedProjectID = TheFindEmployeeProjectHourDateRangeSummaryDataSet.FindEmployeeProjectHourDateRangeSummary[0].AssignedProjectID;
NewHoursRow.FirstName = TheFindEmployeeProjectHourDateRangeSummaryDataSet.FindEmployeeProjectHourDateRangeSummary[0].FirstName;
NewHoursRow.LastName = TheFindEmployeeProjectHourDateRangeSummaryDataSet.FindEmployeeProjectHourDateRangeSummary[0].LastName;
NewHoursRow.ProjectName = TheFindEmployeeProjectHourDateRangeSummaryDataSet.FindEmployeeProjectHourDateRangeSummary[0].ProjectName;
NewHoursRow.Hours = TheFindEmployeeProjectHourDateRangeSummaryDataSet.FindEmployeeProjectHourDateRangeSummary[0].TotalHours;
gdecTotalHours += TheFindEmployeeProjectHourDateRangeSummaryDataSet.FindEmployeeProjectHourDateRangeSummary[0].TotalHours;
NewHoursRow.HomeOffice = TheFindEmployeeProjectHourDateRangeSummaryDataSet.FindEmployeeProjectHourDateRangeSummary[0].HomeOffice;
TheCrewHoursDataSet.crewhours.Rows.Add(NewHoursRow);
}
dgrResults.ItemsSource = TheCrewHoursDataSet.crewhours;
txtTotalHours.Text = Convert.ToString(gdecTotalHours);
}
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Find Employee Crew Assignments // Combo Box Change Event " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
PleaseWait.Close();
}
}
private void mitPrint_Click(object sender, RoutedEventArgs e)
{
int intCurrentRow = 0;
int intCounter;
int intColumns;
int intNumberOfRecords;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
PrintDialog pdCancelledReport = new PrintDialog();
if (pdCancelledReport.ShowDialog().Value)
{
FlowDocument fdCancelledLines = new FlowDocument();
Thickness thickness = new Thickness(100, 50, 50, 50);
fdCancelledLines.PagePadding = thickness;
//Set Up Table Columns
Table cancelledTable = new Table();
fdCancelledLines.Blocks.Add(cancelledTable);
cancelledTable.CellSpacing = 0;
intColumns = TheVehicleHistoryReportDataSet.historyreport.Columns.Count;
for (int intColumnCounter = 0; intColumnCounter < intColumns; intColumnCounter++)
{
cancelledTable.Columns.Add(new TableColumn());
}
cancelledTable.RowGroups.Add(new TableRowGroup());
//Title row
cancelledTable.RowGroups[0].Rows.Add(new TableRow());
TableRow newTableRow = cancelledTable.RowGroups[0].Rows[intCurrentRow];
newTableRow.Cells.Add(new TableCell(new Paragraph(new Run("Vehicle History Report"))));
newTableRow.Cells[0].FontSize = 20;
newTableRow.Cells[0].FontFamily = new FontFamily("Times New Roman");
newTableRow.Cells[0].ColumnSpan = intColumns;
newTableRow.Cells[0].TextAlignment = TextAlignment.Center;
newTableRow.Cells[0].Padding = new Thickness(0, 0, 0, 20);
//Header Row
cancelledTable.RowGroups[0].Rows.Add(new TableRow());
intCurrentRow++;
newTableRow = cancelledTable.RowGroups[0].Rows[intCurrentRow];
newTableRow.Cells.Add(new TableCell(new Paragraph(new Run("TransactionID"))));
newTableRow.Cells.Add(new TableCell(new Paragraph(new Run("BJC Number"))));
newTableRow.Cells.Add(new TableCell(new Paragraph(new Run("First Name"))));
newTableRow.Cells.Add(new TableCell(new Paragraph(new Run("Last Name"))));
newTableRow.Cells.Add(new TableCell(new Paragraph(new Run("Date"))));
//Format Header Row
for (intCounter = 0; intCounter < intColumns; intCounter++)
{
newTableRow.Cells[intCounter].FontSize = 11;
newTableRow.Cells[intCounter].FontFamily = new FontFamily("Times New Roman");
newTableRow.Cells[intCounter].BorderBrush = Brushes.Black;
newTableRow.Cells[intCounter].TextAlignment = TextAlignment.Center;
newTableRow.Cells[intCounter].BorderThickness = new Thickness();
}
intNumberOfRecords = TheVehicleHistoryReportDataSet.historyreport.Rows.Count;
//Data, Format Data
for (int intReportRowCounter = 0; intReportRowCounter < intNumberOfRecords; intReportRowCounter++)
{
cancelledTable.RowGroups[0].Rows.Add(new TableRow());
intCurrentRow++;
newTableRow = cancelledTable.RowGroups[0].Rows[intCurrentRow];
for (int intColumnCounter = 0; intColumnCounter < intColumns; intColumnCounter++)
{
newTableRow.Cells.Add(new TableCell(new Paragraph(new Run(TheVehicleHistoryReportDataSet.historyreport[intReportRowCounter][intColumnCounter].ToString()))));
newTableRow.Cells[intColumnCounter].FontSize = 12;
newTableRow.Cells[0].FontFamily = new FontFamily("Times New Roman");
newTableRow.Cells[intColumnCounter].BorderBrush = Brushes.LightSteelBlue;
newTableRow.Cells[intColumnCounter].BorderThickness = new Thickness(0, 0, 0, 1);
newTableRow.Cells[intColumnCounter].TextAlignment = TextAlignment.Center;
}
}
//Set up page and print
fdCancelledLines.ColumnWidth = pdCancelledReport.PrintableAreaWidth;
fdCancelledLines.PageHeight = pdCancelledReport.PrintableAreaHeight;
fdCancelledLines.PageWidth = pdCancelledReport.PrintableAreaWidth;
pdCancelledReport.PrintDocument(((IDocumentPaginatorSource)fdCancelledLines).DocumentPaginator, "Vehicle History Report");
intCurrentRow = 0;
}
}
catch (Exception Ex)
{
TheMessagesClass.ErrorMessage(Ex.ToString());
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Vehicle History Report // Print Menu Item " + Ex.Message);
}
PleaseWait.Close();
}
private void btnSearch_Click(object sender, RoutedEventArgs e)
{
//setting local variables
string strValueForValidation;
string strErrorMessage = "";
bool blnThereIsAProblem = false;
bool blnFatalError = false;
int intCounter;
int intNumberOfRecords;
string strVehicleNumber;
int intRecordsReturned;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
TheVehicleHistoryReportDataSet.historyreport.Rows.Clear();
strValueForValidation = txtStartDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The Starting Date is not a Date\n";
}
else
{
gdatStartDate = Convert.ToDateTime(strValueForValidation);
}
strValueForValidation = txtEndDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The Ending Date is not a Date\n";
}
else
{
gdatEndDate = Convert.ToDateTime(strValueForValidation);
}
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage(strErrorMessage);
return;
}
else
{
blnFatalError = TheDataValidationClass.verifyDateRange(gdatStartDate, gdatEndDate);
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage("The Starting Date is After the Ending Date");
return;
}
}
if (gstrReportType == "DATE RANGE")
{
TheFindVehicleHistoryByDateRangeDataSet = TheVehicleHistoryClass.FindVehicleHistoryByDateRange(gdatStartDate, gdatEndDate);
intNumberOfRecords = TheFindVehicleHistoryByDateRangeDataSet.FindVehicleHistoryByDateRange.Rows.Count - 1;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
VehicleHistoryReportDataSet.historyreportRow NewHistoryRow = TheVehicleHistoryReportDataSet.historyreport.NewhistoryreportRow();
NewHistoryRow.VehicleNumber = TheFindVehicleHistoryByDateRangeDataSet.FindVehicleHistoryByDateRange[intCounter].VehicleNumber;
NewHistoryRow.FirstName = TheFindVehicleHistoryByDateRangeDataSet.FindVehicleHistoryByDateRange[intCounter].FirstName;
NewHistoryRow.LastName = TheFindVehicleHistoryByDateRangeDataSet.FindVehicleHistoryByDateRange[intCounter].LastName;
NewHistoryRow.TransactionDate = TheFindVehicleHistoryByDateRangeDataSet.FindVehicleHistoryByDateRange[intCounter].TransactionDate;
TheVehicleHistoryReportDataSet.historyreport.Rows.Add(NewHistoryRow);
}
}
if (gstrReportType == "VEHICLE NUMBER")
{
strVehicleNumber = txtSearchInfo.Text;
if (strVehicleNumber == "")
{
TheMessagesClass.ErrorMessage("Vehicle Number Not Entered");
return;
}
else
{
TheFindActiveVehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);
intRecordsReturned = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;
if (intRecordsReturned == 0)
{
TheMessagesClass.ErrorMessage("Vehicle Not Found");
return;
}
else
{
gintVehicleID = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;
}
}
TheFindVehicleHistoryByVehicleIDAndDateRangeDataSet = TheVehicleHistoryClass.FindVehicleHistoryByVehicleIDAndDateRange(gintVehicleID, gdatStartDate, gdatEndDate);
intNumberOfRecords = TheFindVehicleHistoryByVehicleIDAndDateRangeDataSet.FindVehicleHistoryByVehicleIDAndDateRange.Rows.Count - 1;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
VehicleHistoryReportDataSet.historyreportRow NewHistoryRow = TheVehicleHistoryReportDataSet.historyreport.NewhistoryreportRow();
NewHistoryRow.VehicleNumber = TheFindVehicleHistoryByVehicleIDAndDateRangeDataSet.FindVehicleHistoryByVehicleIDAndDateRange[intCounter].VehicleNumber;
NewHistoryRow.FirstName = TheFindVehicleHistoryByVehicleIDAndDateRangeDataSet.FindVehicleHistoryByVehicleIDAndDateRange[intCounter].FirstName;
NewHistoryRow.LastName = TheFindVehicleHistoryByVehicleIDAndDateRangeDataSet.FindVehicleHistoryByVehicleIDAndDateRange[intCounter].LastName;
NewHistoryRow.TransactionDate = TheFindVehicleHistoryByVehicleIDAndDateRangeDataSet.FindVehicleHistoryByVehicleIDAndDateRange[intCounter].TransactionDate;
TheVehicleHistoryReportDataSet.historyreport.Rows.Add(NewHistoryRow);
}
}
if (gstrReportType == "EMPLOYEE")
{
TheFindVehicleHistoryByEmployeeIDAndDateRangeDataSet = TheVehicleHistoryClass.FindVehicleHistoryByEmployeeIDAndDateRange(gintEmployeeID, gdatStartDate, gdatEndDate);
intNumberOfRecords = TheFindVehicleHistoryByEmployeeIDAndDateRangeDataSet.FindVehicleHistoryByEmployeeIDAndDateRange.Rows.Count - 1;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
VehicleHistoryReportDataSet.historyreportRow NewHistoryRow = TheVehicleHistoryReportDataSet.historyreport.NewhistoryreportRow();
NewHistoryRow.VehicleNumber = TheFindVehicleHistoryByEmployeeIDAndDateRangeDataSet.FindVehicleHistoryByEmployeeIDAndDateRange[intCounter].VehicleNumber;
NewHistoryRow.FirstName = TheFindVehicleHistoryByEmployeeIDAndDateRangeDataSet.FindVehicleHistoryByEmployeeIDAndDateRange[intCounter].FirstName;
NewHistoryRow.LastName = TheFindVehicleHistoryByEmployeeIDAndDateRangeDataSet.FindVehicleHistoryByEmployeeIDAndDateRange[intCounter].LastName;
NewHistoryRow.TransactionDate = TheFindVehicleHistoryByEmployeeIDAndDateRangeDataSet.FindVehicleHistoryByEmployeeIDAndDateRange[intCounter].TransactionDate;
TheVehicleHistoryReportDataSet.historyreport.Rows.Add(NewHistoryRow);
}
}
dgrResults.ItemsSource = TheVehicleHistoryReportDataSet.historyreport;
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Vehicle History Report // Search Button " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
PleaseWait.Close();
}
private void mitPrint_Click(object sender, RoutedEventArgs e)
{
//setting local variables
int intCounter;
int intNumberOfRecords;
int intVehicleID;
DateTime datTransactionDate;
int intSecondCounter;
int intSecondNumberOfRecords;
string strInspectStatus;
string strVehicleProblem;
string strInspectionNotes;
int intThirdCounter;
int intThirdNumberOfRecords;
pdProblemReport = new PrintDialog();
if (pdProblemReport.ShowDialog().Value)
{
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
gdatEndDate = DateTime.Now;
gdatEndDate = TheDateSearchClass.RemoveTime(gdatEndDate);
gdatStartDate = TheDateSearchClass.SubtractingDays(gdatEndDate, 200);
intNumberOfRecords = TheSortedDOTAuditDataSete.dotaudit.Rows.Count - 1;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
TheDOTVehicleInspectionDataSet.inspectionresults.Rows.Clear();
intVehicleID = TheSortedDOTAuditDataSete.dotaudit[intCounter].VehicleID;
TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet = TheInspectionsClass.FindDailyVehicleInspectionByVehicleIDAndDateRange(intVehicleID, gdatStartDate, gdatEndDate);
intSecondNumberOfRecords = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange.Rows.Count - 1;
for (intSecondCounter = 0; intSecondCounter <= intSecondNumberOfRecords; intSecondCounter++)
{
strInspectStatus = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intSecondCounter].InspectionStatus;
datTransactionDate = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intSecondCounter].InspectionDate;
datTransactionDate = TheDateSearchClass.RemoveTime(datTransactionDate);
strVehicleProblem = "";
strInspectionNotes = "";
if (strInspectStatus == "PASSED")
{
strVehicleProblem = "NO PROBLEM REPORTED";
strInspectionNotes = "NO PROBLEM REPORTED";
}
else
{
TheFindDailyVehicleInspectionProblemByVehicleIDAndDateRangeDataSet = TheInspectionsClass.FindDailyVehicleInspectionProblemByVehicleIDAndDateRange(intVehicleID, datTransactionDate, datTransactionDate.AddDays(1));
intThirdNumberOfRecords = TheFindDailyVehicleInspectionProblemByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionProblemsByVehicleIDAndDateRange.Rows.Count - 1;
for (intThirdCounter = 0; intThirdCounter <= intThirdNumberOfRecords; intThirdCounter++)
{
if (TheFindDailyVehicleInspectionProblemByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionProblemsByVehicleIDAndDateRange[intThirdCounter].VehicleProblem == null)
{
strVehicleProblem = TheFindDailyVehicleInspectionProblemByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionProblemsByVehicleIDAndDateRange[intThirdCounter].InspectionNotes + "\n";
}
else
{
strVehicleProblem = TheFindDailyVehicleInspectionProblemByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionProblemsByVehicleIDAndDateRange[intThirdCounter].VehicleProblem + "\n";
}
strInspectionNotes = TheFindDailyVehicleInspectionProblemByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionProblemsByVehicleIDAndDateRange[intThirdCounter].InspectionNotes + "\n";
}
}
DOTVehicleInspectionDataSet.inspectionresultsRow NewInspectionRow = TheDOTVehicleInspectionDataSet.inspectionresults.NewinspectionresultsRow();
NewInspectionRow.VehicleNumber = TheSortedDOTAuditDataSete.dotaudit[intCounter].VehicleNumber;
NewInspectionRow.InspectionNotes = strInspectionNotes;
NewInspectionRow.InspectionStatus = strInspectStatus;
NewInspectionRow.OdometerReading = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intSecondCounter].OdometerReading;
NewInspectionRow.TransactionDate = datTransactionDate;
NewInspectionRow.VehicleProblem = strVehicleProblem;
TheDOTVehicleInspectionDataSet.inspectionresults.Rows.Add(NewInspectionRow);
}
PrintReports();
}
dgrResults.ItemsSource = TheDOTVehicleInspectionDataSet.inspectionresults;
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // DOT Audit Report // Process Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
PleaseWait.Close();
}
}
private void MitExportToExcel_Click(object sender, RoutedEventArgs e)
{
int intRowCounter;
int intRowNumberOfRecords;
int intColumnCounter;
int intColumnNumberOfRecords;
// Creating a Excel object.
Microsoft.Office.Interop.Excel._Application excel = new Microsoft.Office.Interop.Excel.Application();
Microsoft.Office.Interop.Excel._Workbook workbook = excel.Workbooks.Add(Type.Missing);
Microsoft.Office.Interop.Excel._Worksheet worksheet = null;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
worksheet = workbook.ActiveSheet;
worksheet.Name = "OpenOrders";
int cellRowIndex = 1;
int cellColumnIndex = 1;
intRowNumberOfRecords = TheReportedITAssetsDataSet.itassets.Rows.Count;
intColumnNumberOfRecords = TheReportedITAssetsDataSet.itassets.Columns.Count;
for (intColumnCounter = 0; intColumnCounter < intColumnNumberOfRecords; intColumnCounter++)
{
worksheet.Cells[cellRowIndex, cellColumnIndex] = TheReportedITAssetsDataSet.itassets.Columns[intColumnCounter].ColumnName;
cellColumnIndex++;
}
cellRowIndex++;
cellColumnIndex = 1;
//Loop through each row and read value from each column.
for (intRowCounter = 0; intRowCounter < intRowNumberOfRecords; intRowCounter++)
{
for (intColumnCounter = 0; intColumnCounter < intColumnNumberOfRecords; intColumnCounter++)
{
worksheet.Cells[cellRowIndex, cellColumnIndex] = TheReportedITAssetsDataSet.itassets.Rows[intRowCounter][intColumnCounter].ToString();
cellColumnIndex++;
}
cellColumnIndex = 1;
cellRowIndex++;
}
PleaseWait.Close();
//Getting the location and file name of the excel to save from user.
SaveFileDialog saveDialog = new SaveFileDialog();
saveDialog.Filter = "Excel files (*.xlsx)|*.xlsx|All files (*.*)|*.*";
saveDialog.FilterIndex = 1;
saveDialog.ShowDialog();
workbook.SaveAs(saveDialog.FileName);
MessageBox.Show("Export Successful");
}
catch (System.Exception ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Current IT Assets // Export to Excel " + ex.Message);
MessageBox.Show(ex.ToString());
}
finally
{
excel.Quit();
workbook = null;
excel = null;
}
}
private void mitGenerateReport_Click(object sender, RoutedEventArgs e)
{
string strValueForValidation;
string strErrorMessage = "";
bool blnThereIsAProblem = false;
bool blnFatalError = false;
int intCounter;
int intNumberOfRecords;
string strProjectID;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
gdecTotalHours = 0;
TheEmployeeProjectTaskDataSet.projecttask.Rows.Clear();
try
{
if (cboSelectEmployee.SelectedIndex < 1)
{
blnFatalError = true;
strErrorMessage += "An Employee Has Not Been Selected\n";
}
strValueForValidation = txtEnterStartDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The Start Date is not a Date\n";
}
else
{
gdatStartDate = Convert.ToDateTime(strValueForValidation);
}
strValueForValidation = txtEnterEndDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The End Date is not a Date\n";
}
else
{
gdatEndDate = Convert.ToDateTime(strValueForValidation);
}
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage(strErrorMessage);
return;
}
blnFatalError = TheDataValidationClass.verifyDateRange(gdatStartDate, gdatEndDate);
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage("The Start Date is after the End Date");
return;
}
TheFindEmployeeProjectTasksDataSet = TheEmployeeProductivityStatsClass.FindEmployeeProjectTaskStats(MainWindow.gintEmployeeID, gdatStartDate, gdatEndDate);
TheFindEmployeeByEmployeeIDDataSet = TheEmployeeClass.FindEmployeeByEmployeeID(MainWindow.gintEmployeeID);
intNumberOfRecords = TheFindEmployeeProjectTasksDataSet.FindEmployeeProjectTaskStats.Rows.Count - 1;
if (intNumberOfRecords > -1)
{
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
strProjectID = TheFindEmployeeProjectTasksDataSet.FindEmployeeProjectTaskStats[intCounter].AssignedProjectID;
TheFindProjectByAssignedProjectIDDataSet = TheProjectClass.FindProjectByAssignedProjectID(strProjectID);
EmployeeProjectTaskDataSet.projecttaskRow NewProjectTaskRow = TheEmployeeProjectTaskDataSet.projecttask.NewprojecttaskRow();
NewProjectTaskRow.AssignedProjectID = strProjectID;
NewProjectTaskRow.HomeOffice = TheFindEmployeeByEmployeeIDDataSet.FindEmployeeByEmployeeID[0].HomeOffice;
NewProjectTaskRow.ProjectName = TheFindProjectByAssignedProjectIDDataSet.FindProjectByAssignedProjectID[0].ProjectName;
NewProjectTaskRow.TotalFootagePieces = TheFindEmployeeProjectTasksDataSet.FindEmployeeProjectTaskStats[intCounter].TotalFootage;
NewProjectTaskRow.TotalHours = TheFindEmployeeProjectTasksDataSet.FindEmployeeProjectTaskStats[intCounter].TaskTotalHours;
NewProjectTaskRow.WorkTask = TheFindEmployeeProjectTasksDataSet.FindEmployeeProjectTaskStats[intCounter].WorkTask;
gdecTotalHours += TheFindEmployeeProjectTasksDataSet.FindEmployeeProjectTaskStats[intCounter].TaskTotalHours;
TheEmployeeProjectTaskDataSet.projecttask.Rows.Add(NewProjectTaskRow);
}
}
dgrResults.ItemsSource = TheEmployeeProjectTaskDataSet.projecttask;
txtTotalHours.Text = Convert.ToString(gdecTotalHours);
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Find Employee Hours // Generate Report Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
PleaseWait.Close();
}
private void MitGenerateReport_Click(object sender, RoutedEventArgs e)
{
//setting local variables
string strValueForValidation;
string strErrorMessage = "";
bool blnThereIsAProblem = false;
bool blnFatalError = false;
int intTaskCounter;
int intTaskNumberOfRecords;
int intProjectTaskCounter;
int intProjectTaskNumberOfRecords;
decimal decTotalFootages;
int intWorkTaskID;
string strWorkTask;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
strValueForValidation = txtStartDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The Start Date is not a Date\n";
}
else
{
MainWindow.gdatStartDate = Convert.ToDateTime(strValueForValidation);
}
strValueForValidation = txtEndDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The End Date is not a Date\n";
}
else
{
MainWindow.gdatEndDate = Convert.ToDateTime(strValueForValidation);
}
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage(strErrorMessage);
return;
}
else
{
blnFatalError = TheDataValidationClass.verifyDateRange(MainWindow.gdatStartDate, MainWindow.gdatEndDate);
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage("The Start Date is after the End Date");
return;
}
}
TheProjectTaskTotalsDataSet.projecttasktotals.Rows.Clear();
if (gblnAllTasks == true)
{
TheFindSortedWorkTaskDataSet = TheWorkTaskClass.FindSortedWorkTask();
intTaskNumberOfRecords = TheFindSortedWorkTaskDataSet.FindSortedWorkTask.Rows.Count - 1;
for (intTaskCounter = 0; intTaskCounter <= intTaskNumberOfRecords; intTaskCounter++)
{
intWorkTaskID = TheFindSortedWorkTaskDataSet.FindSortedWorkTask[intTaskCounter].WorkTaskID;
strWorkTask = TheFindSortedWorkTaskDataSet.FindSortedWorkTask[intTaskCounter].WorkTask;
TheFindProjectTasksForFootageDataSet = TheProjectTaskClass.FindProjectTasksForFootage(intWorkTaskID, MainWindow.gdatStartDate, MainWindow.gdatEndDate);
intProjectTaskNumberOfRecords = TheFindProjectTasksForFootageDataSet.FindProjectTasksForFootage.Rows.Count - 1;
if (intProjectTaskNumberOfRecords > -1)
{
decTotalFootages = 0;
for (intProjectTaskCounter = 0; intProjectTaskCounter <= intProjectTaskNumberOfRecords; intProjectTaskCounter++)
{
decTotalFootages += TheFindProjectTasksForFootageDataSet.FindProjectTasksForFootage[intProjectTaskCounter].FootagePieces;
}
ProjectTaskTotalsDataSet.projecttasktotalsRow NewTaskRow = TheProjectTaskTotalsDataSet.projecttasktotals.NewprojecttasktotalsRow();
NewTaskRow.WorkTaskID = intWorkTaskID;
NewTaskRow.WorkTask = strWorkTask;
NewTaskRow.FootagePieces = decTotalFootages;
TheProjectTaskTotalsDataSet.projecttasktotals.Rows.Add(NewTaskRow);
}
}
}
else if (gblnAllTasks == false)
{
TheFindProjectTasksForFootageDataSet = TheProjectTaskClass.FindProjectTasksForFootage(MainWindow.gintWorkTaskID, MainWindow.gdatStartDate, MainWindow.gdatEndDate);
intProjectTaskNumberOfRecords = TheFindProjectTasksForFootageDataSet.FindProjectTasksForFootage.Rows.Count - 1;
if (intProjectTaskNumberOfRecords > -1)
{
decTotalFootages = 0;
for (intProjectTaskCounter = 0; intProjectTaskCounter <= intProjectTaskNumberOfRecords; intProjectTaskCounter++)
{
decTotalFootages += TheFindProjectTasksForFootageDataSet.FindProjectTasksForFootage[intProjectTaskCounter].FootagePieces;
}
ProjectTaskTotalsDataSet.projecttasktotalsRow NewTaskRow = TheProjectTaskTotalsDataSet.projecttasktotals.NewprojecttasktotalsRow();
NewTaskRow.WorkTaskID = MainWindow.gintWorkTaskID;
NewTaskRow.WorkTask = MainWindow.gstrWorkTask;
NewTaskRow.FootagePieces = decTotalFootages;
TheProjectTaskTotalsDataSet.projecttasktotals.Rows.Add(NewTaskRow);
}
}
dgrResults.ItemsSource = TheProjectTaskTotalsDataSet.projecttasktotals;
PleaseWait.Close();
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // View Work Task Footages // Generate Report Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
}
private void mitGenerateReport_Click(object sender, RoutedEventArgs e)
{
string strProjectID;
int intRecordsReturned;
int intCounter;
int intNumberOfRecords;
string strFirstName;
string strLastName;
DateTime datTransactionDate;
string strWorkTask;
int intSecondCounter;
int intSecondNumberOfRecords;
bool blnItemFound;
int intTaskCounter;
DateTime datStartDate = DateTime.Now;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
TheProjectDailyTaskDataSet.projecttask.Rows.Clear();
TheProjectEmployeeHoursDataSet.employees.Rows.Clear();
strProjectID = txtEnterProjectID.Text;
if (strProjectID == "")
{
TheMessagesClass.ErrorMessage("Project ID Was Not Entered");
PleaseWait.Close();
return;
}
gdecTotalHours = 0;
TheEmployeeCrewDataSet.employeework.Rows.Clear();
TheFindProjectByAssignedProjectIDDataSet = TheProjectClass.FindProjectByAssignedProjectID(strProjectID);
intRecordsReturned = TheFindProjectByAssignedProjectIDDataSet.FindProjectByAssignedProjectID.Rows.Count;
if (intRecordsReturned == 0)
{
TheMessagesClass.InformationMessage("Project Was Not Found");
PleaseWait.Close();
return;
}
MainWindow.gintProjectID = TheFindProjectByAssignedProjectIDDataSet.FindProjectByAssignedProjectID[0].ProjectID;
TheFindProjectTaskHoursByAssignedProjectIDDataSet = TheProjectTaskClass.FindProjectTaskHoursByAssignedProjectID(strProjectID);
datStartDate = TheDataSearchClass.SubtractingDays(datStartDate, 1200);
TheFindProjectHoursDataSet = TheEmployeeProjectAssignmentClass.FindProjectHours(MainWindow.gintProjectID, datStartDate);
intNumberOfRecords = TheFindProjectHoursDataSet.FindProjectHours.Rows.Count - 1;
intSecondNumberOfRecords = 0;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
strFirstName = TheFindProjectHoursDataSet.FindProjectHours[intCounter].FirstName;
strLastName = TheFindProjectHoursDataSet.FindProjectHours[intCounter].LastName;
strWorkTask = TheFindProjectHoursDataSet.FindProjectHours[intCounter].WorkTask;
datTransactionDate = TheFindProjectHoursDataSet.FindProjectHours[intCounter].TransactionDate;
blnItemFound = false;
gdecTotalHours += TheFindProjectHoursDataSet.FindProjectHours[intCounter].TotalHours;
if (intSecondNumberOfRecords > 0)
{
for (intSecondCounter = 0; intSecondCounter < intSecondNumberOfRecords; intSecondCounter++)
{
if (datTransactionDate == TheEmployeeCrewDataSet.employeework[intSecondCounter].TransactionDate)
{
if (strFirstName == TheEmployeeCrewDataSet.employeework[intSecondCounter].FirstName)
{
if (strLastName == TheEmployeeCrewDataSet.employeework[intSecondCounter].LastName)
{
if (strWorkTask == TheEmployeeCrewDataSet.employeework[intSecondCounter].WorkTask)
{
blnItemFound = true;
TheEmployeeCrewDataSet.employeework[intSecondCounter].Hours += TheFindProjectHoursDataSet.FindProjectHours[intCounter].TotalHours;
}
}
}
}
}
}
if (blnItemFound == false)
{
EmployeeCrewDataSet.employeeworkRow NewEmployeeRow = TheEmployeeCrewDataSet.employeework.NewemployeeworkRow();
NewEmployeeRow.AssignedProjectID = TheFindProjectByAssignedProjectIDDataSet.FindProjectByAssignedProjectID[0].AssignedProjectID;
NewEmployeeRow.Crew = "";
NewEmployeeRow.FirstName = strFirstName;
NewEmployeeRow.FootagePieces = 0;
NewEmployeeRow.Hours = TheFindProjectHoursDataSet.FindProjectHours[intCounter].TotalHours;
NewEmployeeRow.LastName = strLastName;
NewEmployeeRow.ProjectName = TheFindProjectByAssignedProjectIDDataSet.FindProjectByAssignedProjectID[0].ProjectName;
NewEmployeeRow.TransactionDate = datTransactionDate;
NewEmployeeRow.WorkTask = strWorkTask;
TheEmployeeCrewDataSet.employeework.Rows.Add(NewEmployeeRow);
intSecondNumberOfRecords++;
}
}
intNumberOfRecords = intSecondNumberOfRecords - 1;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
strFirstName = TheEmployeeCrewDataSet.employeework[intCounter].FirstName;
strLastName = TheEmployeeCrewDataSet.employeework[intCounter].LastName;
strWorkTask = TheEmployeeCrewDataSet.employeework[intCounter].WorkTask;
datTransactionDate = TheEmployeeCrewDataSet.employeework[intCounter].TransactionDate;
TheFindWorkTaskByWorkTaskDataSet = TheWorkTaskClass.FindWorkTaskByWorkTask(strWorkTask);
MainWindow.gintWorkTaskID = TheFindWorkTaskByWorkTaskDataSet.FindWorkTaskByWorkTask[0].WorkTaskID;
MainWindow.gintEmployeeID = FindEmployeeID(strFirstName, strLastName);
if (MainWindow.gintEmployeeID == -1)
{
throw new Exception();
}
TheFindProjectWorkTaskDataSet = TheProjectTaskClass.FindProjectWorkTask(MainWindow.gintProjectID, MainWindow.gintEmployeeID, MainWindow.gintWorkTaskID, datTransactionDate, datTransactionDate);
intSecondNumberOfRecords = TheFindProjectWorkTaskDataSet.FindProjectWorkTask.Rows.Count - 1;
for (intSecondCounter = 0; intSecondCounter <= intSecondNumberOfRecords; intSecondCounter++)
{
TheEmployeeCrewDataSet.employeework[intCounter].FootagePieces += TheFindProjectWorkTaskDataSet.FindProjectWorkTask[intSecondCounter].FootagePieces;
}
TheFindEmployeeCrewAssignmentByDateRange = TheEmployeeCrewAssignmentClass.FindEmployeeCrewAssignmentByDateRange(MainWindow.gintEmployeeID, datTransactionDate, datTransactionDate);
intSecondNumberOfRecords = TheFindEmployeeCrewAssignmentByDateRange.FindEmployeeCrewAssignmentByDateRange.Rows.Count - 1;
for (intSecondCounter = 0; intSecondCounter <= intSecondNumberOfRecords; intSecondCounter++)
{
if (strProjectID == TheFindEmployeeCrewAssignmentByDateRange.FindEmployeeCrewAssignmentByDateRange[intSecondCounter].AssignedProjectID)
{
TheEmployeeCrewDataSet.employeework[intCounter].Crew = TheFindEmployeeCrewAssignmentByDateRange.FindEmployeeCrewAssignmentByDateRange[intSecondCounter].CrewID;
}
}
}
intNumberOfRecords = TheEmployeeCrewDataSet.employeework.Rows.Count - 1;
gintTaskCounter = 0;
gintTaskUIpperLimit = 0;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
blnItemFound = false;
strWorkTask = TheEmployeeCrewDataSet.employeework[intCounter].WorkTask;
datTransactionDate = TheEmployeeCrewDataSet.employeework[intCounter].TransactionDate;
if (gintTaskCounter > 0)
{
for (intTaskCounter = 0; intTaskCounter <= gintTaskUIpperLimit; intTaskCounter++)
{
if (datTransactionDate == TheProjectDailyTaskDataSet.projecttask[intTaskCounter].TransactionDate)
{
if (strWorkTask == TheProjectDailyTaskDataSet.projecttask[intTaskCounter].WorkTask)
{
TheProjectDailyTaskDataSet.projecttask[intTaskCounter].Hours += TheEmployeeCrewDataSet.employeework[intCounter].Hours;
blnItemFound = true;
if (TheProjectDailyTaskDataSet.projecttask[intTaskCounter].Footage == 0)
{
TheProjectDailyTaskDataSet.projecttask[intTaskCounter].Footage = TheEmployeeCrewDataSet.employeework[intCounter].FootagePieces;
}
}
}
}
}
if (blnItemFound == false)
{
ProjectDailyTaskDataSet.projecttaskRow NewTaskRow = TheProjectDailyTaskDataSet.projecttask.NewprojecttaskRow();
NewTaskRow.Crew = TheEmployeeCrewDataSet.employeework[intCounter].Crew;
NewTaskRow.Footage = TheEmployeeCrewDataSet.employeework[intCounter].FootagePieces;
NewTaskRow.Hours = TheEmployeeCrewDataSet.employeework[intCounter].Hours;
NewTaskRow.TransactionDate = TheEmployeeCrewDataSet.employeework[intCounter].TransactionDate;
NewTaskRow.WorkTask = TheEmployeeCrewDataSet.employeework[intCounter].WorkTask;
TheProjectDailyTaskDataSet.projecttask.Rows.Add(NewTaskRow);
gintTaskUIpperLimit = gintTaskCounter;
gintTaskCounter++;
}
}
txtTotalHours.Text = Convert.ToString(gdecTotalHours);
intNumberOfRecords = TheFindProjectTaskHoursByAssignedProjectIDDataSet.FindProjectTaskHoursByAssignedProjectID.Rows.Count - 1;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
MainWindow.gintWorkTaskID = TheFindProjectTaskHoursByAssignedProjectIDDataSet.FindProjectTaskHoursByAssignedProjectID[intCounter].TaskID;
MainWindow.gintEmployeeID = TheFindProjectTaskHoursByAssignedProjectIDDataSet.FindProjectTaskHoursByAssignedProjectID[intCounter].EmployeeID;
TheFindEmployeeByEmployeeIDDataSet = TheEmployeeClass.FindEmployeeByEmployeeID(MainWindow.gintEmployeeID);
TheFindWorkTaskByTaskIDDataSet = TheWorkTaskClass.FindWorkTaskByWorkTaskID(MainWindow.gintWorkTaskID);
ProjectEmployeeHoursDataSet.employeesRow NewEmployeeRow = TheProjectEmployeeHoursDataSet.employees.NewemployeesRow();
NewEmployeeRow.FirstName = TheFindEmployeeByEmployeeIDDataSet.FindEmployeeByEmployeeID[0].FirstName;
NewEmployeeRow.LastName = TheFindEmployeeByEmployeeIDDataSet.FindEmployeeByEmployeeID[0].LastName;
NewEmployeeRow.TotalHours = TheFindProjectTaskHoursByAssignedProjectIDDataSet.FindProjectTaskHoursByAssignedProjectID[intCounter].EmployeeTotalHours;
NewEmployeeRow.TransactionDate = TheFindProjectTaskHoursByAssignedProjectIDDataSet.FindProjectTaskHoursByAssignedProjectID[intCounter].TransactionDate;
NewEmployeeRow.WorkTask = TheFindWorkTaskByTaskIDDataSet.FindWorkTaskByWorkTaskID[0].WorkTask;
TheProjectEmployeeHoursDataSet.employees.Rows.Add(NewEmployeeRow);
}
dgrResults.ItemsSource = TheProjectDailyTaskDataSet.projecttask;
dgrEmployees.ItemsSource = TheProjectEmployeeHoursDataSet.employees;
bool blnFatalError = TheEmployeeDateEntryClass.InsertIntoEmployeeDateEntry(MainWindow.TheVerifyLogonDataSet.VerifyLogon[0].EmployeeID, "Blue Jay ERP // Find Project Employee Hours // Generate Report Menu Item ");
}
catch (Exception Ex)
{
PleaseWait.Close();
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Find Project Employee Hours // Generate Report Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
PleaseWait.Close();
}
private void mitSelectSpreadSheet_Click(object sender, RoutedEventArgs e)
{
Excel.Application xlDropOrder;
Excel.Workbook xlDropBook;
Excel.Worksheet xlDropSheet;
Excel.Range range;
string strInformation = "";
int intColumnRange = 0;
int intCounter;
int intNumberOfRecords;
char[] chaInformation;
int intCharCounter;
int intCharLength;
string strCompleteWord = "";
int intLength;
try
{
TheImportedDataSet.importedjobs.Rows.Clear();
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
dlg.FileName = "Document"; // Default file name
dlg.DefaultExt = ".csv"; // Default file extension
dlg.Filter = "Excel (.csv)|*.csv"; // Filter files by extension
// Show open file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process open file dialog box results
if (result == true)
{
// Open document
string filename = dlg.FileName;
}
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
xlDropOrder = new Excel.Application();
xlDropBook = xlDropOrder.Workbooks.Open(dlg.FileName, 0, true, 5, "", "", true, Microsoft.Office.Interop.Excel.XlPlatform.xlWindows, "\t", false, false, 0, true, 1, 0);
xlDropSheet = (Excel.Worksheet)xlDropOrder.Worksheets.get_Item(1);
range = xlDropSheet.UsedRange;
intNumberOfRecords = range.Rows.Count - 1;
intColumnRange = range.Columns.Count;
for (intCounter = 2; intCounter <= intNumberOfRecords; intCounter++)
{
strInformation = Convert.ToString((range.Cells[intCounter, 1] as Excel.Range).Value2);
gintColumnCounter = 0;
chaInformation = strInformation.ToCharArray();
intCharLength = strInformation.Length - 1;
ImportedDataSet.importedjobsRow NewJobRow = TheImportedDataSet.importedjobs.NewimportedjobsRow();
NewJobRow.ScheduledDate = DateTime.Now;
for (intCharCounter = 0; intCharCounter <= intCharLength; intCharCounter++)
{
if (chaInformation[intCharCounter] != ',')
{
strCompleteWord += Convert.ToString(chaInformation[intCharCounter]);
strCompleteWord = strCompleteWord.ToUpper();
}
else
{
if (gintColumnCounter == 1)
{
NewJobRow.WorkorderID = strCompleteWord;
}
else if (gintColumnCounter == 11)
{
NewJobRow.JobStatus = strCompleteWord;
}
else if (gintColumnCounter == 29)
{
strCompleteWord = strCompleteWord.Substring(2);
if (strCompleteWord == "MAPLE")
{
strCompleteWord = "MAPLE HTS";
}
NewJobRow.Pool = strCompleteWord;
}
else if (gintColumnCounter == 57)
{
NewJobRow.AccountID = strCompleteWord;
}
else if (gintColumnCounter == 58)
{
NewJobRow.FirstName = strCompleteWord;
}
else if (gintColumnCounter == 59)
{
NewJobRow.LastName = strCompleteWord;
}
else if (gintColumnCounter == 60)
{
if (strCompleteWord == "(999) 999-9999")
{
strCompleteWord = Convert.ToString(gintPhoneCounter);
gintPhoneCounter++;
}
else if (strCompleteWord == "")
{
strCompleteWord = Convert.ToString(gintPhoneCounter);
gintPhoneCounter++;
}
else if (strCompleteWord == null)
{
strCompleteWord = Convert.ToString(gintPhoneCounter);
gintPhoneCounter++;
}
NewJobRow.PhoneNumber = strCompleteWord;
}
else if (gintColumnCounter == 75)
{
NewJobRow.StreetAddress = strCompleteWord;
}
else if (gintColumnCounter == 77)
{
NewJobRow.City = strCompleteWord;
}
else if (gintColumnCounter == 78)
{
NewJobRow.State = strCompleteWord;
}
else if (gintColumnCounter == 79)
{
intLength = strCompleteWord.Length;
if (intColumnRange > 5)
{
strCompleteWord = strCompleteWord.Substring(0, 5);
}
NewJobRow.Zip = strCompleteWord;
}
strCompleteWord = "";
gintColumnCounter++;
}
}
TheImportedDataSet.importedjobs.Rows.Add(NewJobRow);
}
CheckOpenOrders();
PleaseWait.Close();
dgrResults.ItemsSource = TheImportedDataSet.importedjobs;
mitImportJobs.IsEnabled = true;
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Import MDU Drop Bury Orders // Select Spreadsheet Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
}
private void mitGenerateReport_Click(object sender, RoutedEventArgs e)
{
//setting local variables
bool blnThereIsAProblem = false;
bool blnFatalError = false;
string strValueForValidation;
string strErrorMessage = "";
int intCounter;
int intNumberOfRecords;
int intInspectionID;
int intRecordsReturned;
string strVehicleNumber;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
TheDailyVehicleInspectionReportDataSet.dailyinspection.Rows.Clear();
strValueForValidation = txtStartDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "Start Date is not a Date\n";
}
else
{
gdatStartDate = Convert.ToDateTime(strValueForValidation);
}
strValueForValidation = txtEndDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "End Date is not a Date\n";
}
else
{
gdatEndDate = Convert.ToDateTime(strValueForValidation);
gdatEndDate = TheDataSearchClass.RemoveTime(gdatEndDate);
gdatEndDate = TheDataSearchClass.AddingDays(gdatEndDate, 1);
}
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage(strErrorMessage);
PleaseWait.Close();
return;
}
else
{
blnFatalError = TheDataValidationClass.verifyDateRange(gdatStartDate, gdatEndDate);
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage("Start Date is After the End Date");
PleaseWait.Close();
return;
}
}
if (gstrReportType == "DATE RANGE")
{
TheFindDailyVehicleInspectionByDateRangeDataSet = TheInspectionClass.FindDailyVehicleInspectionByDateRange(gdatStartDate, gdatEndDate);
intNumberOfRecords = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange.Rows.Count - 1;
if (intNumberOfRecords > -1)
{
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
DailyVehicleInspectionReportDataSet.dailyinspectionRow NewInspectionRow = TheDailyVehicleInspectionReportDataSet.dailyinspection.NewdailyinspectionRow();
intInspectionID = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange[intCounter].TransactionID;
TheFindVehicleInspectionProblemByInsepctionIDDataSet = TheInspectionClass.FindVehicleInspectionProblemsbyInspectionID(intInspectionID);
intRecordsReturned = TheFindVehicleInspectionProblemByInsepctionIDDataSet.FindVehicleInspectionProblemsByInspectionID.Rows.Count;
if (intRecordsReturned == 0)
{
NewInspectionRow.InspectionNotes = "NO NOTES REPORTED";
}
else
{
NewInspectionRow.InspectionNotes = TheFindVehicleInspectionProblemByInsepctionIDDataSet.FindVehicleInspectionProblemsByInspectionID[0].InspectionNotes;
}
NewInspectionRow.FirstName = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange[intCounter].FirstName;
NewInspectionRow.InspectionDate = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange[intCounter].InspectionDate;
NewInspectionRow.InspectionID = intInspectionID;
NewInspectionRow.InspectionStatus = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange[intCounter].InspectionStatus;
NewInspectionRow.LastName = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange[intCounter].LastName;
NewInspectionRow.OdometerReading = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange[intCounter].OdometerReading;
NewInspectionRow.VehicleID = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange[intCounter].VehicleID;
NewInspectionRow.VehicleNumber = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange[intCounter].VehicleNumber;
NewInspectionRow.HomeOffice = TheFindDailyVehicleInspectionByDateRangeDataSet.FindDailyVehicleInspectionByDateRange[intCounter].AssignedOffice;
TheDailyVehicleInspectionReportDataSet.dailyinspection.Rows.Add(NewInspectionRow);
}
}
}
else if (gstrReportType == "EMPLOYEE")
{
TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet = TheInspectionClass.FindDailyVehicleInspectionByEmployeeIDAndDateRange(gintEmployeeID, gdatStartDate, gdatEndDate);
intNumberOfRecords = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange.Rows.Count - 1;
if (intNumberOfRecords > -1)
{
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
DailyVehicleInspectionReportDataSet.dailyinspectionRow NewInspectionRow = TheDailyVehicleInspectionReportDataSet.dailyinspection.NewdailyinspectionRow();
intInspectionID = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange[intCounter].TransactionID;
TheFindVehicleInspectionProblemByInsepctionIDDataSet = TheInspectionClass.FindVehicleInspectionProblemsbyInspectionID(intInspectionID);
intRecordsReturned = TheFindVehicleInspectionProblemByInsepctionIDDataSet.FindVehicleInspectionProblemsByInspectionID.Rows.Count;
if (intRecordsReturned == 0)
{
NewInspectionRow.InspectionNotes = "NO NOTES REPORTED";
}
else
{
NewInspectionRow.InspectionNotes = TheFindVehicleInspectionProblemByInsepctionIDDataSet.FindVehicleInspectionProblemsByInspectionID[0].InspectionNotes;
}
NewInspectionRow.FirstName = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange[intCounter].FirstName;
NewInspectionRow.InspectionDate = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange[intCounter].InspectionDate;
NewInspectionRow.InspectionID = intInspectionID;
NewInspectionRow.InspectionStatus = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange[intCounter].InspectionStatus;
NewInspectionRow.LastName = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange[intCounter].LastName;
NewInspectionRow.OdometerReading = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange[intCounter].OdometerReading;
NewInspectionRow.VehicleID = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange[intCounter].VehicleID;
NewInspectionRow.VehicleNumber = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange[intCounter].VehicleNumber;
NewInspectionRow.HomeOffice = TheFindDailyVehicleInspectionByEmployeeIDAndDateRangeDataSet.FindDailyVehicleInspectionsByEmployeeIDAndDateRange[intCounter].AssignedOffice;
TheDailyVehicleInspectionReportDataSet.dailyinspection.Rows.Add(NewInspectionRow);
}
}
}
else if (gstrReportType == "VEHICLE NUMBER")
{
strVehicleNumber = txtSearchInfo.Text;
if (strVehicleNumber == "")
{
TheMessagesClass.ErrorMessage("Vehicle Number Not Entered");
PleaseWait.Close();
return;
}
TheFindActiveVehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);
intRecordsReturned = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;
if (intRecordsReturned == 0)
{
TheMessagesClass.ErrorMessage("Vehicle Numbered Does Not Exist");
PleaseWait.Close();
return;
}
else
{
gintVehicleID = TheFindActiveVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;
}
TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet = TheInspectionClass.FindDailyVehicleInspectionByVehicleIDAndDateRange(gintVehicleID, gdatStartDate, gdatEndDate);
intNumberOfRecords = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange.Rows.Count - 1;
if (intNumberOfRecords > -1)
{
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
DailyVehicleInspectionReportDataSet.dailyinspectionRow NewInspectionRow = TheDailyVehicleInspectionReportDataSet.dailyinspection.NewdailyinspectionRow();
intInspectionID = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intCounter].TransactionID;
TheFindVehicleInspectionProblemByInsepctionIDDataSet = TheInspectionClass.FindVehicleInspectionProblemsbyInspectionID(intInspectionID);
intRecordsReturned = TheFindVehicleInspectionProblemByInsepctionIDDataSet.FindVehicleInspectionProblemsByInspectionID.Rows.Count;
if (intRecordsReturned == 0)
{
NewInspectionRow.InspectionNotes = "NO NOTES REPORTED";
}
else
{
NewInspectionRow.InspectionNotes = TheFindVehicleInspectionProblemByInsepctionIDDataSet.FindVehicleInspectionProblemsByInspectionID[0].InspectionNotes;
}
NewInspectionRow.FirstName = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intCounter].FirstName;
NewInspectionRow.InspectionDate = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intCounter].InspectionDate;
NewInspectionRow.InspectionID = intInspectionID;
NewInspectionRow.InspectionStatus = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intCounter].InspectionStatus;
NewInspectionRow.LastName = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intCounter].LastName;
NewInspectionRow.OdometerReading = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intCounter].OdometerReading;
NewInspectionRow.VehicleID = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intCounter].VehicleID;
NewInspectionRow.VehicleNumber = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intCounter].VehicleNumber;
NewInspectionRow.HomeOffice = TheFindDailyVehicleInspectionByVehicleIDAndDateRangeDataSet.FindDailyVehicleInspectionsByVehicleIDAndDateRange[intCounter].AssignedOffice;
TheDailyVehicleInspectionReportDataSet.dailyinspection.Rows.Add(NewInspectionRow);
}
}
}
dgrResults.ItemsSource = TheDailyVehicleInspectionReportDataSet.dailyinspection;
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Daily Vehicle Inspection Report // Generate Report Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
PleaseWait.Close();
}
private void mitProcess_Click(object sender, RoutedEventArgs e)
{
bool blnFatalError = false;
DateTime datTransactionDate = DateTime.Now;
string strErrorMessage = "";
try
{
if (MainWindow.gintTrailerID == -1)
{
blnFatalError = true;
strErrorMessage += "Trailer Was Not Entered\n";
}
if (cboSelectEmployee.SelectedIndex < 1)
{
blnFatalError = true;
strErrorMessage += "Employee Was Not Selected\n";
}
if (cboDamageReported.SelectedIndex < 1)
{
blnFatalError = true;
strErrorMessage += "Damage Reported Was Not Selected\n";
}
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage(strErrorMessage);
return;
}
if (gblnProblemReported == false)
{
MainWindow.gstrInspectionProblem = "NO PROBLEMS REPORTED";
}
else
{
InspectionTrailerProblems InspectionTrailerProblems = new InspectionTrailerProblems();
InspectionTrailerProblems.ShowDialog();
}
blnFatalError = TheDailyTrailerInspectionClass.InsertDailyTrailerInspection(MainWindow.gintTrailerID, MainWindow.gintEmployeeID, datTransactionDate, gstrInspectionStatus, MainWindow.gstrInspectionProblem);
if (blnFatalError == true)
{
throw new Exception();
}
blnFatalError = TheTrailerHistoryClass.InsertTrailerHistory(MainWindow.gintTrailerID, MainWindow.gintEmployeeID, MainWindow.TheVerifyLogonDataSet.VerifyLogon[0].EmployeeID, "TRAILER SIGNED OUT");
if (blnFatalError == true)
{
throw new Exception();
}
if (gstrInspectionStatus == "FAILED")
{
PleaseWait pleaseWait = new PleaseWait();
pleaseWait.Show();
TheSendEmailClass.TrailerEmailMessage(txtEnterTrailerNumber.Text, MainWindow.gstrInspectionProblem);
pleaseWait.Close();
}
TheMessagesClass.InformationMessage("The Trailer Inspection Has Been Entered");
ResetControls();
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Daily Trailer Inspection // Process Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
}
private void mitImportExcel_Click(object sender, RoutedEventArgs e)
{
bool blnIsNotInteger = false;
Excel.Application xlDropOrder;
Excel.Workbook xlDropBook;
Excel.Worksheet xlDropSheet;
Excel.Range range;
string strInformation = "";
int intColumnRange = 0;
int intCounter;
int intNumberOfRecords;
string strVehicleNumber;
int intVehicleID;
int intSecondCounter;
int intSecondNumberOfRecords;
try
{
TheDOTAuditDataSet.dotaudit.Rows.Clear();
Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
dlg.FileName = "Document"; // Default file name
// dlg.DefaultExt = ".csv"; // Default file extension
//dlg.Filter = "Excel (.csv)|*.csv"; // Filter files by extension
// Show open file dialog box
Nullable <bool> result = dlg.ShowDialog();
// Process open file dialog box results
if (result == true)
{
// Open document
string filename = dlg.FileName;
}
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
xlDropOrder = new Excel.Application();
xlDropBook = xlDropOrder.Workbooks.Open(dlg.FileName, 0, true, 5, "", "", true, Microsoft.Office.Interop.Excel.XlPlatform.xlWindows, "\t", false, false, 0, true, 1, 0);
xlDropSheet = (Excel.Worksheet)xlDropOrder.Worksheets.get_Item(1);
range = xlDropSheet.UsedRange;
intNumberOfRecords = range.Rows.Count - 1;
intColumnRange = range.Columns.Count;
for (intCounter = 2; intCounter <= intNumberOfRecords; intCounter++)
{
strInformation = Convert.ToString((range.Cells[intCounter, 2] as Excel.Range).Value2);
strInformation = strInformation.Substring(4, 4);
blnIsNotInteger = TheDataValidationClass.VerifyIntegerData(strInformation);
if (blnIsNotInteger == false)
{
DOTAuditDataSet.dotauditRow NewVehicleRow = TheDOTAuditDataSet.dotaudit.NewdotauditRow();
strVehicleNumber = strInformation;
TheFindActiveVehicleBVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);
intVehicleID = TheFindActiveVehicleBVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;
NewVehicleRow.VehicleID = intVehicleID;
NewVehicleRow.VehicleNumber = strVehicleNumber;
NewVehicleRow.VIN = TheFindActiveVehicleBVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VINNumber;
TheDOTAuditDataSet.dotaudit.Rows.Add(NewVehicleRow);
}
}
ThefindActiveVehicleMainSortedDataSet = TheVehicleMainClass.FindActiveVehicleMainSorted();
intNumberOfRecords = ThefindActiveVehicleMainSortedDataSet.FindActiveVehicleMainSorted.Rows.Count - 1;
intSecondNumberOfRecords = TheDOTAuditDataSet.dotaudit.Rows.Count - 1;
for (intCounter = 0; intCounter <= intNumberOfRecords; intCounter++)
{
intVehicleID = ThefindActiveVehicleMainSortedDataSet.FindActiveVehicleMainSorted[intCounter].VehicleID;
for (intSecondCounter = 0; intSecondCounter <= intSecondNumberOfRecords; intSecondCounter++)
{
if (intVehicleID == TheDOTAuditDataSet.dotaudit[intSecondCounter].VehicleID)
{
DOTAuditDataSet.dotauditRow NewVehicleRow = TheSortedDOTAuditDataSete.dotaudit.NewdotauditRow();
NewVehicleRow.VehicleNumber = TheDOTAuditDataSet.dotaudit[intSecondCounter].VehicleNumber;
NewVehicleRow.VehicleID = intVehicleID;
NewVehicleRow.VIN = TheDOTAuditDataSet.dotaudit[intSecondCounter].VIN;
TheSortedDOTAuditDataSete.dotaudit.Rows.Add(NewVehicleRow);
}
}
}
PleaseWait.Close();
dgrResults.ItemsSource = TheSortedDOTAuditDataSete.dotaudit;
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // DOT Audit Report // Import Excel Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
}
private void mitProcess_Click(object sender, RoutedEventArgs e)
{
//setting variables
int intTaskCounter;
int intTaskNumberOfRecords;
int intTaskID;
int intEmployeeCounter;
int intEmployeeNumberOfRecords;
int intTransactionID;
bool blnFatalError = false;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
intTaskNumberOfRecords = TheOldWorkTasksDataSet.worktask.Rows.Count - 1;
for (intTaskCounter = 0; intTaskCounter <= intTaskNumberOfRecords; intTaskCounter++)
{
if (TheOldWorkTasksDataSet.worktask[intTaskCounter].ChangeItems == true)
{
intTaskID = TheOldWorkTasksDataSet.worktask[intTaskCounter].WorkTaskID;
TheFindEmployeeProjectAssignmentByTaskIDDataSet = TheEmployeeProjectAssignmentClass.FindEmployeeProjectAssignementByTaskID(intTaskID);
intEmployeeNumberOfRecords = TheFindEmployeeProjectAssignmentByTaskIDDataSet.FindEmployeeProjectAssignmentByTaskID.Rows.Count - 1;
for (intEmployeeCounter = 0; intEmployeeCounter <= intEmployeeNumberOfRecords; intEmployeeCounter++)
{
intTransactionID = TheFindEmployeeProjectAssignmentByTaskIDDataSet.FindEmployeeProjectAssignmentByTaskID[intEmployeeCounter].TransactionID;
blnFatalError = TheEmployeeProjectAssignmentClass.UpdateEmployeeProjectAssignmentTaskID(intTransactionID, gintNewTaskID);
if (blnFatalError == true)
{
throw new Exception();
}
}
blnFatalError = TheWorkTaskClass.UpdateWorkTaskActive(intTaskID, false);
TheFindProjectTaskByTaskIDDataSet = TheProjectTaskClass.FindProjectTaskByTaskID(intTaskID);
intEmployeeNumberOfRecords = TheFindProjectTaskByTaskIDDataSet.FindProjectTaskByTaskID.Rows.Count - 1;
for (intEmployeeCounter = 0; intEmployeeCounter <= intEmployeeNumberOfRecords; intEmployeeCounter++)
{
intTransactionID = TheFindProjectTaskByTaskIDDataSet.FindProjectTaskByTaskID[intEmployeeCounter].TransactionID;
blnFatalError = TheProjectTaskClass.UpdateProjectTaskID(intTransactionID, intTaskCounter);
if (blnFatalError == true)
{
throw new Exception();
}
}
}
}
TheMessagesClass.InformationMessage("All Tasks Have Been Updated");
TheOldWorkTasksDataSet.worktask.Rows.Clear();
dgrOldTasks.ItemsSource = TheOldWorkTasksDataSet.worktask;
TheFindWorktaskByTaskKeywordDataSet = TheWorkTaskClass.FindWorkTaskByTaskKeyword("llllllllll");
dgrNewTask.ItemsSource = TheFindWorktaskByTaskKeywordDataSet.FindWorkTaskByTaskKeyword;
txtNewTask.Text = "";
txtOldTaskName.Text = "";
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Edit Project Work Task // Process Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
PleaseWait.Close();
}
private void mitGenerateReport_Click(object sender, RoutedEventArgs e)
{
//setting local viarables
string strValueForValidation;
string strErrorMessage = "";
bool blnThereIsAProblem = false;
bool blnFatalError = false;
int intLaborCounter;
int intLaborNumberOfRecords;
int intEmployeeCounter;
int intEmployeeNumberOfRecords;
int intEmployeeID;
decimal decHours;
bool blnItemFound;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
TheTotalHoursDataSet.totalhours.Rows.Clear();
strValueForValidation = txtEnterStartDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The Start Date is not a Date\n";
}
else
{
MainWindow.gdatStartDate = Convert.ToDateTime(strValueForValidation);
}
strValueForValidation = txtEnterEndDate.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDateData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The End Date is not a Date\n";
}
else
{
MainWindow.gdatEndDate = Convert.ToDateTime(strValueForValidation);
}
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage(strErrorMessage);
PleaseWait.Close();
return;
}
else
{
blnFatalError = TheDataValidationClass.verifyDateRange(MainWindow.gdatStartDate, MainWindow.gdatEndDate);
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage("The Start Date is after the End Date");
PleaseWait.Close();
return;
}
}
TheFindLaborHoursByDateRangeDataSet = TheEmployeeProjectAssignmentClass.FindLaborHoursByDateRange(MainWindow.gdatStartDate, MainWindow.gdatEndDate);
intLaborNumberOfRecords = TheFindLaborHoursByDateRangeDataSet.FindLaborHoursByDateRange.Rows.Count - 1;
intEmployeeNumberOfRecords = 0;
for (intLaborCounter = 0; intLaborCounter <= intLaborNumberOfRecords; intLaborCounter++)
{
intEmployeeID = TheFindLaborHoursByDateRangeDataSet.FindLaborHoursByDateRange[intLaborCounter].EmployeeID;
decHours = TheFindLaborHoursByDateRangeDataSet.FindLaborHoursByDateRange[intLaborCounter].TotalHours;
blnItemFound = false;
if (intEmployeeNumberOfRecords > 0)
{
for (intEmployeeCounter = 0; intEmployeeCounter < intEmployeeNumberOfRecords; intEmployeeCounter++)
{
if (intEmployeeID == TheTotalHoursDataSet.totalhours[intEmployeeCounter].EmployeeID)
{
blnItemFound = true;
TheTotalHoursDataSet.totalhours[intEmployeeCounter].TotalHours += decHours;
}
}
}
if (blnItemFound == false)
{
TheFindEmployeeByEmployeeIDDataSet = TheEmployeeClass.FindEmployeeByEmployeeID(intEmployeeID);
TotalHoursDataSet.totalhoursRow NewEmployeeRow = TheTotalHoursDataSet.totalhours.NewtotalhoursRow();
NewEmployeeRow.EmployeeID = intEmployeeID;
NewEmployeeRow.EmployeeType = TheFindEmployeeByEmployeeIDDataSet.FindEmployeeByEmployeeID[0].EmployeeType;
NewEmployeeRow.FirstName = TheFindEmployeeByEmployeeIDDataSet.FindEmployeeByEmployeeID[0].FirstName;
NewEmployeeRow.HomeOffice = TheFindEmployeeByEmployeeIDDataSet.FindEmployeeByEmployeeID[0].HomeOffice;
NewEmployeeRow.LastName = TheFindEmployeeByEmployeeIDDataSet.FindEmployeeByEmployeeID[0].LastName;
NewEmployeeRow.TotalHours = decHours;
TheTotalHoursDataSet.totalhours.Rows.Add(NewEmployeeRow);
intEmployeeNumberOfRecords++;
}
}
TheTotalHoursDataSet.totalhours.DefaultView.Sort = "TotalHours DESC";
dgrResults.ItemsSource = TheTotalHoursDataSet.totalhours;
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Find Labor Hours // Generate Report Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
PleaseWait.Close();
}
private void mitProcess_Click(object sender, RoutedEventArgs e)
{
//this will process the information
string strValueForValidation;
bool blnFatalError = false;
bool blnThereIsAProblem = false;
string strErrorMessage = "";
string strVehicleNumber;
int intRecordsReturned;
try
{
strVehicleNumber = txtEnterBJCNumber.Text;
TheFindVehicleMainByVehicleNumberDataSet = TheVehicleMainClass.FindActiveVehicleMainByVehicleNumber(strVehicleNumber);
intRecordsReturned = TheFindVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber.Rows.Count;
if (intRecordsReturned == 0)
{
blnFatalError = true;
strErrorMessage += "Vehicle Number Entered Was Not Found\n";
}
else
{
MainWindow.gintVehicleID = TheFindVehicleMainByVehicleNumberDataSet.FindActiveVehicleMainByVehicleNumber[0].VehicleID;
}
strValueForValidation = cboEmployee.SelectedItem.ToString();
if (strValueForValidation == "Select Employee")
{
blnFatalError = true;
strErrorMessage += "The Employee Was Not Selected\n";
}
if (rdoFailed.IsChecked == false)
{
if (rdoPassed.IsChecked == false)
{
if (rdoPassedServiceRequired.IsChecked == false)
{
blnFatalError = true;
strErrorMessage += "Passed, Passed Service Required, or Failure Was Not Checked\n";
}
}
}
strValueForValidation = txtOdometerReading.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyIntegerData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The Odometer Reading is not an Integer\n";
}
else
{
MainWindow.gintOdometerReading = Convert.ToInt32(strValueForValidation);
}
if (cboVehicleCleanliness.SelectedIndex == 0)
{
blnFatalError = true;
strErrorMessage += "Cleanliness Was Not Selected\n";
}
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage(strErrorMessage);
return;
}
MainWindow.gdatTransactionDate = DateTime.Now;
blnFatalError = TheWeeklyInspectionClass.InsertWeeklyVehicleInspection(MainWindow.gintVehicleID, MainWindow.gdatTransactionDate, MainWindow.gintEmployeeID, MainWindow.gstrInspectionStatus, MainWindow.gintOdometerReading);
if (blnFatalError == true)
{
TheMessagesClass.ErrorMessage("There Was a Problem, Contact ID");
return;
}
TheFindWeeklyVehicleInspectionIDDataSet = TheWeeklyInspectionClass.FindWeelyVehicleInspectionID(MainWindow.gintVehicleID, MainWindow.gintEmployeeID, MainWindow.gintOdometerReading, MainWindow.gdatTransactionDate);
MainWindow.gintInspectionID = TheFindWeeklyVehicleInspectionIDDataSet.FindWeeklyVehicleInspectionID[0].TransactionID;
blnFatalError = TheWeeklyVehicleCleanlinessClass.InsertWeeklyVehicleCleanliness(MainWindow.gintInspectionID, MainWindow.gintVehicleID, gblnVehicleCleanliness, MainWindow.gstrCleanlinessNotes);
if (blnFatalError == true)
{
throw new Exception();
}
if ((rdoFailed.IsChecked == true) || (rdoPassedServiceRequired.IsChecked == true))
{
VehicleInspectionProblem VehicleInspectionProblem = new VehicleInspectionProblem();
VehicleInspectionProblem.ShowDialog();
}
else if (rdoPassed.IsChecked == true)
{
TheFindOpenVehicleProblemsbyVehicleIDDataSet = TheVehicleProblemClass.FindOpenVehicleProblemsbyVehicleID(MainWindow.gintVehicleID);
intRecordsReturned = TheFindOpenVehicleProblemsbyVehicleIDDataSet.FindOpenVehicleProblemsByVehicleID.Rows.Count;
if (intRecordsReturned > 0)
{
TheMessagesClass.ErrorMessage("There Are Open Problems with this Vehicle and\nYou Are Reporting No Problems, Please Correct");
return;
}
}
if (rdoFailed.IsChecked == true)
{
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
TheVehicleStatusClass.UpdateVehicleStatus(MainWindow.gintVehicleID, "DOWN", DateTime.Now);
TheSendEmailClass.EmailMessage(MainWindow.gstrVehicleNumber, MainWindow.gstrVehicleProblem);
PleaseWait.Close();
}
BulkToolsAssignedToVehicle BulkToolsAssignedToVehicle = new BulkToolsAssignedToVehicle();
BulkToolsAssignedToVehicle.ShowDialog();
txtEnterBJCNumber.Text = "";
cboEmployee.Items.Clear();
txtEnterLastName.Text = "";
txtOdometerReading.Text = "";
rdoFailed.IsChecked = false;
rdoPassed.IsChecked = false;
rdoPassedServiceRequired.IsChecked = false;
cboBodyDamageReported.SelectedIndex = 0;
cboVehicleCleanliness.SelectedIndex = 0;
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Manager Weekly Audit Data Entry // Process Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
}
private void mitSave_Click(object sender, RoutedEventArgs e)
{
//setting local variables
string strPartNumber;
int intPartID;
string strDescription;
string strJDEPartNumber;
double douPrice = 0;
string strValueForValidation;
bool blnFatalError = false;
bool blnThereIsAProblem = false;
string strErrorMessage = "";
int intRecordsReturned;
int intRecordCounter;
bool blnRecordMatch;
PleaseWait PleaseWait = new PleaseWait();
PleaseWait.Show();
try
{
//data validation
strPartNumber = txtPartNumber.Text;
intPartID = Convert.ToInt32(txtPartID.Text);
if (strPartNumber == "")
{
blnFatalError = true;
strErrorMessage += "Part Number Was Not Entered\n";
}
strJDEPartNumber = txtJDEPartNumber.Text;
if (strJDEPartNumber == "")
{
blnFatalError = true;
strErrorMessage += "JDE Part Number Was Not Entered\n";
}
strDescription = txtDescription.Text;
if (strDescription == "")
{
blnFatalError = true;
strErrorMessage += "The Description Was Not Entered\n";
}
strValueForValidation = txtPrice.Text;
blnThereIsAProblem = TheDataValidationClass.VerifyDoubleData(strValueForValidation);
if (blnThereIsAProblem == true)
{
blnFatalError = true;
strErrorMessage += "The Price Entered in not Numeric\n";
}
else
{
douPrice = Convert.ToDouble(strValueForValidation);
}
if (blnFatalError == true)
{
PleaseWait.Close();
TheMessagesClass.ErrorMessage(strErrorMessage);
return;
}
//validation to see if the part number is used with another row
TheFindPartByPartNumberDataSet = ThePartNumberClass.FindPartByPartNumber(strPartNumber);
intRecordsReturned = TheFindPartByPartNumberDataSet.FindPartByPartNumber.Rows.Count;
if (intRecordsReturned > 0)
{
blnRecordMatch = false;
for (intRecordCounter = 0; intRecordCounter <= intRecordsReturned - 1; intRecordCounter++)
{
if (strPartNumber == TheFindPartByPartNumberDataSet.FindPartByPartNumber[intRecordCounter].PartNumber)
{
if (intPartID != TheFindPartByPartNumberDataSet.FindPartByPartNumber[intRecordCounter].PartID)
{
blnRecordMatch = true;
}
}
}
if (blnRecordMatch == true)
{
TheMessagesClass.ErrorMessage("Part Number Exists with a Different Part ID");
return;
}
}
if ((strJDEPartNumber != "NOT REQUIRED") && (strJDEPartNumber != "NOT PROVIDED"))
{
TheFindPartByJDEPartNumberDataSet = ThePartNumberClass.FindPartByJDEPartNumber(strJDEPartNumber);
intRecordsReturned = TheFindPartByJDEPartNumberDataSet.FindPartByJDEPartNumber.Rows.Count;
if (intRecordsReturned > 0)
{
blnRecordMatch = false;
for (intRecordCounter = 0; intRecordCounter <= intRecordsReturned - 1; intRecordCounter++)
{
if (strJDEPartNumber == TheFindPartByJDEPartNumberDataSet.FindPartByJDEPartNumber[intRecordCounter].JDEPartNumber)
{
if (intPartID != TheFindPartByJDEPartNumberDataSet.FindPartByJDEPartNumber[intRecordCounter].PartID)
{
blnRecordMatch = true;
}
}
}
if (blnRecordMatch == true)
{
TheMessagesClass.ErrorMessage("JDE Part Number Exists with a Different Part ID");
return;
}
}
}
//doing the loop
blnFatalError = ThePartNumberClass.UpdatePartInformation(intPartID, strJDEPartNumber, strDescription, true, float.Parse(txtPrice.Text));
if (blnFatalError == true)
{
throw new Exception();
}
TheMessagesClass.InformationMessage("The Part Has Been Updated");
ClearControls();
}
catch (Exception Ex)
{
TheEventLogClass.InsertEventLogEntry(DateTime.Now, "Blue Jay ERP // Edit Parts // Save Menu Item " + Ex.Message);
TheMessagesClass.ErrorMessage(Ex.ToString());
}
PleaseWait.Close();
}
