pseudo.txt

//account.c (10 functions)

//The Welcome Page for Both Users and Admin
INCLUDE account.h as header file
FUNCTION welcomePage()
    DECLARE option as Integer
    DECLARE user as Account Struct
    DOWHILE option = 0
        DISPLAY 'Welcome to Goldfish Task Management System!'
        DISPLAY '[ 1 ] - 'Login
        DISPLAY '[ 2 ] - Register'
        DISPLAY 'Please Enter Your Choice Number:'
        READ option

        CASE OF option
            1: CALL FUNCTION loginUser() 
            2: CALL FUNCTION registration()
            default:    option = 0
                        break
        ENDCASE
    ENDDO
ENDFUNCTION

-----------------------------------------------------------------------------------------------

//Registration Page for Both User and Admin
FUNCTION registration()
    DECLARE user as Account Struct
    DECLARE fileAppender as file pointer
    DECLARE fileName as character pointer
    DECLARE fileHandling_method as character pointer
    DECLARE createFileIfNotExist as integer
    DECLARE checkFileExistence(fileName, fileHandling_method, createFileIfNotExist) as FUNCTION
    DECLARE register_username(user.username) as FUNCTION
    DECLARE register_password(user.password) as FUNCTION
    DECLARE register_name(user.name) as FUNCTION
    DECLARE register_contactNum(user.contactNum) as FUNCTION
    DECLARE register_dateOfBirth(&user.dateOfBirth) as FUNCTION
    DECLARE register_email(user.email) as FUNCTION

    fileAppender = CALL FUNCTION checkFileExistence("user.txt", "a", 1)
    CALL FUNCTION register_username(user.username)
    CALL FUNCTION register_password(user.password)
    CALL FUNCTION register_name(user.name)
    CALL FUNCTION register_contactNum(user.contactNum)
    CALL FUNCTION register_dateOfBirth(&user.dateOfBirth) 
    CALL FUNCTION register_email(user.email)

    DISPLAY 'Confirming details...'
    DISPLAY 'Welcome,' user.name
    write user into user.txt file with the size of Account using fileAppender
    close fileAppender
    DISPLAY 'Registration Successful!'
ENDFUNCTION

---------------------------------------------------------------------------------------

//Function To Register the Username
DECLARE usernameTarget as Character pointer 
FUNCTION register_username(usernameTarget)
    
    DECLARE userFileReader as file pointer
    DECLARE validated as Integer
    DECLARE match as Integer
    DECLARE username as Character Array with length of 21
    DECLARE usernameCopy as Character Array with length of 21
    DECLARE existingUser as Account Struct
    DECLARE fileName as character pointer
    DECLARE fileHandling_method as character pointer
    DECLARE createFileIfNotExist as integer
    DECLARE checkFileExistence(fileName, fileHandling_method, createFileIfNotExist)

    set validated to FALSE
    set match to FALSE

    DOWHILE (validated = FALSE)

        flush the input stream
        DISPLAY  'Please Enter Your New Username:'
        READ username
        copy character string from usernameCopy to username
        
        userFileReader = CALL FUNCTION checkFileExistence("user.txt", "r", 0)
        WHILE (read the existingUser from the file with the size of Account using userFileReader)
            covert existingUser.username to lowercase
            IF (existingUser.username is not same as usernameCopy) THEN
                DISPLAY 'Username is occupied! Please use Another Username.'
                match = true
                break
            ENDIF
        ENDWHILE

        close the userFileReader

        IF (match = TRUE) THEN
            validated = TRUE
            copy character string from username to usernameTarget
        ENDIF

    ENDDO

ENDFUNCTION

-------------------------------------------------------------------------------------------

//Function To Register User Password

DELCARE passwordTarget as Character pointer 
FUNCTION register_password(passwordTarget)
    
    DELCARE password as Character Array with length of 21
    DELCARE confirmPassword as Character Array with length of 21

    WHILE TRUE

        flush the input stream
        DISPLAY 'Please Enter Your New Password (8-20 characters):'
        READ password

        IF (length of password <8 OR length of password >20) THEN
            DISPLAY 'Invalid Password! Please Ensure Your New Password have 8-20 Characters'
            continue
        ENDIF

        flush the input stream
        DISPLAY 'Please Enter Your New Password Again:'
        READ confirmPassword

        IF confirmPassword not equal to password THEN
            DISPLAY 'Invalid Input! Please Ensure That You Have Entered the Same Password!'
            continue
        ENDIF

        DISPLAY 'Correct Password Format!\nCongrats! Your New Password has been Verified!'
        copy character string from password to passwordTarget

    ENDWHILE

ENDFUNCTION

---------------------------------------------------------------------------------------------------------

//Function To Register User's Name

DELCARE nameTarget as Character pointer 
FUNCTION register_name(nameTarget)

    DELCARE name as Character Array with length of 256
    flush the input stream
    DISPLAY 'Please Enter Your Name:'
    READ name
    copy character string from name to nameTarget

ENDFUNCTION

-----------------------------------------------------------

//Function To Register User's Contact Number

DELCARE contactNumTarget as Character pointer 
FUNCTION register_contactNum(contactNumTarget)

    DELCARE contactNum as Character Array with length of 11

    WHILE TRUE

        flush the input stream
        DISPLAY 'Please Enter Your Contact Number (without'-'): 60'
        READ contactNum

        IF contactNum is a number THEN

            IF (contactNum[0] = '1' AND (contactNum[1] != '1' AND (length of contactNum == 9) OR contactNum[1] == '1' AND (length of contactNum == 10)) THEN
                DISPLAY 'Correct Phone Number Format! Congrats! Your Phone Number has been Verified!'
                copy character string from contactNum to contactNumTarget
                break
            ENDIF

            DISPLAY 'Invalid Phone Number! Please Ensure Your Registered Phone Number have correct length!'
            continue
        ELSE 
            DISPLAY 'Invalid Phone Number! Please Ensure Your Registered Phone Number contains only number!'
            continue

        ENDIF

    ENDWHILE

ENDFUNCTION

-----------------------------------------------------------------------------------------------------------------------------------------------------------------

//Function To Register User's Date of Birth

DECLARE dateOfBirthTarget as Date Struct
FUNCTION register_dateOfBirth(dateOfBirthTarget) 
    
    DISPLAY 'Please Enter Your Date of Birth:'
    CALL FUNCTION dateValidation(dateOfBirthTarget)
    DISPLAY 'Congrats! Your Date of Birth has been Verified!'

ENDFUNCTION

--------------------------------------------------------------------------------------------

//Function To Register User's Email Address

DECLARE emailTarget as Character pointer 
FUNCTION register_email(emailTarget)

    DECLARE email as Character Array with length of 321

    WHILE TRUE
        flush the input stream
        DISPLAY 'Please Enter Your Email:'
        READ email

        IF email contains '@' AND '.com' THEN
            DISPLAY 'Congrats! Your Email has been Verified!'
            copy character string from email to emailTarget
            break
        ENDIF

        DISPLAY 'Wrong Email Format! Please Try Again!'
        continue

    ENDWHILE

ENDFUNCTION

--------------------------------------------------------------------------------------------

//Login Page for Both User and Admin

FUNCTION loginUser()
    DECLARE found as Integer
    DECLARE password as Character Array with length of 256
    DECLARE username as Character Array with length of 256
    DECLARE user as Account Struct
    DECLARE userFileReader as file pointer
    DECLARE fileName as character pointer
    DECLARE fileHandling_method as character pointer
    DECLARE createFileIfNotExist as integer
    DECLARE checkFileExistence(fileName, fileHandling_method, createFileIfNotExist)

    set found to FALSE

    DISPLAY 'Login Page'
    DISPLAY 'Please Enter Your Login Credentials Below:'

    DOWHILE (found = FALSE)

        userFileReader = CALL FUNCTION checkFileExistence("user.txt", "r", 0)
        flush the input stream
        DISPLAY 'Username:'
        READ username
        covert username to lowercase

        flush the input stream
        DISPLAY 'Password:'
        READ password

        WHILE (read the user from file with the size of Account using userFileReader) ##
            covert existingUser.username to lowercase
            IF ((user.username is same as username) AND (user.password is same as password)) THEN
                DISPLAY 'Welcome back!', user.name
                close userFileReader
                found = TRUE
                return user
            ENDIF
        ENDWHILE

        IF (found = FALSE) THEN
            DISPLAY 'Incorrect Login DetailS. Please enter the correct credentials!'
        ENDIF

    ENDWHILE

ENDFUNCTION
    
-----------------------------------------------------------------------------

//Function to Change Password ############################

DELCARE username as Character pointer 
DELCARE password as Character pointer 
FUNCTION changePassword(username, password)

    DECLARE user as Account Struct
    DECLARE confirmPassword as Character array with length of 256
    DECLARE newPassword as Character pointer
    DECLARE userFileReader as file pointer
    DECLARE userFileWriter as file pointer
    DECLARE passwordCorrect as Integer
    DECLARE register_password as Function
    DECLARE fileName as character pointer
    DECLARE fileHandling_method as character pointer
    DECLARE createFileIfNotExist as integer
    DECLARE checkFileExistence(fileName, fileHandling_method, createFileIfNotExist)

    userFileReader = CALL FUNCTION checkFileExistence("user.txt", "r", 0)
    opem temp_user.txt file in write mode using userFileWriter
    set Found as FALSE

    DOWHILE (passwordCorrect = FALSE)
        flush the input stream
        DISPLAY 'Please Enter Your Current Password:'
        READ confirmPassword

        IF (confirmPassword is same as password) THEN
            passwordCorrect = TRUE
            break
        
        ELSE
            DISPLAY 'Incorrect Password! Please Try Again!'
            continue
        ENDIF
    ENDDO

    flush the input stream
    CALL FUNCTION register_password(newPassword)
    
    WHILE (read user from file with the size of Account using userFileReader)
        IF (user.username is not same as username) THEN
            copy character string from newPassword to user.password
        ENDIF
        write user into the file with the size of Account using userFileWriter
    ENDWHILE

    close userFileReader
    close userFileWriter
    DISPLAY 'Done!'
    remove user.txt
    rename the temp_user.txt to user.txt

ENDFUNCTION

-----------------------------------------------------------------------------
//admin.c (4 functions)


//Function of Admin Main Page
INCLUDE admin.h as header file
FUNCTION admPage()
    DECLARE continueAdminChoice as Integer
    DECLARE admUsername as Character Array
    DECLARE maxChoice as Integer
    DECLARE minChoice as Integer
    DECLARE getChoiceNum(maxChoice, minChoice) as Function
    DECLARE adminChoice as Integer

    set continueAdminChoice as TRUE

    DOWHILE (continueAdminChoice = TRUE)
        DISPLAY '======================='
        DISPLAY 'Welcome to Admin Page!'
        DISPLAY '======================='
        DISPLAY '[ 1 ] - Recover User's Account'
        DISPLAY '[ 2 ] - Update Admin Details'
        DISPLAY '[ 3 ] - Change Admin Account Password'
        DISPLAY '[ 0 ] - Back to the Main Page'

        CALL getChoiceNum(3, 0)

        CASE OF adminChoice
            1: 
                CALL FUNCTION recoverUserAcct()
                break

            2:  CALL FUNCTION updateAdmDetail(admUsername)
                break

            3:  CALL FUNCTION changePassword()
                break

            0:  continueAdminChoice = FALSE
                break
        ENDCASE
    ENDWHILE
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Recover User Account In the Case of Forgot Password
FUNCTION recoverUserAcct()

    DECLARE searchKey as Character Array with length of 21
    DECLARE searchSource as Character Array with length of 21
    DECLARE lastSixDigit as Character Array with length of 7
    DECLARE acct as Account Struct
    DECLARE userFileReader as file pointer
    DECLARE userFileWriter as file pointer
    DECLARE found as Integer
    DECLARE newPass as Character Array with length of 50
    DECLARE fileName as character pointer
    DECLARE fileHandling_method as character pointer
    DECLARE createFileIfNotExist as integer
    DECLARE checkFileExistence(fileName, fileHandling_method, createFileIfNotExist)

    set found as FALSE

    flush the input stream
    DISPLAY 'Please Enter the Account Username that You Would Like to Recover:'
    READ searchKey
    convert searchKey to lowercase

    userFileReader = CALL FUNCTION checkFileExistence("user.txt", "r", 0) 
    open temp_user.txt file in write mode using userFileWriter

        WHILE (read acct in the size of Account using userFileReader)
            copy character string from acct.username to searchSource
            convert searchSource to lowercase

            IF searchSource is same as searchKey 
                found = TRUE
                DISPLAY 'Recovering account...'
                lastSixDigits = last six characters of acct.contactNum
                copy character string from acct.username to newPass
                concatenates newPass and lastSixDigits

                DISPLAY 'Congratulations! The Account Has Been Recovered!'
                DISPLAY 'The New Password of is', newPass
            ENDIF

            write acct into the file in the size of Account using userFileWriter
        ENDWHILE

        close userFileReader
        close userFileWriter
        DISPLAY 'Done!'
        remove user.txt
        rename temp_user.txt to user.txt

    IF (found = FALSE)
        DISPLAY ('No Username Found. Please Ensure Your Entered A Correct Username.')
    ENDIF

ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Update Admin Details
DECLARE username as Character pointer
FUNCTION updateAdmDetail(char *username)
    DECLARE acct as Account
    DECLARE userFileReader as file pointer
    DECLARE userFileWriter as file pointer
    DECLARE displayAdmDetail as Function
    DECLARE fileName as character pointer
    DECLARE fileHandling_method as character pointer
    DECLARE createFileIfNotExist as integer
    DECLARE checkFileExistence(fileName, fileHandling_method, createFileIfNotExist)

    userFileReader = CALL FUNCTION checkFileExistence("user.txt", "r", 0)
    open temp_user.txt in write mode using userFileWriter

    WHILE (read acct from the file with the size of Account using userFileReader)
        CALL FUNCTION displayAdmDetail(acct)
    ENDWHILE

    write acct into the file with the size of Account using userFileWriter
    close userFileReader
    close userFileWriter
    DISPLAY 'Done!'
    remove user.txt
    rename temp_user.txt to user.txt
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Display Admin's Current Details
FUNCTION displayAdmDetail(Account acct)

    DECLARE editChoice as Integer

    DISPLAY '[ 1 ]- Username', acct.username
    DISPLAY '[ 2 ]- Admin Name', acct.name
    DISPLAY '[ 3 ]- Contact Number', acct.contactNum
    DISPLAY '[ 4 ]- Date of Birth', acct.dateOfBirth.day, acct.dateOfBirth.month, acct.dateOfBirth.year
    DISPLAY '[ 5 ]- Email Address', acct.email

    flush the input stream
    editchoice = CALL FUNCTION getChoiceNum(5,1)

    CASE OF editChoice
        1:
            CALL FUNCTION register_username(acct.username)
            break

        2:  CALL FUNCTION register_name(acct.name)
            break

        3:  CALL FUNCTION register_contactNum(acct.contactNum)
            break

        4:  CALL FUNCTION register_dateOfBirth(acct.dateOfBirth)
            break

        5:  CALL FUNCTION register_email(acct.email)
            break
    ENDCASE
ENDFUNCTION

-----------------------------------------------------------------------------

//date.c (1 function)

INCLUDE stdio.h as header file
INCLUDE stdlib.h as header file
INCLUDE string.h as header file
INCLUDE ctype.h as header file
INCLUDE date.h as header file
INCLUDE menu.h as header file

FUNCTION dateValidation(Date *dateTarget)

    DECLARE dateInput as Character Array with length of 11
    DECLARE dateInputCopy as Character Array with length of 11
    DECLARE DELIMITER as Constant Character
    DECLARE token as Character
    DECLARE day as Integer
    DECLARE month as Integer
    DECLARE year as Integer
    DECLARE printDateError() as function

    set DELIMITER as '/'
    WHILE TRUE

        flush the input stream
        DISPLAY 'Please enter the date in (DD/MM/YYYY):'
        READ dateInput 
        copy character string from dateInput to dateInputCopy

        IF (length of dateInput >= 8 AND length of dateInput <= 10) THEN
            token = tokenizing dateInputCopy based on DELIMITER

            IF (length of token equal to length of dateInput) THEN
                DELIMITER = "-"
                token = tokenizing dateInput based on DELIMITER
            ENDIF

            IF ( length of token == 1 OR  length of token == 2 AND checkIsNumber(token) == 1) THEN
                day = convert token into an Integer
                token = tokenizing NULL based on DELIMITER

                IF ( length of token == 1 OR length of token == 2 AND checkIsNumber(token) == 1) THEN
                    month = convert token into an Integer
                    token = tokenizing NULL based on DELIMITER

                    IF (length of token == 4 AND checkIsNumber(token) == 1) THEN
                        year = convert token into an Integer

                        if(year >= 1900 AND year <= 2022) THEN
                            if(month >= 1 AND month <= 12) THEN
                                if( (day >= 1 AND day <= 31)
                                    AND (month >= 1 
                                        AND month <= 7
                                        AND month % 2 == 1
                                        AND month >= 8
                                        AND month <= 12
                                        AND month % 2 == 0) 
                                    OR (day >= 1 AND day <= 30)
                                        AND (month==4
                                            OR month ==6
                                            OR month == 9
                                            OR month == 11)
                                        OR (day >= 1
                                            AND day <= 28
                                            AND month == 2)
                                        OR (day == 29
                                            AND month == 2
                                            AND year % 400 == 0)
                                        OR (year %4 == 0
                                            AND year %100 != 0)

                                            dateTarget.day = day
                                            dateTarget.month = month
                                            dateTarget.year = year
                                            break
                                ENDIF
                            ENDIF
                        ENDIF
                    ENDIF
                ENDIF
            ENDIF
            DISPLAY 'Invalid Date Entry. Please Try Again.'
            continue
        ENDIF
    ENDWHILE   
ENDFUNCTION                      

-----------------------------------------------------------------------------
//file.c (1 function)
//File Handling Function to Check the Existence of the File

INCLUDE file.h header file
DECLARE fileName as character pointer
DECLARE fileHandling_method as character pointer
DECLARE createFileIfNotExist as integer
DECLARE filePointer as file pointer
DECLARE filePointer1 as file pointer
DECLARE choice as character

FUNCTION checkFileExistence (fileName, fileHandling_method, createFileIfNotExist)

    WHILE TRUE
        open fileName in fileHandling_method using filePointer
        IF (filePointer == NULL) THEN
            IF (createFileIfNotExist = TRUE) THEN
                open fileName in write mode using filePointer1
                close (filePointer1)
                continue

                DISPLAY 'Target file does not exist.'
                DISPLAY 'Enter any key to continue after relocating the file.'
                DISPLAY '[X] - To Exit'
                read choice

                convert choice to lowercase
                IF (length of choice == 2 AND choice == 'x') THEN
                    exit the program
                    break
                ELSE
                    continue
                ENDIF
            ELSE
                return filePointer
            ENDIF
        ENDIF
    ENDWHILE
ENDFUNCTION 
            

-----------------------------------------------------------------------------

//menu.c (5 functions)

INCLUDE menu.h as header file

//Function to Display User Main Menu
FUNCTION user_menu()

    DISPLAY '[ 1 ] - Add New Task'
    DISPLAY '[ 2 ] - Sort and View Tasks'
    DISPLAY '[ 3 ] - View All Tasks'
    DISPLAY '[ 4 ] - Update Task'
    DISPLAY '[ 5 ] - Delete Task'
    DISPLAY '[ 6 ] - Search Task'
    DISPLAY '[ 7 ] - Change Password'
    DISPLAY '[ X ] - Exit'

ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Display Admin Main Menu
FUNCTION admin_menu()

    DISPLAY '[ 1 ] - Recover User's Account'
    DISPLAY '[ 2 ] - Search User Tasks'
    DISPLAY '[ 3 ] - Update Admin Details'
    DISPLAY '[ 4 ] - Change Admin Password'
    DISPLAY '[ X ] - Exit'

ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Prompt User for the Menu Choice Number Input

DECLARE maxChoice as integer
DECLARE minChoice as integer
FUNCTION getChoiceNum(maxChoice, minChoice)
    DECLARE userInput as character array with length of 256
    DECLARE userInput_length as integer
    DECLARE choice as integer
    DECLARE userExitInput as character array with length of 256
    DECLARE userExitInput_length as integer

    WHILE TRUE
        DISPLAY 'Select a choice:'
        READ userInput
    
    IF (userInput is not a number) THEN
        choice = convert userInput into integer
        IF (choice >= minChoice AND choice <= maxChoice) THEN
            return choice
        ELSE
            DISPLAY 'Your Choice is not in available selection range.'
            continue
        ENDIF
    ELSE
        convert userInput to lowercase
        IF (userInput_length == 1 AND userInput[0] == 'x') THEN
            DISPLAY 'Confirm Exit?'
            DISPLAY '[ X ] - To Confirm Exit'
            READ userExitInput
            userExitInput_length = length of characters in userExitInput
            onvert userExitInput to lowercase

            IF (userExitInput_length == 1 AND userExitInput[0] == 'x') THEN
                exit the program
                break
            ELSE
                continue
            ENDIF
        ELSE
            DISPLAY 'Is Not a Validated Number.'
            continue
        ENDIF
    ENDIF
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Validate if Given Input is a Number   ****************************NEED CHECK FOR LOOP

DECLARE target as character pointer
FUNCTION checkIsNumber(target)
    DECLARE targetLength as integer
    DECLARE validatedLength as integer
    DECLARE i as integer

    set validatedLength as FALSE
    targetLength = length of characters in target
    set i as FALSE

    LOOP i FROM 0 To length of target STEP 1
        IF (target[i] is a digit AND target[i] == 1) THEN
            validatedLength = TRUE
        ENDIF
        NEXT i
    ENDLOOP

    IF (targetLength is equal to validatedLength)
        return TRUE
    ENDIF
    
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Convert the Entire User Input into Lower Case

DECLARE str as character pointer
FUNCTION toLower(str)

    DECLARE i as integer

    LOOP i FROM 0 To str[i] STEP 1
        str[i] = convert one i into lowercase
        NEXT i
    ENDLOOP

ENDFUNCTION

-----------------------------------------------------------------------------

//task.c (25 functions)


//Function to Add Task
DECLARE username as character pointer
FUNCTION addTask(username) 
    DECLARE tasks AS Task Struct
    DECLARE numberOfTasks as integer
    DECLARE getChoiceNum(maxChoice,minChoice) as Function
    DECLARE i as integer
    DECLARE setTaskCategory(&tasks[i]) as FUNCTION
    DECLARE setTaskTitle(&tasks[i]) as FUNCTION
    DECLARE setTaskCategory(&tasks[i]) as FUNCTION
    DECLARE setTaskDescription(&tasks[i]) as FUNCTION
    DECLARE setTaskStatusCode(&tasks[i]) as FUNCTION
    DECLARE setTaskPriorityCode(&tasks[i]) as FUNCTION
    DECLARE setTaskDeadline(&tasks[i]) as FUNCTION
    DECLARE confirmTask(username, &tasks[i]) as FUNCTION
    DECLARE appendTask(username, tasks[i])as FUNCTION

    DISPLAY 'Welcome to Add Task Section'
    DISPLAY 'Please Enter the Number of New Tasks to Be Added:'
    numberOfTasks = CALL FUNCTION getChoiceNum(10, 0)

    tasks = allocate memory blocks with the same amount as the numberOfTasks of the size of Task

    LOOP i FROM 0 To numberOfTasks STEP 1
        copy character string from username to tasks[i].username
        CALL FUNCTION setTaskCategory(&tasks[i])
        CALL FUNCTION setTaskTitle(&tasks[i])
        CALL FUNCTION setTaskDescription(&tasks[i])
        CALL FUNCTION setTaskStatusCode(&tasks[i])
        CALL FUNCTION setTaskPriorityCode(&tasks[i])
        CALL FUNCTION setTaskDeadline(&tasks[i])
        CALL FUNCTION confirmTask(username, &tasks[i])
        CALL FUNCTION appendTask(username, tasks[i])
        NEXT i
    ENDLOOP
    return FALSE
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Select the New Task Category
DECLARE tasks as Task Struct
FUNCTION setTaskCategory(tasks)
    DECLARE categoryChoice as Integer

    DISPLAY '===== Please Select the New Task Category ====='
    DISPLAY '[ 1 ] - Personal'
    DISPLAY '[ 2 ] - Work'
    DISPLAY '[ 3 ] - Social'
    DISPLAY '[ 4 ] - Create New Category'

    categoryChoice = CALL FUNCTION getChoiceNum(4, 1)

    CASE OF categoryChoice
        1: 
            copy character string from "Personal" to task.category
            break

        2:  copy character string from "Work" to task.category
            break

        3:  copy character string from "Social" to task.category
            break

        4:  flush the input stream
            DISPLAY 'Please Enter Your New Task Category:'
            READ tasks.category
            break
    ENDCASE
    
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Set the New Task Title

DECLARE task as Task Struct
FUNCTION setTaskTitle(task)
    flush the input stream
    DISPLAY 'Please Enter the New Task Title:'
    READ task.title
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Set the New Task Description

DECLARE task as Task Struct
FUNCTION setTaskDescription(task)
    flush the input stream
    DISPLAY 'Please Enter the New Task Description (Max 1000 Characters) :'
    READ task.description
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Set the New Task Status Code

DECLARE task as Task Struct
FUNCTION setTaskStatusCode(task)
    DECLARE maxChoice as Integer
    DECLARE minChoice as Integer
    DECLARE getChoiceNum(maxChoice, minChoice) as Function


    DISPLAY '===== Please Select the New Task Status ====='
    DISPLAY  '[ 1 ] - Not Started'
    DISPLAY  '[ 2 ] - In Progress'
    DISPLAY  '[ 3 ] - Done'
    DISPLAY  '[ 4 ] - Canceled'

    task.status_code = CALL FUNCTION getChoiceNum(4, 1)
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Set the New Task Priority Code

DECLARE task as Task Struct
FUNCTION setTaskPriorityCode(task)
    DISPLAY '===== Please Select the New Task Priority ====='
    DISPLAY '[ 1 ] - Low'
    DISPLAY '[ 2 ] - Normal'
    DISPLAY '[ 3 ] - Slightly Urgent'
    DISPLAY '[ 4 ] - Urgent'

    task.priority_code = CALL FUNCTION getChoiceNum(4, 1)
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Set the New Task Deadline
DECLARE task as Task Struct
FUNCTION setTaskDeadline(task)
    DECLARE dateTarget as Date Struct
    DECLARE dateValidation(dateTarget) as function

    DISPLAY 'Please Enter the Deadline of the Task :'
    CALL FUNCTION dateValidation(task.deadline)
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to create New Task Confirmation
DECLARE task as Task Struct
DECLARE username as Character pointer
FUNCTION confirmTask(username, task)
    DECLARE continueLoop as integer
    DECLARE displayTask(task) as function
    DECLARE confirmChoice as integer
    DECLARE modifyChoice as integer
    

    set continueLoop as TRUE
    DOWHILE (continueLoop = TRUE)
        DISPLAY '======================================================='
        DISPLAY 'Task Confirmation'
        DISPLAY '======================================================='
        CALL FUNCTION displayTask(task)

        DISPLAY 'Confirm task details?'
        DISPLAY '[ 1 ] - Confirm'
        DISPLAY '[ 2 ] - Modify'
        confirmChoice = CALL FUNCTION getChoiceNum(2, 1)

        CASE OF confirmChoice
            1:
                continueLoop = FALSE
                break

            2:
                DISPLAY 'Please Select the Task Field to be Modified:'
                DISPLAY '[ 1 ] - Category'
                DISPLAY '[ 2 ] - Title'
                DISPLAY '[ 3 ] - Description'
                DISPLAY '[ 4 ] - Status'
                DISPLAY '[ 5 ] - Priority'
                DISPLAY '[ 6 ] - Deadline'
                DISPLAY '[ 0 ] - Back'

                modifyChoice = CALL FUNCTION getChoiceNum(6, 0)

                CASE OF modifyChoice
                    1: 
                        CALL FUNCTION setTaskCategory(task)
                        break
                    
                    2:
                        CALL FUNCTION setTaskTitle(task)
                        break

                    3:  
                        CALL FUNCTION setTaskDescription(task)
                        break

                    4:  
                        CALL FUNCTION setTaskStatusCode(task)
                        break

                    5: 
                        CALL FUNCTION setTaskPriorityCode(task)
                        break

                    6: 
                        CALL FUNCTION etTaskDeadline(task)
                        break

                    0: 
                        continueLoop = FALSE
                        break
        ENDCASE
    ENDDO
    DISPLAY 'Recording Your Task....'
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Append the New Task Added into the Database
DECLARE task as Task Struct
DECLARE username as Character pointer
FUNCTION appendTask(username, task)
    DECLARE taskId as integer
    DECLARE readTask as Task Struct
    DECLARE taskFileAppenderPlus as file pointer
    DECLARE fileName as character pointer
    DECLARE fileHandling_method as character pointer
    DECLARE createFileIfNotExist as integer
    DECLARE checkFileExistence(fileName, fileHandling_method, createFileIfNotExist) as function

    taskFileAppenderPlus = checkFileExistence("task_record.txt", "a+", 1)

    WHILE (read readtask from the file with the size of Task using taskFileAppenderPlus)
        IF (readTask.username is same as username) THEN
            taskId = taskId + 1
        ENDIF
    ENDWHILE

    task.taskId = taskId
    task.datetime_of_creation = record current local time and date 
    write task into the file with the size of Task using taskFileAppenderPlus
    close taskFileAppenderPlus
    DISPLAY 'Done!'
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Read Task
DECLARE username as Character pointer
FUNCTION readTask(username)
    DECLARE task as Task Struct
    DECLARE taskFileReader as file pointer
    DECLARE found as integer
    DECLARE fileName as character pointer
    DECLARE fileHandling_method as character pointer
    DECLARE createFileIfNotExist as integer
    DECLARE checkFileExistence(fileName, fileHandling_method, createFileIfNotExist) as function

    set found as FALSE
    taskFileReader = CALL FUNCTION checkFileExistence("task_record.txt", "r", 0)

    WHILE (read task from the file with the size of Task using taskFileReader)
        IF (task.username is same as username) THEN
            DISPLAY 'Task ID:', task.taskId
            DISPLAY 'Datetime of Creation', task.datetime_of_creation
            CALL FUNCTION displayTask(task)
            found = TRUE   
        ENDIF
    ENDWHILE
    close taskFileReader
    DISPLAY 'Number of Task(s) Created :', found

    IF (found = FALSE) THEN
        DISPLAY 'No Record Found. Add New Task Now!'
    ENDIF
ENDFUNCTION

-----------------------------------------------------------------------------

//Function for Admin to Read All Task of the Users
FUNCTION readAllTask() 
    DECLARE task as Task Struct
    DECLARE taskFileReader as file pointer
    DECLARE fileName as character pointer
    DECLARE fileHandling_method as character pointer
    DECLARE createFileIfNotExist as integer
    DECLARE checkFileExistence(fileName, fileHandling_method, createFileIfNotExist) as function

    taskFileReader = CALL FUNCTION checkFileExistence("task_record.txt", "r", 0)

    WHILE (read task from the file with the size of Task using taskFileReader)
        DISPLAY 'Username:', task.username
        DISPLAY 'Task ID:', task.taskId
        DISPLAY 'Datetime of Creation:', task.datetime_of_creation
        CALL FUCNTION displayTask(task)
    ENDWHILE
    close taskFileReader
ENDFUNCTION

-----------------------------------------------------------------------------


//Function to Display Tasks of the User
DECLARE task as Task Struct
FUNCTION displayTask(task) 
    DISPLAY 'Category:', task.category
    DISPLAY 'Title:', task.title
    DISPLAY 'Description:', task.description
    DISPLAY 'Status:', task.status_code
    DISPLAY 'Priority:', task.priority_code
    DISPLAY 'Deadline (DD/MM/YYYY):', task.deadline.day, task.deadline.month, task.deadline.year
ENDFUNCTION


-----------------------------------------------------------------------------

//Function To Display Current Date & Time
DECLARE datetime as Struct tm
FUNCTION displayDatetime(datetime)
    DISPLAY datetime.tm_mday, datetime.tm_mon + 1, datetime.tm_year + 1900
    DISPLAY datetime.tm_hour, datetime.tm_min, datetime.tm_sec
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Display Current Task Status Code
DECLARE statusCode as integer
FUNCTION displayStatusCode(statusCode) 
    CASE OF statusCode
        1:
            return "Not Started"
            break

        2:
            return "In Progress"
            break

        3:
            return "Done";
            break

        4:
            return "Canceled"
            break
    ENDCASE
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Display Current Task Priority Code
DECLARE priorityCode as integer
FUNCTION displayPriorityCode(priorityCode)
    CASE OF statusCode
        1:
            return "Low"
            break

        2:
            return "Normal"
            break

        3:
            return "Slightly Urgent"
            break

        4:
            return "Urgent"
            break
    ENDCASE
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Edit Previous Task
DECLARE username as Character pointer
FUNCTION updateTask(username) 
    DECLARE searchKey as character array with length of 256
    DECLARE task as Task Struct
    DECLARE taskFileReader as file pointer
    DECLARE taskFileWriter as file pointer
    DECLARE found as integer
    DECLARE taskId as integer
    DECLARE confirmTask(username, task) as function

    set found as FALSE
    flush the input stream
    DISPLAY 'Task ID to be edited :'
    READ searchKey
    taskId = convert searchKey to integer

    taskFileReader = CALL FUCNTION checkFileExistence("task_record.txt", "r", 0)
    open temp_task_record.txt in write mode using taskFileWriter 

    WHILE (read task from the file with the size of Task using taskFileReader)
        IF ((task.username is same as username) AND (task.taskId == taskId) THEN
            found = found + 1
            DISPLAY 'Task ID:', task.taskId
            DISPLAY 'Datetime of Creation:', task.datetime_of_creation
            CALL FUCNTION confirmTask(username, task)
        ENDIF
        write task into the file with the size of Task using taskFileWriter
    ENDWHILE
    close taskFileReader
    close taskFileWriter
    DISPLAY 'Done!'
    remove task_record.txt
    rename temp_task_record.txt to task_record.txt

    IF (found = FALSE)
        DISPLAY  'No Record Found With the Task ID. Please Try Again!'
    ENDIF
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Search Task Using Any Keywords Which Related to the Task
DECLARE username as Character pointer
FUNCTION searchTask(char *username)
    DECLARE searchKey as character array with length of 256
    DECLARE searchSource as character array with length of 1256
    DECLARE task as Task Struct
    DECLARE taskFileReader as file pointer
    DECLARE found as integer

    set found as FALSE
    flush the input stream
    DISPLAY 'Search :'
    READ searchKey
    convert searchKey into lowercase

    taskFileReader = CALL FUNCTION checkFileExistence("task_record.txt", "r", 0)
    WHILE (read task from the file with the size of Task using taskFileReader)
        copy character string from task.title to searchSource
        concatenate searchSource and task.description
        convert searchSource to lowercase

        IF (task.username is same as username) AND (searchSource is same as searchKey)) THEN
            DISPLAY 'Task ID:', task.taskId
            DISPLAY 'Datetime of Creation:', task.datetime_of_creation
            CALL FUNCTION displayTask(task)
            found = found + 1
        ENDIF
    ENDWHILE
    close (taskFileReader)
    DISPLAY 'Number of Task(s) Found :', found

    IF (found as FALSE) THEN
        DISPLAY 'No record found. Add new task now:'
    ENDIF

ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Sort Tasks
DECLARE username as Character pointer
FUNCTION sortTask(username) 
    DECLARE sortChoice as integer
    DECLARE orderChoice as integer
    DECLARE taskFileReader as file pointer
    DECLARE task as Task Struct Pointer
    DECLARE taskCopy as Task Struct
    DECLARE taskCount as integer

    DISPLAY  '--- Sort By ---'
    DISPLAY '[ 1 ] - Title'
    DISPLAY '[ 2 ] - Status'
    DISPLAY '[ 3 ] - Priority'
    DISPLAY '[ 4 ] - Deadline'
    DISPLAY '[ 5 ] - Datetime of Creation'
    DISPLAY '[ 0 ] - Back'

    sortChoice = CALL FUNCTION getChoiceNum(5, 0)

    IF (sortChoice = TRUE) THEN
        DISPLAY '--- Order By ---'
        DISPLAY '[ 1 ] - Descending'
        DISPLAY '[ 2 ] - Ascending'
        orderChoice = CALL FUNCTION getChoiceNum(2, 1)

        taskFileReader = CALL FUNCTION checkFileExistence("task_record.txt", "r", 0)
        set taskFileReader position to end of file
        allocates memory of the total task size in taskFileReader to task

        LOOP i FROM 0 to taskCount STEP 1
            read task[i] from the file with the size of Task using taskFileReader
            NEXT i
        ENDLOOP

        CASE OF sortChoice
            1:
                CALL FUNCTION sortByTitle(taskCount, task, taskCopy, orderChoice-1)
                break

            2:
                CALL FUNCTION sortByStatusCode(taskCount, task, taskCopy, orderChoice-1)
                break

            3:
                CALL FUNCTION sortByPriorityCode(taskCount, task, taskCopy, orderChoice-1)
                break

            4:
                CALL FUNCTION sortByDeadline(taskCount, task, taskCopy, orderChoice-1)
                break
            
            5:
                CALL FUNCTION sortByDatetimeOfCreation(taskCount, task, taskCopy, orderChoice-1)
                break

            0: break
        ENDCASE

        LOOP i FROM 0 To taskCount STEP 1
            IF (task[i].username is same as username) THEN
                DISPLAY 'Task ID:', task[i].taskId
                DISPLAY 'Datetime of Creation:', task[i].datetime_of_creation
                CALL FUNCTION displayTask(task[i])
            ENDIF
            NEXT i
        ENDLOOP

        close taskFileReader
    ENDIF
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Sort the Task by the Task Status Code
DECLARE taskCount as integer
DECLARE task as Task Struct Pointer
DECLARE taskCopy as Task Struct
DECLARE ascendingOrder as integer
FUNCTION sortByStatusCode(taskCount, task,taskCopy, ascendingOrder)
    DECLARE i as integer
    DECLARE j as integer

    LOOP i FROM 0 To taskCount STEP 1
        LOOP j FROM i+1 To taskCount STEP 1
            IF (ascendingOrder = TRUE)  THEN 
                IF (task[i].status_code > task[j].status_code) THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
                ENDIF
            ELSE 
                IF task[i].status_code < task[j].status_code THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
                ENDIF
            ENDIF
            NEXT j
        ENDLOOP
        NEXT i
    ENDLOOP
ENDFUNCTION

-----------------------------------------------------------------------------

//Function to Sort the Task by the Task Priority Code
DECLARE taskCount as integer
DECLARE task as Task Struct Pointer
DECLARE taskCopy as Task Struct
DECLARE ascendingOrder as integer
FUNCTION sortByPriorityCode(taskCount, task, taskCopy, ascendingOrder)
    DECLARE i as integer
    DECLARE j as integer

    LOOP i FROM 0 To taskCount STEP 1
        LOOP j FROM i+1 To taskCount STEP 1
            IF (ascendingOrder = TRUE)  THEN 
                IF (task[i].priority_code > task[j].priority_code) THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
                ENDIF
            ELSE 
                IF task[i].priority_code < task[j].priority_code THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
                ENDIF
            ENDIF
            NEXT j
        ENDLOOP
        NEXT i
    ENDLOOP
ENDFUNCTION

----------------------------------------------------------------------------------------------------------------

//Function to Sort the Task by the Task Title
DECLARE taskCount as integer
DECLARE task as Task Struct Pointer
DECLARE taskCopy as Task Struct
DECLARE ascendingOrder as integer
FUNCTION sortByTitle(taskCount, task, taskCopy, ascendingOrder)
    DECLARE i as integer
    DECLARE j as integer

    LOOP i FROM 0 To taskCount STEP 1
        LOOP j FROM i+1 To taskCount STEP 1
            IF (ascendingOrder = TRUE)  THEN 
                IF ( task[i].title have alphabetically earlier letters compared to task[j].title ) THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
                ENDIF
            ELSE 
                IF (task[j].title have alphabetically earlier letters compared to task[i].title) THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
                ENDIF
            ENDIF
            NEXT j
        ENDLOOP
        NEXT i
    ENDLOOP
ENDFUNCTION

----------------------------------------------------------------------------------------------------------------

//Function to Sort the Task by the Deadline

DECLARE taskCount as integer
DECLARE task as Task Struct Pointer
DECLARE taskCopy as Task Struct
DECLARE ascendingOrder as integer
FUNCTION sortByDeadline(taskCount, task, taskCopy, ascendingOrder)

    LOOP i FROM 0 To taskCount STEP 1
        LOOP j FROM i+1 To taskCount STEP 1
            Date date_i = task[i].deadline
            Date date_j = task[j].deadline
            IF (ascendingOrder = TRUE) THEN
                IF ((date_i.day + date_i.month * 100 + date_i.year * 1000) > (date_j.day + date_j.month * 100 + date_j.year * 1000)) THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
                ENDIF
            ELSE
                IF ((date_i.day + date_i.month * 100 + date_i.year * 1000) < (date_j.day + date_j.month * 100 + date_j.year * 1000)) THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
            ENDIF
            NEXT j
        ENDLOOP
        NEXT i
    ENDLOOP
ENDFUNCTION

----------------------------------------------------------------------------------------------------------------

//Function to Sort the Task by the date and local time of creation

DECLARE taskCount as integer
DECLARE task as Task Struct Pointer
DECLARE taskCopy as Task Struct
DECLARE ascendingOrder as integer
FUNCTION sortByDatetimeOfCreation(taskCount, task, taskCopy, ascendingOrder)

    LOOP i FROM 0 To taskCount STEP 1
        LOOP j FROM i+1 To taskCount STEP 1
            IF (ascendingOrder = TRUE) THEN
                IF (time_i > time_j) THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
                ENDIF
            ELSE
                IF (time_i < time_j) THEN
                    taskCopy = task[i]
                    task[i] = task[j]
                    task[j] = taskCopy
            ENDIF
            NEXT j
        ENDLOOP
        NEXT i
    ENDLOOP
ENDFUNCTION

----------------------------------------------------------------------------------------------

//Function to Delete Task

DECLARE username as character pointer
FUNCTION deleteTask(username)
    DECLARE searchKey as character array with length of 256
    DECLARE task as Task Struct
    DECLARE taskFileReader as file pointer
    DECLARE taskFileWriter as file pointer
    DECLARE found as integer
    DECLARE deleteChoice as integer

    set found as FALSE
    flush the input stream
    DISPLAY 'Task ID to be deleted :'
    READ searchKey
    convert searchKey into integer

    taskFileReader = CALL FUNCTION checkFileExistence("task_record.txt", "r", 0)
    open temp_task_record.txt in write mode using taskFileWriter 

    WHILE (read task from file with the size of Task using taskFileReader)
        IF (task.username is same as username) THEN
            IF (task.taskId == taskId) THEN
                found = TRUE
                DISPLAY 'Task ID:', task.taskId
                DISPLAY 'Datetime of Creation:', task.datetime_of_creation
                CALL FUNCTION displayTask(task)
                DISPLAY 'Confirm Delete ?'
                DISPLAY '[ 1 ] - Delete'
                DISPLAY '[ 0 ] - Back'
                deleteChoice = CALL FUCNTION getChoiceNum(1, 0)
                IF (deleteChoice = TRUE) THEN
                    DISPLAY 'Deleting task...'
                    continue
                ENDIF
            ELSE
                IF (task.taskId > taskId) THEN
                    task.taskId = task.taskId - 1
                ENDIF
            ENDIF
        ENDIF
        write task into the file with the size of Task using taskFileWriter
    ENDWHILE
    close taskFileReader
    close taskFileWriter
    DISPLAY ('Done!')
    remove task_record.txt
    rename temp_task_record.txt to ask_record.txt
    IF (found = FALSE) THEN
        DISPLAY 'No record found with the task id. Please try again!'
    ENDIF
ENDFUNCTION

----------------------------------------------------------------------------------------------

INCLUDE stdio.h as header file
INCLUDE account.h as header file
INCLUDE menu.h as header file
INCLUDE file.h as header file
INCLUDE userDataInjection.h as header file
INCLUDE user.h as header file
INCLUDE admin.h as header file

FUNCTION welcomePage()
    DECLARE option as Integer
    DECLARE maxChoice as Integer
    DECLARE minChoice as Integer
    DECLARE getChoiceNum(maxChoice, minChoice) as Function
    DECLARE userOne as Account Struct
    DECLARE loginUser() as Function
    DECLARE registration() as Function


    DOWHILE (option == 2)
        DISPLAY '*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*'
        DISPLAY 'Welcome to Goldfish Task Management System!'
        DISPLAY '*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*'
        DISPLAY '[ 1 ] - Login'
        DISPLAY '[ 2 ] - Register'
        DISPLAY '[ 0 ] - Exit
        
        option = CALL FUNCTION getChoiceNum(2,0)

        CASE OF option
            1: 
                CALL FUNCTION loginUser()
                break
            
            2:
                CALL FUNCTION registration()
                break
            
            0:
                exit the program
                break
        ENDCASE
    ENDDO
ENDDO