unit UnitAssessmentAndHomeworkEntry;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.Grids, Vcl.DBGrids,
  Vcl.ExtCtrls, IdMessage, IdTCPConnection, IdTCPClient,
  IdExplicitTLSClientServerBase, IdMessageClient, IdSMTPBase, IdSMTP,
  IdBaseComponent, IdComponent, IdIOHandler, IdIOHandlerSocket,
  IdIOHandlerStack, IdSSL, IdSSLOpenSSL, MmSystem;

type
  TfrmAssessmentAndHomeworkEntry = class(TForm)
    lblHomeworkAndAssessmentEntry: TLabel;
    ledtMaxMarkInput: TLabeledEdit;
    ledtAHWMarkAchieved: TLabeledEdit;
    btnCreateBoundary: TButton;
    btnSaveMark: TButton;
    dbgDisplayAssessmentHomeworkTables: TDBGrid;
    cboAHWSelectGroup: TComboBox;
    cboAHWName: TComboBox;
    gboSelectAStudent: TGroupBox;
    cboType: TComboBox;
    btnAHWBackToGroupProfiles: TButton;
    btnAHWSelectGroup: TButton;
    gboAHWSelectGroup: TGroupBox;
    GroupBox1: TGroupBox;
    ledtExamMarkAStar: TLabeledEdit;
    ledtExamMarkA: TLabeledEdit;
    ledtExamMarkB: TLabeledEdit;
    ledtExamMarkC: TLabeledEdit;
    ledtExamMarkD: TLabeledEdit;
    ledtExamMarkE: TLabeledEdit;
    ledtNewBoundaryAStar: TLabeledEdit;
    ledtNewBoundaryA: TLabeledEdit;
    ledtNewBoundaryB: TLabeledEdit;
    ledtNewBoundaryC: TLabeledEdit;
    ledtNewBoundaryD: TLabeledEdit;
    ledtNewBoundaryE: TLabeledEdit;
    gboExamBoardMarksBoundary: TGroupBox;
    GroupBox3: TGroupBox;
    btnSaveMarks: TButton;
    btnAlterMarks: TButton;
    ledtExamBMaxMark: TLabeledEdit;
    ledtNewMaxMark: TLabeledEdit;
    IdSSLIOHandlerSocketOpenSSL1: TIdSSLIOHandlerSocketOpenSSL;
    IdSMTP1: TIdSMTP;
    IdMessage1: TIdMessage;
    procedure FormShow(Sender: TObject);
    procedure btnAHWBackToGroupProfilesClick(Sender: TObject);
    procedure btnAHWSelectGroupClick(Sender: TObject);
    procedure btnAlterMarksClick(Sender: TObject);
    procedure btnSaveMarksClick(Sender: TObject);
    procedure btnCreateBoundaryClick(Sender: TObject);
    procedure btnSaveMarkClick(Sender: TObject);
    procedure ledtExamBMaxMarkKeyPress(Sender: TObject; var Key: Char);
    procedure ledtExamMarkAStarKeyPress(Sender: TObject; var Key: Char);
    procedure ledtExamMarkAKeyPress(Sender: TObject; var Key: Char);
    procedure ledtExamMarkBKeyPress(Sender: TObject; var Key: Char);
    procedure ledtExamMarkCKeyPress(Sender: TObject; var Key: Char);
    procedure ledtExamMarkDKeyPress(Sender: TObject; var Key: Char);
    procedure ledtExamMarkEKeyPress(Sender: TObject; var Key: Char);
    procedure ledtAHWMarkAchievedKeyPress(Sender: TObject; var Key: Char);
    procedure ledtMaxMarkInputKeyPress(Sender: TObject; var Key: Char);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  frmAssessmentAndHomeworkEntry: TfrmAssessmentAndHomeworkEntry;
  ExamMarksBoundaryFile : TextFile;
  ExamBMarksBoundary : array [0..7] of string;
  NewMarkBoundary : array [0..7,0..1] of string;

implementation

uses UnitdmDatabaseComponents, UnitGroupProfiles, UnitEmailDetails;

{$R *.dfm}

procedure ErrorOutputComboBox(ErrorMessage : string; Cbo : TComboBox);
begin
  {  ----------  Highlight the input with an error  ----------  }
  Cbo.Color := clRed;  // Turn the input into a red color
  Cbo.Font.Color := clWhite;  // Turn the text into the input to white
  PlaySound('SYSTEMEXCLAMATION', 0, SND_ASYNC);  //  Play error sound
  Showmessage(ErrorMessage);  //  Output an error message
  {  ----------  Remove the highlight  ----------}
  Cbo.Color := clWhite;  // Make the input white again
  Cbo.Font.Color := clBlack;  //  Make the font black again
end;

procedure ErrorOutputLabeledEdit(ErrorMessage : string; Ledt : TLabeledEdit);
begin
  {  ----------  Highlight the input with an error  ----------  }
  Ledt.Color := clRed;  // Turn the input into a red color
  ledt.Font.Color := clWhite;  // Turn the text into the input to white
  PlaySound('SYSTEMEXCLAMATION', 0, SND_ASYNC);  //  Play error sound
  Showmessage(ErrorMessage);  //  Output an error message
  {  ----------  Remove the highlight  ----------}
  Ledt.Color := clWhite;  // Make the input white again
  ledt.Font.Color := clBlack;  //  Make the font black again
end;

procedure CorrectKeyPressedNumerical(KeyIn : Char; Field : string);
begin
   if not (KeyIn in ['0'..'9', #8]) then // If a letter pressed
   begin
      PlaySound('SYSTEMEXCLAMATION', 0, SND_ASYNC);  //  Play error sound
      Showmessage('ERROR: '+Field+' must only be numerical');  // Produce an error message
      KeyIn := #0; // Remove the last character
   end; // end if
end;

procedure Gmail(username, password, totarget, subject, body: string);
var
  DATA: TIdMessage;
  SMTP: TIdSMTP;
  SSL: TIdSSLIOHandlerSocketOpenSSL;

begin

  SMTP := TIdSMTP.Create(nil);
  DATA := TIdMessage.Create(nil);
  SSL := TIdSSLIOHandlerSocketOpenSSL.Create(nil);

  SSL.SSLOptions.Method := sslvTLSv1;
  SSL.SSLOptions.Mode := sslmUnassigned;
  SSL.SSLOptions.VerifyMode := [];
  SSL.SSLOptions.VerifyDepth := 0;

  DATA.From.Address := username;
  DATA.Recipients.EMailAddresses := totarget;
  DATA.subject := subject;
  DATA.body.text := body;

  SMTP.IOHandler := SSL;
  SMTP.Host := 'smtp.gmail.com';
  SMTP.Port := 587;
  SMTP.username := username;
  SMTP.password := password;
  SMTP.UseTLS := utUseExplicitTLS;

  SMTP.Connect;
  SMTP.Send(DATA);
  SMTP.Disconnect;

  SMTP.Free;
  DATA.Free;
  SSL.Free;
end;

procedure EnableNewMarkBoundary();
begin
  with frmAssessmentAndHomeworkEntry do
  begin
  ledtNewMaxMark.Enabled:=True;
  ledtNewBoundaryAStar.Enabled:=True;
  ledtNewBoundaryA.Enabled:=True;
  ledtNewBoundaryB.Enabled:=True;
  ledtNewBoundaryC.Enabled:=True;
  ledtNewBoundaryD.Enabled:=True;
  ledtNewBoundaryE.Enabled:=True;
  end;
end;

procedure DisableNewMarkBoundary();
begin
  with frmAssessmentAndHomeworkEntry do
  begin
  ledtNewMaxMark.Enabled:=False;
  ledtNewBoundaryAStar.Enabled:=False;
  ledtNewBoundaryA.Enabled:=False;
  ledtNewBoundaryB.Enabled:=False;
  ledtNewBoundaryC.Enabled:=False;
  ledtNewBoundaryD.Enabled:=False;
  ledtNewBoundaryE.Enabled:=False;
  end;
end;

procedure EnableExamBMarksInput();
begin
  frmAssessmentAndHomeworkEntry.ledtExamBMaxMark.Enabled := True;
  frmAssessmentAndHomeworkEntry.ledtExamMarkAStar.Enabled := True;
  frmAssessmentAndHomeworkEntry.ledtExamMarkA.Enabled := True;
  frmAssessmentAndHomeworkEntry.ledtExamMarkB.Enabled := True;
  frmAssessmentAndHomeworkEntry.ledtExamMarkC.Enabled := True;
  frmAssessmentAndHomeworkEntry.ledtExamMarkD.Enabled := True;
  frmAssessmentAndHomeworkEntry.ledtExamMarkE.Enabled := True;
end;

procedure DisableExamBMarksInput();
begin
  frmAssessmentAndHomeworkEntry.ledtExamBMaxMark.Enabled := False;
  frmAssessmentAndHomeworkEntry.ledtExamMarkAStar.Enabled := False;
  frmAssessmentAndHomeworkEntry.ledtExamMarkA.Enabled := False;
  frmAssessmentAndHomeworkEntry.ledtExamMarkB.Enabled := False;
  frmAssessmentAndHomeworkEntry.ledtExamMarkC.Enabled := False;
  frmAssessmentAndHomeworkEntry.ledtExamMarkD.Enabled := False;
  frmAssessmentAndHomeworkEntry.ledtExamMarkE.Enabled := False;
end;

procedure TfrmAssessmentAndHomeworkEntry.btnAHWBackToGroupProfilesClick(Sender: TObject);
begin
  frmAssessmentAndHomeworkEntry.Hide;
  frmGroupProfile.Show;
end;

procedure TfrmAssessmentAndHomeworkEntry.btnAlterMarksClick(Sender: TObject);
begin
  {  ----------  Disable input of Exam UMS Boundary  ----------  }
  EnableExamBMarksInput;

  btnAlterMarks.Enabled := False;
  btnSaveMarks.Enabled := True;
end;

procedure TfrmAssessmentAndHomeworkEntry.btnCreateBoundaryClick(
  Sender: TObject);
var
  MarkMultiplier : Real;
  x, Calc: Integer;
begin
  {  ----------  Max Mark validation  ----------  }
  {  ----------  Presence Check  -----------}
  if ledtMaxMarkInput.Text = '' then
  begin
    ErrorOutputLabeledEdit('ERROR: Please enter a max mark', ledtMaxMarkInput);
  end
  else if (StrToInt(ledtMaxMarkInput.Text) > 140) OR (StrToInt(ledtMaxMarkInput.Text) < 0) then
  begin
    Showmessage('ERROR: Max mark is too big');
  end
  else
  begin
    // Allow data to be written to labeled edits of the new grade boundaries
    EnableNewMarkBoundary;

    // Calculate the multiplier
    MarkMultiplier := StrToInt(ledtMaxMarkINput.Text) / StrToInt(ledtExamBMaxMark.Text);

    // Save the max mark entered as the first data item of the new boundary
    NewMarkBoundary[0,1] := ledtMaxMarkINput.Text;

    { ----------  Calculate the new grade boundary  ---------- }
    for x := 1 to 7 do
    begin
      Calc := Round(MarkMultiplier * StrToInt(ExamBMarksBoundary[x]));
      NewMarkBoundary[x,1]:= IntToStr(Calc);
    end;

    // Make max mark entered by the user the new max mark
    ledtNewMaxMark.Text := ledtMaxMarkINput.Text;

    { ----------  Output the new calculated grade boundaries  ---------- }
    ledtNewBoundaryAStar.Text:= NewMarkBoundary[1,1];  // Output new mark for an A*
    ledtNewBoundaryA.Text:= NewMarkBoundary[2,1]; // Output new mark for an A
    ledtNewBoundaryB.Text:= NewMarkBoundary[3,1]; // Output new mark for a B
    ledtNewBoundaryC.Text:= NewMarkBoundary[4,1]; // Output new mark for a C
    ledtNewBoundaryD.Text:= NewMarkBoundary[5,1]; // Output new mark for a D
    ledtNewBoundaryE.Text:= NewMarkBoundary[6,1]; // Output new mark for an E

    { ----------  Set the UMS boundaries for the new grade boundary  ---------- }
    NewMarkBoundary[0,0]:='100';  // UMS for 100%
    NewMarkBoundary[1,0]:='90';  // UMS for an A*
    NewMarkBoundary[2,0]:='80';  // UMS for an A
    NewMarkBoundary[3,0]:='70';  // UMS for a B
    NewMarkBoundary[4,0]:='60';  // UMS for a C
    NewMarkBoundary[5,0]:='50';  // UMS for a D
    NewMarkBoundary[6,0]:='40';  // UMS for an E
    NewMarkBoundary[7,0]:='0';  // UMS for 0 marks

    // Prevent the user from altering the newboundary
    DisableNewMarkBoundary;
  end;

end;

procedure CalcCurrentGrade(HWAssess,  Group, StudentID, HWAssessName, HWAssessMark, HWAssessMaxMark, HWAssessUMS : string; NewAverageUMS: integer);
var
  // Email variables
  EmailSenderUsername, EmailSenderPassword, EmailRecipient, EmailSubject, EmailBody : string;
  AutomatedEmailTextFile : TextFile;
  AutomatedEmailRead : string;
  // Database variables
  CurrentGrade, s, GradeProgression : String;
  CurrentGradeChar, TargetGradeChar : Char;
  Average : Integer;
  PrevOnAlert : Boolean;
begin
  with dmDatabaseComponents.adoUnitHWAndAssesstEntry do
  begin
    { -----------  Refresh the DBGrid  ---------- }
    Close;
    SQL.Clear;  //  Initialize the SQL
    //  Set the SQL
    SQL.Text:='SELECT * FROM ['+HWAssess+Group+'] WHERE StudentID = '+StudentID;
    ExecSQL;  //  Execute the SQL
    Open;
    {  ----------  Traverse through the table  ----------  }
    if FieldByName('AverageUMS%').Value = Null then
    begin
      Average := NewAverageUMS;
    end
    else
    begin
      {  ---  Need to refreshh table here --- }
      Average := Round((FieldByName('AverageUMS%').AsInteger + NewAverageUMS)/2);
    end;
  end;

  {  ----------  Convert the HW and Assessment Average to a grade  ----------  }
  case Average of
    90..100 : CurrentGrade := 'A*';  // Average UMS between 90-100 then average is A*
    80..89 : CurrentGrade := 'A';  // Average UMS between 80-89 then average is A
    70..79 : CurrentGrade := 'B';  // Average UMS between 70-79 then average is B
    60..69 : CurrentGrade := 'C';  // Average UMS between 60-69 then average is C
    50..59 : CurrentGrade := 'D';  // Average UMS between 50-59 then average is D
    40..49 : CurrentGrade := 'E';  // Average UMS between 40-49 then average is E
     0..39 : CurrentGrade := 'U';  // Average UMS between  0-39 then average is U
  end;

  {  ----------  Update Student's Current Grade  ----------  }
  with dmDatabaseComponents.adoUnitHWAndAssesstEntry do
  begin
    Close;
    SQL.Clear;  //  Initialize the SQL
    //  Set the SQL
    SQL.Text:='UPDATE [StudentDetails] SET [CurrentGrade] = '+QuotedStr(CurrentGrade)+' WHERE StudentNumber ='+StudentID;
    ExecSQL;  //  Execute the SQL
  end;

  with dmDatabaseComponents.adoUnitHWAndAssesstEntry do
  begin
    {  ----------  Use group to find the student  ----------  }
    Close;
    SQL.Clear;  //  Initialize the SQL
    //  Set the SQL
    SQL.Text:='SELECT * FROM [StudentDetails] WHERE GroupName = '+QuotedStr(Group);
    ExecSQL;  //  Execute the SQL
    Open;

    {  ----------  Previously on Alert  ----------  }
    if FieldByName('Progression').AsString = 'Below' then
    begin
      PrevOnAlert := True;
    end;


    {  ----------  Traverse through the table  ----------  }
    First;
    while not EoF do
    begin
      if FieldByName('StudentNumber').Value = frmAssessmentAndHomeworkEntry.dbgDisplayAssessmentHomeworkTables.DataSource.DataSet.FieldByName('StudentID').AsInteger then
      begin
        //  if the current grade is less then the target grade then...
        if FieldByName('CurrentGrade').AsString < FieldByName('TargetGrade').AsString then
        //  do this
        begin
          GradeProgression := 'Below';
        end  // end of if statement
        //  if the current grade is less then the target grade then...
        else if FieldByName('CurrentGrade').AsString = FieldByName('TargetGrade').AsString then
        //  do this
        begin
          GradeProgression := 'In Line';
        end  // end of else if statement
        //  if the current grade eqauls target grade then...
        else
        //  do this
        begin
          GradeProgression := 'Above';
        end;  // end of else statement
        Break;  // End the while and move on
      end
      else // if they are not the same
      Next;  // move on to the next record
    end;
  end;

  with dmDatabaseComponents.adoUnitHWAndAssesstEntry do
  begin
    Close;
    SQL.Clear;
    SQL.Text:='UPDATE StudentDetails SET Progression = '+QuotedStr(GradeProgression)+' WHERE StudentNumber = '+StudentID;
    ExecSQL;
  end;

  if GradeProgression = 'Below' then
  begin
    if PrevOnAlert = False then
    begin
      EmailSubject := 'You are currently on Alert';
      // Initialize the email body
      EmailBody := '';
      {  ----------  Read from Automated Email Textfile  ----------  }
      AssignFile(AutomatedEmailTextFile, 'AutomatedEmail.txt');
      Reset(AutomatedEmailTextFile);
      while not Eof(AutomatedEmailTextFile) do
      begin
        Readln(AutomatedEmailTextFile, AutomatedEmailRead);
        EmailBody := EmailBody + sLineBreak + AutomatedEmailRead;
      end;
      Closefile(AutomatedEmailTextFile);
    end
    else
    begin
      EmailSubject := '';
      // Initialize the email body
      EmailSubject := 'You still currently on Alert';

      {  ----------  Read from Automated Email Textfile  ----------  }
      AssignFile(AutomatedEmailTextFile, 'AutomatedEmailPrevOnAlert.txt');
      Reset(AutomatedEmailTextFile);
      while not Eof(AutomatedEmailTextFile) do
      begin
        Readln(AutomatedEmailTextFile, AutomatedEmailRead);
        EmailBody := EmailBody + sLineBreak +  AutomatedEmailRead;
      end;
      Closefile(AutomatedEmailTextFile);
    end;

    EmailBody := EmailBody+sLineBreak+sLineBreak+'Your last socre:';

    EmailBody := EmailBody+sLineBreak+sLineBreak+HWAssessName+': '+HWAssessMark+'/'+HWAssessMaxMark+' ('+HWAssessUMS+' UMS)';

    frmEmailDetails.ledtEmailAddress.Enabled := True;
    frmEmailDetails.ledtPassword.Enabled := True;

    with dmDatabaseComponents.adoUnitHWAndAssesstEntry do
      begin
        Close;
        SQL.Clear;
        SQL.Text:='SELECT StudentEmail FROM StudentDetails WHERE StudentNumber = '+StudentID;
        ExecSQL;
      Open;
    end;

    // Set the varialbes
    EmailSenderUsername := frmEmailDetails.ledtEmailAddress.Text;
    EmailSenderPassword := frmEmailDetails.ledtPassword.Text;
    EmailRecipient := dmDatabaseComponents.adoUnitHWAndAssesstEntry.FieldByName('StudentEmail').AsString;

    try
      Gmail(EmailSenderUsername, EmailSenderPassword, EmailRecipient, EmailSubject, EmailBody);
    except
    end;
  end;

end;

procedure TfrmAssessmentAndHomeworkEntry.btnSaveMarkClick(Sender: TObject);
var
  //  Count variables
  x, i : integer;
  MarkMin, UMSMin, ChangeInMarkBoundary, ChangeInUMSBoundary,  UMSValue : Integer;
  // Current grade variables
  AverageUMS : integer;
  SumUMS : integer;
  AverageUMSStr, GroupSelected, StudentNumber : string;
  // Query variables
  AssessOrHW, GroupName, AssessOrHwName : string;
  // Error output variables
  ErrorMessagePram : string;
begin
  //
  ledtNewBoundaryAStar.Enabled := True;
  {  ----------  Mark Achieved Validation  ----------  }
  {  ----------  Presence Check  ----------  }
  if ledtAHWMarkAchieved.Text = '' then
  begin
   Showmessage('ERROR: Please enter a mark achieved');
   // ErrorOutputLabeledEdit('ERROR: Please enter a mark achieved', ledtAHWMarkAchieved);
  end
  {  ----------  Range Check  ----------   }
  else if (StrToInt(ledtAHWMarkAchieved.Text) > 140) OR (StrToInt(ledtAHWMarkAchieved.Text) < 0) then
  begin
    Showmessage('ERROR: Mark achieved is out of range');
  end
  {  ----------  Homework/Assessment Name Validation  ----------  }
  {  ----------  Presence Check  ----------  }
  else if cboAHWName.Text = '' then
  begin
    ErrorOutputComboBox('ERROR: Please select a homework or assessment', cboAHWName);
  end
  {  ----------  Boundary Validation  ----------  }
  {  ----------  Presence Check  ----------  }
  else if ledtNewBoundaryAStar.Text = '' then
  begin
    PlaySound('SYSTEMEXCLAMATION', 0, SND_ASYNC);  //  Play error sound
    Showmessage('ERROR: Please create a boundary first');  // Output error message
    ledtNewBoundaryAStar.Enabled := False;
  end
  {  ----------  Error prevention  ----------  }
  else if StrToInt(ledtAHWMarkAchieved.Text) > StrToInt(ledtMaxMarkInput.Text) then
  begin
    ErrorMessagePram := '';
    ErrorMessagePram := 'ERROR: Mark achieved cannot be greater than the max mark';
    ErrorOutputLabeledEdit(ErrorMessagePram, ledtAHWMarkAchieved)
  end
  else
  begin
    {}
    StudentNumber := dbgDisplayAssessmentHomeworkTables.DataSource.DataSet.FieldByName('StudentID').AsString;
    AssessOrHW := cboType.Items[cboType.ItemIndex];
    GroupName := cboAHWSelectGroup.Items[cboAHWSelectGroup.ItemIndex];
    AssessOrHwName := cboAHWName.Items[cboAHWName.ItemIndex];

    EnableNewMarkBoundary;
    // If the student got mull marks
    if ledtAHWMarkAchieved.Text = ledtMaxMarkInput.Text then
    begin
      // Set the UMS to 100
      UMSValue := 100;
    end  //  End if statement
    else
    begin
      {  ----------  Convert Mark to UMS  ----------  }
      for x := 0 to 6 do
      begin
        {Boundaries are real not integer}
        if (StrToInt(ledtAHWMarkAchieved.Text) < StrToInt(NewMarkBoundary[x,1])) AND (StrToInt(ledtAHWMarkAchieved.Text) >= StrToInt(NewMarkBoundary[x+1,1])) then
        begin
          MarkMin := StrToInt(NewMarkBoundary[x+1,1]);
          UMSMin := StrToInt(NewMarkBoundary[x+1,0]);
          ChangeInMarkBoundary := StrToInt(NewMarkBoundary[x,1]) - StrToInt(NewMarkBoundary[x+1,1]);
          ChangeInUMSBoundary := StrToInt(NewMarkBoundary[x,0]) - StrToInt(NewMarkBoundary[x+1,0]);
          Break;  // Once the data has been calculated, break way from the loop
        end;  //  End if statement
      end; //  End of for loop

      UMSValue := Round((((ChangeInUMSBoundary/ChangeInMarkBoundary)*(StrToInt(ledtAHWMarkAchieved.Text)-MarkMin))+UMSMin));
    end;  //  End of else statement

    {  ----------  Insert Mark Into the database  ----------  }
    with dmdatabaseComponents.adoUnitHWAndAssesstEntry do
    begin
      Close;
      SQL.Clear;  // Initialize SQL
      // Set the SQL
      SQL.Text:='UPDATE ['+AssessOrHW+GroupName+'] SET ['+AssessOrHwName+'] = '+IntToStr(UMSValue)+' WHERE StudentID = '+StudentNumber;
      ExecSQL; // Execute the query
    end;

    {  ----------  Calculate the average UMS  ----------  }
    with dmDatabaseComponents.adoUnitHWAndAssesstEntry do
    begin
      Close;
      SQL.Clear;  //  Initialize
      //  Set the SQL
      SQL.Text := 'SELECT * FROM ['+AssessOrHW+GroupName+'] WHERE StudentID = '+QuotedStr(StudentNumber);
      Open;
        //  Loop through all the columns
        for i := 3 to FieldCount-1 do
        begin
          // Find the sum of all UMS marks
          SumUMS := SumUMS + Fields[i].Value;
        end;
        Showmessage('This is Sum UMS '+IntToStr(SumUMS));
        // Calculate the average of the UMS Marks
        AverageUMS := Round((SumUMS / (FieldCount - 3)));
    end;

    {  ----------  Update the AverageUMS% for the student  ----------  }
    with dmdatabaseComponents.adoUnitHWAndAssesstEntry do
    begin
      Close;
      SQL.Clear;  // Initialize SQL
      // Set the SQL
      SQL.Text:='UPDATE ['+AssessOrHW+GroupName+'] SET [AverageUMS%] = '+IntToStr(AverageUMS)+' WHERE StudentID = '+StudentNumber;
      ExecSQL;  // Execute query
    end;

    GroupSelected := cboAHWSelectGroup.Items[cboAHWSelectGroup.ItemIndex];

    if cboType.Items[cboType.ItemIndex] = 'ASSESSMENT' then
    begin
      CalcCurrentGrade('HOMEWORK', GroupName, StudentNumber, AssessOrHWName, ledtAHWMarkAchieved.Text, ledtMaxMarkInput.Text, IntToStr(UMSValue), AverageUMS);
    end
    else
    begin
      CalcCurrentGrade('ASSESSMENT', GroupName, StudentNumber, AssessOrHWName, ledtAHWMarkAchieved.Text, ledtMaxMarkInput.Text, IntToStr(UMSValue), AverageUMS);
    end;

    //  Once the entire procedure has been completed disable the inputs to stop the user from altering th grade boundaries
    DisableNewMarkBoundary;

    // Clear the mark input
  ledtAHWMarkAchieved.Text := '';

  end;
end;

procedure TfrmAssessmentAndHomeworkEntry.btnSaveMarksClick(Sender: TObject);
var
  x : integer;
  i : integer;
  GradeBoundaryValid : Boolean;
begin

  //  Save values to the correct array items
  ExamBMarksBoundary[0]:=ledtExamBMaxMark.Text;  // Save max mark
  ExamBMarksBoundary[1]:=ledtExamMarkAStar.Text;  // Save mark for A*
  ExamBMarksBoundary[2]:=ledtExamMarkA.Text;  // Save mark for A
  ExamBMarksBoundary[3]:=ledtExamMarkB.Text;  // Save mark for B
  ExamBMarksBoundary[4]:=ledtExamMarkC.Text;  // Save mark for C
  ExamBMarksBoundary[5]:=ledtExamMarkD.Text;  // Save mark for D
  ExamBMarksBoundary[6]:=ledtExamMarkE.Text;  // Save mark for E
  ExamBMarksBoundary[7]:='0';  //  Save the zero mark

  for i := 0 to 5 do
  begin
    if (ExamBMarksBoundary[i] < ExamBMarksBoundary[i+1]) OR (ExamBMarksBoundary[i] = '0') OR (ExamBMarksBoundary[i+1] = '0') then
    begin
      Showmessage('Please enter a real set of grade boundaries');
      GradeBoundaryValid := True;
    end
  end;

  if GradeBoundaryValid = False then
  begin
    {  ----------  Save the exam grade boundaries  ----------  }
    AssignFile(ExamMarksBoundaryFile,'ExamMarkBoundary.txt');
    //  Delete the existing file
    DeleteFile('ExamMarkBoundary.txt');
    // Open the file for write access
    Rewrite(ExamMarksBoundaryFile);
    //  Go through each data item of the array
    for x := 0 to 7 do
    begin
      // Write the file the contents of the data item at index x
      Writeln(ExamMarksBoundaryFile, ExamBMarksBoundary[x]);
    end;
    // Once saved close the file
    CloseFile(ExamMarksBoundaryFile);

    // Prevent the user from pressing the save button again
    btnSaveMarks.Enabled:=False;
    // Allow the user to change marks as soon as current boundaries are saved
    btnAlterMarks.Enabled:=True;
    // Disable the inputs of the exam grade boundaries
    DisableExamBMarksInput;

    Showmessage('The grade boundaries were successully saved');

  end;
end;

procedure TfrmAssessmentAndHomeworkEntry.btnAHWSelectGroupClick(Sender: TObject);
var
  x : integer;
begin
  if cboAHWSelectGroup.Text = '' then
  begin
    ErrorOutputComboBox('ERROR: Please select a group', cboAHWSelectGroup);
  end
  else if cboType.Text ='' then
  begin
    ErrorOutputComboBox('ERROR: Please select a type', cboType);
  end
  else
  begin
    with dmDatabaseComponents.adoAHWDisplayAssessmentHomework do
    begin
      Close;
      SQL.Text:='SELECT * FROM ['+cboType.Items[cboType.ItemIndex]+cboAHWSelectGroup.Items[cboAHWSelectGroup.ItemIndex]+']';
      ExecSQL;
      Open;
    end;

    with dbgDisplayAssessmentHomeworkTables do
    begin
      cboAHWName.Clear;
      for x := 3 to FieldCount - 1 do
      cboAHWName.Items.Add(Columns[x].Title.Caption);
    end;

    cboAHWName.Enabled := True;
    cboAHWName.Enabled := True;
    ledtAHWMarkAchieved.Enabled :=  True;
    btnSaveMark.Enabled := True;
  end;
end;

procedure TfrmAssessmentAndHomeworkEntry.FormShow(Sender: TObject);
var
  x : integer;
begin
   { ----------  Add latest group anmes to the combo box  ---------- }
  cboAHWSelectGroup.Clear; // Initialize the contents of the combo box

  with dmDatabaseComponents.adoAHWDisplayGroupNames do
  begin
    First;  // Start at first record
    while not EoF do
    begin
       cboAHWSelectGroup.Items.Add(FieldByName('GroupName').AsString);  // Read the GroupNames record only
       Next;  // Next Record
    end; // End While
  end;

  {  ----------  Diplay Saved UMS  ----------  }
  AssignFile(ExamMarksBoundaryFile,'ExamMarkBoundary.txt');
  Reset(ExamMarksBoundaryFile);
  x:=0;
  while not Eof(ExamMarksBoundaryFile) do
  begin
    Readln(ExamMarksBoundaryFile, ExamBMarksBoundary[x]);
    x := x + 1;
  end;
  CloseFile(ExamMarksBoundaryFile);

  {  ----------  Output the UMS values  ----------  }
  ledtExamBMaxMark.Text:=ExamBMarksBoundary[0];
  ledtExamMarkAStar.Text:=ExamBMarksBoundary[1];  // Output UMS boundary for A*
  ledtExamMarkA.Text:=ExamBMarksBoundary[2];  // Output UMS boundary for A
  ledtExamMarkB.Text:=ExamBMarksBoundary[3];  // Output UMS boundary for B
  ledtExamMarkC.Text:=ExamBMarksBoundary[4];  // Output UMS boundary for C
  ledtExamMarkD.Text:=ExamBMarksBoundary[5];  // Output UMS boundary for D
  ledtExamMarkE.Text:=ExamBMarksBoundary[6];  // Output UMS boundary for E

  {  ----------  Disable input of Exam Mark Boundary and New Mark Boundary  ----------  }
  DisableNewMarkBoundary;
  DisableExamBMarksInput;
end;

procedure TfrmAssessmentAndHomeworkEntry.ledtAHWMarkAchievedKeyPress(
  Sender: TObject; var Key: Char);
begin
  CorrectKeyPressedNumerical(Key, 'Mark achieved');
end;

procedure TfrmAssessmentAndHomeworkEntry.ledtExamBMaxMarkKeyPress(
  Sender: TObject; var Key: Char);
begin
  CorrectKeyPressedNumerical(Key, 'Exam board max mark');
end;

procedure TfrmAssessmentAndHomeworkEntry.ledtExamMarkAKeyPress(Sender: TObject;
  var Key: Char);
begin
  CorrectKeyPressedNumerical(Key, 'A grade boundary');
end;

procedure TfrmAssessmentAndHomeworkEntry.ledtExamMarkAStarKeyPress(
  Sender: TObject; var Key: Char);
begin
  CorrectKeyPressedNumerical(Key, 'A grade boundary');
end;

procedure TfrmAssessmentAndHomeworkEntry.ledtExamMarkBKeyPress(Sender: TObject;
  var Key: Char);
begin
  CorrectKeyPressedNumerical(Key, 'A grade boundary');
end;

procedure TfrmAssessmentAndHomeworkEntry.ledtExamMarkCKeyPress(Sender: TObject;
  var Key: Char);
begin
  CorrectKeyPressedNumerical(Key, 'A grade boundary');
end;

procedure TfrmAssessmentAndHomeworkEntry.ledtExamMarkDKeyPress(Sender: TObject;
  var Key: Char);
begin
  CorrectKeyPressedNumerical(Key, 'A grade boundary');
end;

procedure TfrmAssessmentAndHomeworkEntry.ledtExamMarkEKeyPress(Sender: TObject;
  var Key: Char);
begin
  CorrectKeyPressedNumerical(Key, 'A grade boundary');
end;

procedure TfrmAssessmentAndHomeworkEntry.ledtMaxMarkInputKeyPress(
  Sender: TObject; var Key: Char);
begin
  CorrectKeyPressedNumerical(Key, 'Max mark');
end;

end.