public void ConstructorWithAllParamTestInvalidDOHBeforeDOB()
 {
     DateTime DOB = new DateTime(2003, 12, 12);
     DateTime DOH = new DateTime(2001, 01, 29);
     DateTime DOT = new DateTime(2006, 05, 21);
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 230000);
 }
        public FulltimeEmployee(FulltimeEmployee prev)
            : base(prev)
        {
            dateOfHire        = prev.GetDateOfHire();
            dateOfTermination = prev.GetDateOfTermination();
            salary            = prev.GetSalary();

            SetType("FT");
        }
 /// <summary>
 /// Add a new employee type, given a set of information the method will decide which employee type is requested to be created and to provide the 
 /// information in creating that specific employee type 
 /// </summary>
 /// <param name="record">Contains a set of information regarding which employee type to create and what information it should contain</param>
 /// <returns></returns>
 public void Add(object record)
 {
     if (((string)record)[0] != ';')
     {
         try
         {
             string[] recordStr = ((string)record).Split('|');
             Employee newEmployee = null;
             switch (recordStr[0].ToUpper())
             {
                 case "FT":
                     newEmployee = new FulltimeEmployee(recordStr);
                     break;
                 case "PT":
                     newEmployee = new ParttimeEmployee(recordStr); //PARAM Needs to be changed, temp fix
                     break;
                 case "CT":
                     newEmployee = new ContractEmployee(recordStr); //PARAM Needs to be changed, temp fix
                     break;
                 case "SN":
                     newEmployee = new SeasonalEmployee(recordStr); //PARAM Needs to be changed, temp fix
                     break;
                 default:
                     break;
             }
             if (newEmployee != null)
             {
                 if (newEmployee.IsValid)
                 {
                     //Exist by sin
                     if (!employeeSinExist(newEmployee))
                     {
                         employees.Add(newEmployee);
                     }
                     else
                     {
                         Logging.LogString("Tried adding employee but the SIN/BN matched another record.");
                         throw new ArgumentException("That Sin Already Exists");
                     }
                 }
                 else
                 {
                     //Employee is not valid dont add Needs LOG
                 }
             }
         }
         catch (MissingMemberException mME)
         {
             //throw mME;
         }
         catch (ArgumentException aE)
         {
             throw aE;
         }
     }
 }
        public void SetDateOfHireDateTestInvalidDOHbeforeDOB()
        {
            DateTime DOB = new DateTime(1985, 08, 20);
            DateTime DOH = new DateTime(1994, 09, 03);
            DateTime DOT = new DateTime(2000, 03, 23);
            FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 230000);
            bool retVal = employee.SetDateOfHire("1980-12-24");
            Assert.IsFalse(retVal);

            int compReturn = DateTime.Compare(employee.GetDateOfHire(), DOH);
            Assert.AreEqual(0, compReturn);
        }
        public void SetDateOfBirthStringTestValidString()
        {
            FulltimeEmployee employee = new FulltimeEmployee();
            bool retVal = employee.SetDateOfBirth("1993-04-24");
            Assert.IsTrue(retVal);

            DateTime date = new DateTime(1993, 04, 24);
            int compReturn = DateTime.Compare(employee.GetDateOfBirth(), date);
            Assert.AreEqual(0, compReturn);
        }
        public void SetDateOfBirthStringTestInvalidDOBafterDOH()
        {
            DateTime DOB = new DateTime(1954, 08, 20);
            DateTime DOH = new DateTime(1994, 09, 03);
            DateTime DOT = new DateTime();
            FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 230000);
            bool retVal = employee.SetDateOfBirth("2001-12-24");
            Assert.IsFalse(retVal);

            int compReturn = DateTime.Compare(employee.GetDateOfBirth(), DOB);
            Assert.AreEqual(0, compReturn);
        }
 public void DetailsTestValid()
 {
     DateTime DOB = new DateTime(1954, 08, 20);
     DateTime DOH = new DateTime(1994, 09, 03);
     DateTime DOT = new DateTime(2014, 12, 23);
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 230000);
     String details = employee.Details();
     Assert.IsTrue(details == "Employee Type: FullTime\nName: Brandon Davies\nSocial Insurance Number: 123 456 789\nDate of Birth: 1954-08-20\nDate of Hire: 1994-09-03\nDate of Termination: 2014-12-23\nSalary: 230000");
 }
 public void ConstructorWithNamesTestInvalidSpace()
 {
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Mc Davies");
 }
 public void ConstructorWithAllParamTestValid3()
 {
     DateTime DOB = new DateTime(1984, 12, 23);
     DateTime DOH = new DateTime(1994, 11, 03);
     DateTime DOT = new DateTime();
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 230000);
 }
        public void SetDateOfHireIntsTestValid()
        {
            FulltimeEmployee employee = new FulltimeEmployee();
            bool retVal = employee.SetDateOfHire(1993, 04, 24);
            Assert.IsTrue(retVal);

            DateTime date = new DateTime(1993, 04, 24);
            int compReturn = DateTime.Compare(employee.GetDateOfHire(), date);
            Assert.AreEqual(0, compReturn);
        }
Exemple #11
0
        /**
        * \brief given string from file, pars all data into list, return list valid employees
        *
        * \details <b>Details</b>
        *
        * \param fileText - <b>string</b> - The string of data containing an employees records
        *
        * \return  employeeRec - <b>List<AllEmployees.Employee></b> - The list of all the employee records in the strinng of data
        */
        private static List<AllEmployees.Employee> ParsRecord(String fileText)
        {
            List<AllEmployees.Employee> employeeRec = new List<AllEmployees.Employee>();
            //tostringbase string employeeString = firstName + "|" + lastName + "|" + SocialInsuranceNumber + "|" + DateOfBirth.Year + "-" + DateOfBirth.Month + "-" + DateOfBirth.Day + "|";
            char[] delimiterChars = { '|', '\n'};
            string[] words = fileText.Split(delimiterChars);
            int wordCounter = 0;
            while (wordCounter < words.Count() - 1)
            {
                if (words[wordCounter] == "CT")
                {
                    bool isValid = true;
                    if (words.Length > (wordCounter + 7))
                    {
                        //AllEmployees.ContractEmployee contractEmp = new AllEmployees.ContractEmployee(words[wordCounter], words[wordCounter+1], Convert.ToInt32(words[wordCounter+2]), words[wordCounter+3], words[wordCounter+4], words[wordCounter+5], Convert.ToDouble(words[wordCounter+6]));
                        try
                        {
                            AllEmployees.ContractEmployee contractEmp = new AllEmployees.ContractEmployee();
                            contractEmp.SetEmployeeType(words[wordCounter]);
                            wordCounter++;
                            contractEmp.SetLastName(words[wordCounter]);
                            wordCounter++;
                            wordCounter++;
                            contractEmp.SetSocialInsuranceNumber(Convert.ToInt32(words[wordCounter]));//only take an int
                            wordCounter++;
                            contractEmp.SetDateOfBirth(words[wordCounter]);
                            wordCounter++;

                            contractEmp.SetContractStartDate(words[wordCounter]);
                            wordCounter++;
                            isValid = contractEmp.SetContractStopDate(words[wordCounter]);
                            if (words[wordCounter] == "")
                            {
                                isValid = true;
                            }
                            wordCounter++;
                            contractEmp.SetFixedContractAmount(Convert.ToDouble(words[wordCounter]));
                            wordCounter++;

                            if (contractEmp.Validate() == true && isValid == true)
                            {
                                employeeRec.Add(contractEmp);
                                Logging.Log("FileIO", "ParsRecord", "contract employee added");
                                wordCounter++;
                            }
                            else
                            {
                                Logging.Log("FileIO", "ParsRecord", "invalid employee data for a contract employee");
                                while (words[wordCounter] != "FT" && words[wordCounter] != "PT" && words[wordCounter] != "SN" && words[wordCounter] != "CT" && wordCounter < words.Count() - 1)
                                {
                                    wordCounter++;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Logging.Log("FileIO", "ParsRecord", "invalid employee data for a contract employee - Error Message: " + ex.Message);
                            while (words[wordCounter] != "FT" && words[wordCounter] != "PT" && words[wordCounter] != "SN" && words[wordCounter] != "CT" && wordCounter < words.Count() - 1)
                            {
                                wordCounter++;
                            }
                        }
                    }
                    else
                    {
                        Logging.Log("FileIO", "ParsRecord", "Not enough employee data for a contract employee");
                        break;
                    }
                }
                else if (words[wordCounter] == "FT")
                {
                    bool isValid = true;
                    if (words.Length > (wordCounter + 7))
                    {
                        AllEmployees.FulltimeEmployee fullTimeEmp = new AllEmployees.FulltimeEmployee();

                        try
                        {
                            fullTimeEmp.SetEmployeeType(words[wordCounter]);
                            wordCounter++;
                            fullTimeEmp.SetLastName(words[wordCounter]);
                            wordCounter++;
                            fullTimeEmp.SetFirstName(words[wordCounter]);
                            wordCounter++;
                            fullTimeEmp.SetSocialInsuranceNumber(Convert.ToInt32(words[wordCounter]));//only takes an int
                            wordCounter++;
                            fullTimeEmp.SetDateOfBirth(words[wordCounter]);
                            wordCounter++;

                            fullTimeEmp.SetDateOfHire(words[wordCounter]);
                            wordCounter++;
                            isValid = fullTimeEmp.SetDateOfTermination(words[wordCounter]);
                            if (words[wordCounter] == "")
                            {
                                isValid = true;
                            }
                            wordCounter++;
                            fullTimeEmp.SetSalary(Convert.ToDouble(words[wordCounter]));//only takes a float
                            wordCounter++;

                            if (fullTimeEmp.Validate() == true && isValid == true)
                            {
                                wordCounter++;
                                employeeRec.Add(fullTimeEmp);
                                Logging.Log("FileIO", "ParsRecord", "full time employee added");
                            }
                            else
                            {
                                Logging.Log("FileIO", "ParsRecord", "invalid employee data for a full time employee");
                                while (words[wordCounter] != "FT" && words[wordCounter] != "PT" && words[wordCounter] != "SN" && words[wordCounter] != "CT" && wordCounter < words.Count() - 1)
                                {
                                    wordCounter++;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Logging.Log("FileIO", "ParsRecord", "invalid employee data for a full time employee - Error Message: " + ex.Message);
                            while (words[wordCounter] != "FT" && words[wordCounter] != "PT" && words[wordCounter] != "SN" && words[wordCounter] != "CT" && wordCounter < words.Count() - 1)
                            {
                                wordCounter++;
                            }
                        }
                    }

                    else
                    {
                        Logging.Log("FileIO", "ParsRecord", "Not enough employee data for a full time employee");
                        break;
                    }
                }
                else if (words[wordCounter] == "PT")
                {
                    if (words.Length > (wordCounter + 7))
                    {
                        bool isValid = true;
                        AllEmployees.ParttimeEmployee partTimeEmp = new AllEmployees.ParttimeEmployee();

                        try
                        {
                            partTimeEmp.SetEmployeeType(words[wordCounter]);
                            wordCounter++;
                            partTimeEmp.SetLastName(words[wordCounter]);
                            wordCounter++;
                            partTimeEmp.SetFirstName(words[wordCounter]);
                            wordCounter++;
                            partTimeEmp.SetSocialInsuranceNumber(Convert.ToInt32(words[wordCounter]));//only takes an int
                            wordCounter++;
                            partTimeEmp.SetDateOfBirth(words[wordCounter]);
                            wordCounter++;

                            partTimeEmp.SetDateOfHire(words[wordCounter]);
                            wordCounter++;
                            isValid = partTimeEmp.SetDateOfTermination(words[wordCounter]);
                            if (words[wordCounter] == "")
                            {
                                isValid = true;
                            }
                            wordCounter++;
                            partTimeEmp.SetHourlyRate(Convert.ToDouble(words[wordCounter]));//only takes a float
                            wordCounter++;

                            if (partTimeEmp.Validate() == true && isValid == true)
                            {
                                wordCounter++;
                                employeeRec.Add(partTimeEmp);
                                Logging.Log("FileIO", "ParsRecord", "part time employee added");
                            }
                            else
                            {
                                Logging.Log("FileIO", "ParsRecord", "invalid employee data for a part time employee");
                                while (words[wordCounter] != "FT" && words[wordCounter] != "PT" && words[wordCounter] != "SN" && words[wordCounter] != "CT" && wordCounter < words.Count() - 1)
                                {
                                    wordCounter++;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Logging.Log("FileIO", "ParsRecord", "invalid employee data for a part time employee - Error Message: " + ex.Message);
                            while (words[wordCounter] != "FT" && words[wordCounter] != "PT" && words[wordCounter] != "SN" && words[wordCounter] != "CT" && wordCounter < words.Count() - 1)
                            {
                                wordCounter++;
                            }
                        }
                    }
                    else
                    {
                        Logging.Log("FileIO", "ParsRecord", "Not enough employee data for a part time employee");
                        break;
                    }
                }
                else if (words[wordCounter] == "SN")
                {
                    if (words.Length > (wordCounter + 6))
                    {
                        AllEmployees.SeasonalEmployee seasonalEmp = new AllEmployees.SeasonalEmployee();

                        try
                        {
                            seasonalEmp.SetEmployeeType(words[wordCounter]);
                            wordCounter++;
                            seasonalEmp.SetLastName(words[wordCounter]);
                            wordCounter++;
                            seasonalEmp.SetFirstName(words[wordCounter]);
                            wordCounter++;
                            seasonalEmp.SetSocialInsuranceNumber(Convert.ToInt32(words[wordCounter]));//only takes an int
                            wordCounter++;
                            Logging.Log("FileIO", "ParsRecord", "SN Birthday: " + words[wordCounter]);
                            seasonalEmp.SetDateOfBirth(words[wordCounter]);
                            wordCounter++;
                            Logging.Log("FileIO", "ParsRecord", "SN Season: " + words[wordCounter]);
                            seasonalEmp.SetSeason(words[wordCounter]);
                            wordCounter++;
                            Logging.Log("FileIO", "ParsRecord", "SN PiecePay: " + words[wordCounter]);
                            seasonalEmp.SetPiecePay(Convert.ToDouble(words[wordCounter]));//only takes a float
                            wordCounter++;

                            if (seasonalEmp.Validate() == true)
                            {
                                wordCounter++;
                                employeeRec.Add(seasonalEmp);
                                Logging.Log("FileIO", "ParsRecord", "seasonal employee added");
                            }
                            else
                            {
                                Logging.Log("FileIO", "ParsRecord", "invalid employee data for a seasonal employee");
                                while (words[wordCounter] != "FT" && words[wordCounter] != "PT" && words[wordCounter] != "SN" && words[wordCounter] != "CT" && wordCounter < words.Count() - 1)
                                {
                                    wordCounter++;
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Logging.Log("FileIO", "ParsRecord", "invalid employee data for a seasonal employee - Error Message: " + ex.Message);
                            while (words[wordCounter] != "FT" && words[wordCounter] != "PT" && words[wordCounter] != "SN" && words[wordCounter] != "CT" && wordCounter < words.Count() - 1)
                            {
                                wordCounter++;
                            }
                        }

                    }
                    else
                    {
                        Logging.Log("FileIO", "ParsRecord", "Not enough employee data for a seasonal employee");
                        break;
                    }
                }
                else
                {
                    //string className, string methodName, string eventDetails
                    Logging.Log("FileIO", "ParsRecord", "invalid employee type in file");
                    while (words[wordCounter] != "FT" && words[wordCounter] != "PT" && words[wordCounter] != "SN" && words[wordCounter] != "CT" && wordCounter < words.Count() - 1)
                    {
                        wordCounter++;
                    }
                }
            }
            return employeeRec;
        }
Exemple #12
0
        /**
        * \brief Give employee write and file to write to
        *
        * \details <b>Details</b>
        *
        * \employeeList - <b>List<AllEmployees.Employee></b> - The employees records
        * \param fileName - <b>String</b> - The file path and name of file storing the records
        *
        * \return  umOfRecordsSaved - <b>Int</b> - The number of employees that were sucessfully saved
        */
        public static int WriteRecord(List<AllEmployees.Employee> employeeList, String fileName)
        {
            int numOfRecordsSaved = 0;
            if (wasRead == true)
            {
                File.WriteAllText(fileName, String.Empty);
            }
            foreach (Employee emp in employeeList)
            {
                string identifier = emp.GetEmployeeType();
                string fileOutput = "";

                if (identifier == "CT")
                {
                    AllEmployees.ContractEmployee employeeData = new AllEmployees.ContractEmployee();
                    employeeData = (AllEmployees.ContractEmployee)emp;
                    if (employeeData.Validate() == true)
                    {
                        fileOutput = employeeData.ToString();//test sample of gow to format
                        StreamWriter sw = File.AppendText(fileName);//write data (Details Method)
                        sw.WriteLine(fileOutput);//will append if file exists or create new if it does not already exist
                        sw.Close();
                        Logging.Log("FileIO", "WriteAllRecords", "ContractEmployee written to file");
                        numOfRecordsSaved++;
                    }
                    else
                    {
                        Logging.Log("FileIO", "WriteAllRecords", "ContractEmployee was invalid and was not written to file");
                    }
                }
                else if (identifier == "FT")
                {
                    AllEmployees.FulltimeEmployee employeeData = new AllEmployees.FulltimeEmployee();
                    employeeData = (AllEmployees.FulltimeEmployee)emp;
                    if (employeeData.Validate() == true)
                    {
                        fileOutput = employeeData.ToString();//test sample of gow to format
                        StreamWriter sw = File.AppendText(fileName);//write data (Details Method)
                        sw.WriteLine(fileOutput);//will append if file exists or create new if it does not already exist
                        sw.Close();
                        Logging.Log("FileIO", "WriteAllRecords", "FulltimeEmployee written to file");
                        numOfRecordsSaved++;
                    }
                    else
                    {
                        Logging.Log("FileIO", "WriteAllRecords", "FullTimeEmployee was invalid and was not written to file");
                    }
                }
                else if (identifier == "PT")
                {
                    AllEmployees.ParttimeEmployee employeeData = new AllEmployees.ParttimeEmployee();
                    employeeData = (AllEmployees.ParttimeEmployee)emp;
                    if (employeeData.Validate() == true)
                    {
                        fileOutput = employeeData.ToString();//test sample of gow to format
                        StreamWriter sw = File.AppendText(fileName);//write data (Details Method)
                        sw.WriteLine(fileOutput);//will append if file exists or create new if it does not already exist
                        sw.Close();
                        Logging.Log("FileIO", "WriteAllRecords", "ParttimeEmployee written to file");
                        numOfRecordsSaved++;
                    }
                    else
                    {
                        Logging.Log("FileIO", "WriteAllRecords", "PartTimeEmployee was invalid and was not written to file");
                    }
                }
                else if (identifier == "SN")
                {
                    AllEmployees.SeasonalEmployee employeeData = new AllEmployees.SeasonalEmployee();
                    employeeData = (AllEmployees.SeasonalEmployee)emp;
                    if (employeeData.Validate() == true)
                    {
                        fileOutput = employeeData.ToString();//test sample of gow to format
                        StreamWriter sw = File.AppendText(fileName);//write data (Details Method)
                        sw.WriteLine(fileOutput);//will append if file exists or create new if it does not already exist
                        sw.Close();
                        Logging.Log("FileIO", "WriteAllRecords", "SeasonalEmployee written to file");
                        numOfRecordsSaved++;
                    }
                    else
                    {
                        Logging.Log("FileIO", "WriteAllRecords", "SeasonalEmployee was invalid and was not written to file");
                    }
                }
                else
                {
                    Logging.Log("FileIO", "WriteAllRecords", "invalid unknown employee type was not written to file: " + identifier);
                }
            }
            return numOfRecordsSaved;
        }
Exemple #13
0
        /**
         * @fn  private bool ModifyFulltimeEmployee(ModifyFulltimeEmployee employee, string returnMessage)
         *
         * @brief   allows user to modify this employee using the command line.
         *
         * @param   ModifyFulltimeEmployee    The employee to modify.
         * @param   returnMessage       message displayed to the user as the option to return from this method.
         *
         * @return  whether the user canceled.
         */
        private bool ModifyFulltimeEmployee(FulltimeEmployee employee, string returnMessage)
        {
            bool done = false;
            bool isCanceled = false;
            //loop until user goes back
            do {
                Console.Clear();
                Console.WriteLine(employee.Details());
                Console.WriteLine("1.   Change First Name(A-Z, a-z, ', -)");
                Console.WriteLine("2.   Change Last Name(A-Z, a-z, ', -)");
                Console.WriteLine("3.   Change Date of birth(yyyy-mm-dd)");
                Console.WriteLine("4.   Change Social insurance number");
                Console.WriteLine("5.   Change Date of hire(yyyy-mm-dd)");
                Console.WriteLine("6.   Change Date of termination(yyyy-mm-dd)");
                Console.WriteLine("7.   Change Salary");
                Console.WriteLine("8.   Cancel");
                Console.WriteLine("9.   " + returnMessage);

                //get user input until valid
                bool valid;
                do {
                    valid = true;
                    string input = Console.ReadLine();
                    switch(input) {
                        case "1":
                            Console.Write("Enter a new first name:");
                            while(employee.SetFirstName(Console.ReadLine()) == false) {
                                Console.Write("Invalid name, Enter a new first name:");
                            }
                            break;
                        case "2":
                            Console.Write("Enter a new last name:");
                            while(employee.SetLastName(Console.ReadLine()) == false) {
                                Console.Write("Invalid name, Enter a new last name:");
                            }
                            break;
                        case "3":
                            bool dateOfBirthDone = false;
                            while (!dateOfBirthDone) {
                                Console.Write("Enter a new date of birth:");
                                try {
                                    while (employee.SetDateofBirth(DateTime.ParseExact(Console.ReadLine(), "yyyy-MM-dd", CultureInfo.InvariantCulture)) == false) {
                                        Console.Write("Invalid date, Enter a new date of birth:");
                                    }
                                    dateOfBirthDone = true;
                                }
                                catch (FormatException ex) {
                                    Console.WriteLine("Invalid date, Format: yyyy-mm-dd");
                                    dateOfBirthDone = false;
                                }
                            }
                            break;
                        case "4":
                            Console.Write("Enter a new social insurance number:");
                            while (employee.SetSocialInsuranceNumber(Console.ReadLine()) == false) {
                                Console.Write("Invalid number, Enter a new social insurance number:");
                            }
                            break;
                        case "5":
                            bool dateOfHireDone = false;
                            while (!dateOfHireDone) {
                                Console.Write("Enter a new date of hire:");
                                try {
                                    while (employee.SetDateOfHire(DateTime.ParseExact(Console.ReadLine(), "yyyy-MM-dd", CultureInfo.InvariantCulture)) == false) {
                                        Console.Write("Invalid date, Enter a new date of hire:");
                                    }
                                    dateOfHireDone = true;
                                }
                                catch (FormatException ex) {
                                    Console.WriteLine("Invalid date, Format: yyyy-mm-dd");
                                    dateOfHireDone = false;
                                }
                            }
                            break;
                        case "6":
                            bool dateOfTerminationDone = false;
                            while (!dateOfTerminationDone) {
                                Console.Write("Enter a new date of termination:");
                                try {
                                    while (employee.SetDateOfTermination(DateTime.ParseExact(Console.ReadLine(), "yyyy-MM-dd", CultureInfo.InvariantCulture)) == false) {
                                        Console.Write("Invalid date, Enter a new date of termination:");
                                    }
                                    dateOfTerminationDone = true;
                                }
                                catch (FormatException ex){
                                    Console.WriteLine("Invalid date, Format: yyyy-mm-dd");
                                    dateOfTerminationDone = false;
                                }
                            }
                            break;
                        case "7":
                            bool salaryDone = false;
                            while (!salaryDone) {
                                Console.Write("Enter a new salary:");
                                try {
                                    while (employee.SetSalary(decimal.Parse(Console.ReadLine())) == false) {
                                        Console.Write("Invalid pay, Enter a new salary:");
                                    }
                                    salaryDone = true;
                                }
                                catch (FormatException ex) {
                                    Console.WriteLine("Salary must be a number");
                                    salaryDone = false;
                                }
                            }
                            break;
                        case "8":
                            done = true;//end
                            isCanceled = true;
                            break;
                        case "9":
                            done = true;//end
                            isCanceled = false;
                            break;
                        default:
                            Console.WriteLine("Invalid input, please enter number corrispoding to a menu option:");
                            valid = false;
                            break;
                    }
                } while(!valid);

            } while(!done);

            return isCanceled;
        }
Exemple #14
0
 public void TestInitialize()
 {
     // Instantiate the container and a full-time employee
     employeeRepo = new Container();
     DateTime dateOfBirth = new DateTime(1990, 09, 10);
     DateTime dateOfHire = new DateTime(2010, 10, 11);
     DateTime dateOfTermination = new DateTime(2011, 03, 19);
     FTEmployee = new FulltimeEmployee("Sam", "Jones", 902398402, dateOfBirth, dateOfHire, dateOfTermination, 50000);
 }
        public void SetDateOfHireStringTestInvalidFormat()
        {
            FulltimeEmployee employee = new FulltimeEmployee();
            bool retVal = employee.SetDateOfHire("19930424");
            Assert.IsFalse(retVal);

            DateTime date = new DateTime();
            int compReturn = DateTime.Compare(employee.GetDateOfHire(), date);
            Assert.AreEqual(0, compReturn);
        }
 public void ConstructorWithAllParamTestValid2()
 {
     DateTime DOB = new DateTime(1954, 08, 20);
     DateTime DOH = new DateTime(1994, 09, 03);
     DateTime DOT = new DateTime(2014, 12, 23);
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Mc'Davies", 123456789, DOB, DOH, DOT, 200000);
 }
        public void SetDateOfTerminationIntsTestInvalidLetter()
        {
            DateTime DOB = new DateTime(1954, 08, 20);
            DateTime DOH = new DateTime(1994, 09, 03);
            DateTime DOT = new DateTime(2000, 03, 23);
            FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 230000);

            bool retVal = employee.SetDateOfTermination("1993-s2-24");
            Assert.IsFalse(retVal);

            int compReturn = DateTime.Compare(employee.GetDateOfTermination(), DOT);
            Assert.AreEqual(0, compReturn);
        }
 public void ConstructorWithNamesTestInvalidNumber()
 {
     FulltimeEmployee employee = new FulltimeEmployee("Brandon2", "Davies");
 }
 public void ConstructorWithAllParamTestInvalidSIN()
 {
     DateTime DOB = new DateTime();
     DateTime DOH = new DateTime();
     DateTime DOT = new DateTime();
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 1234756789, DOB, DOH, DOT, 230000);
 }
 public void ConstructorWithNamesTestValid3()
 {
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "LeRoy-Davies");
 }
        public void SetDateOfTerminationStringTestValidString()
        {
            DateTime DOB = new DateTime(1954, 08, 20);
            DateTime DOH = new DateTime(1994, 09, 03);
            DateTime DOT = new DateTime(2000, 03, 23);
            FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 230000);
            bool retVal = employee.SetDateOfTermination("1997-04-24");
            Assert.IsTrue(retVal);

            DateTime date = new DateTime(1997, 04, 24);
            int compReturn = DateTime.Compare(employee.GetDateOfTermination(), date);
            Assert.AreEqual(0, compReturn);
        }
        public void SetDateOfBirthDateTestValidDate()
        {
            FulltimeEmployee employee = new FulltimeEmployee();
            DateTime date = new DateTime(1993, 05, 15);
            bool retVal = employee.SetDateOfBirth(date);
            Assert.IsTrue(retVal);

            int compReturn = DateTime.Compare(employee.GetDateOfBirth(), date);
            Assert.AreEqual(0, compReturn);
        }
        public void SetSalaryInvalidNegitive()
        {
            FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies");
            bool retVal = employee.SetSalary(-20000);
            Assert.IsFalse(retVal);

            Assert.AreEqual(employee.GetSalary(), 0);
        }
        public void SetDateOfBirthIntsTestInvalidLetter()
        {
            FulltimeEmployee employee = new FulltimeEmployee();
            bool retVal = employee.SetDateOfBirth("1993-s2-24");
            Assert.IsFalse(retVal);

            DateTime date = new DateTime();
            int compReturn = DateTime.Compare(employee.GetDateOfBirth(), date);
            Assert.AreEqual(0, compReturn);
        }
        public void SetSalaryValid()
        {
            FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies");
            bool retVal = employee.SetSalary(20000);
            Assert.IsTrue(retVal);

            Assert.AreEqual(employee.GetSalary(), 20000);
        }
        public void SetDateOfBirthStringTestInvalidFuture()
        {
            FulltimeEmployee employee = new FulltimeEmployee();
            bool retVal = employee.SetDateOfBirth("2017-11-24");
            Assert.IsFalse(retVal);

            DateTime date = new DateTime();
            int compReturn = DateTime.Compare(employee.GetDateOfBirth(), date);
            Assert.AreEqual(0, compReturn);
        }
 public void ToStringTestValid()
 {
     DateTime DOB = new DateTime(1954, 08, 20);
     DateTime DOH = new DateTime(1994, 09, 03);
     DateTime DOT = new DateTime(2014, 12, 23);
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 230000);
     String toString = employee.ToString();
     Assert.IsTrue(toString == "|FT|Brandon|Davies|123456789|1954-08-20|1994-09-03|2014-12-23|230000|");
 }
 public void ConstructorWithAllParamTestInvalidDOTBoforeDOH()
 {
     DateTime DOB = new DateTime(1993, 11, 14);
     DateTime DOH = new DateTime(2012, 10, 19);
     DateTime DOT = new DateTime(2010, 07, 29);
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 230000);
 }
 public void ConstructorWithAllParamTestValid1()
 {
     DateTime DOB = new DateTime(1993, 04, 24);
     DateTime DOH = new DateTime(2000, 12, 12);
     DateTime DOT = new DateTime();
     FulltimeEmployee employee = new FulltimeEmployee("Brandon", "Davies", 123456789, DOB, DOH, DOT, 20000);
 }
        public void ModifyNormalTest()
        {
            EmployeeContainer ec = new EmployeeContainer("test", "ModifyNormalTestLog");
            ParttimeEmployee pe = new ParttimeEmployee(
                new DateTime(1999, 12, 31),
                new DateTime(2000, 1, 1),
                10,
                "Testy",
                "Peoper",
                new DateTime(1950, 1, 1),
                "111222333"
            );

            ec.Add(pe);

            FulltimeEmployee fe = new FulltimeEmployee(
                new DateTime(2004, 3, 6),
                new DateTime(2010, 1, 17),
                1000,
                "Dirty",
                "Dan",
                new DateTime(1975, 5, 30),
                "333222111"
            );

            Assert.AreEqual(ec.Modify(0, fe), true);
        }
        /**
           * @fn  public void Load()
           *
           * @brief   Loads from database file.
           *
           * @return void.
           */
        public void Load()
        {
            employees.Clear();

            List<List<string>> records = file.ReadRecords("|");

            foreach(List<string> record in records) {
                if(record.Count <= 1) {
                    continue;
                }

                Employee newEmployee = null;

                switch(record[0]) {
                    case "CE":
                        newEmployee = new ContractEmployee();
                        break;
                    case "SE":
                        newEmployee = new SeasonalEmployee();
                        break;
                    case "PE":
                        newEmployee = new ParttimeEmployee();
                        break;
                    case "FE":
                        newEmployee = new FulltimeEmployee();
                        break;
                }

                newEmployee.InitFromRecord(record);
                employees.Add(newEmployee);
            }
        }