LoginInfo

/**************************************************************************************************
 * Program Name   : Week 2 - Login Info
 * Author         : Terry Weiss
 * Date           : January 29, 2016
 * Course/Section : CSC264 - 001
 * Program Description: This program will create usernames and passwords for
 *     students at OCC using their first and last name. The username will be
 *     the student's first two letters of their first name, followed by the
 *     first three letters of their last name, followed by a random digit
 *     1 and 3. If either name is too short their full first/last name is used.
 *     All usernames are in all lowercase letters. The password will default to
 *     the user's first name (in all lower case letters). The usernames and
 *     passwords each in their own array. The user may create up to 10
 *     username/password combinations. Duplicate usernames are prevented by
 *     adding another digit (1, 2, or 3) onto the end of the duplicate username,
 *     thus creating a unique username. When the user stops creating usernames,
 *     all of the usernames and passwords are displayed on the screen.
 *
 * Methods:
 * -------
 * Main           - Reads the names, creates the login info and displays them
 * Prompt Name    - Prompts for a first and last name or quit value
 * Random Number  - Generates a random number within range (1 through 3 inclusive)
 * Generate ID    - Generates the ID using first and last name
 * Generate Pwd   - Generates the passwords using their first name in lower case
 * Unique ID      - Goes through ID list confirming each ID is unique or replacing
 * Display Logins - Displays a list of all the IDs and passwords
 **************************************************************************************************/

import java.util.Random;

class LoginInfoTTW
{

    /**********************************************************************************************
     * Method Name    : LoginInfo - Main
     * Author         : Terry Weiss
     * Date           : January 29, 2016
     * Course/Section : CSC264 - 001
     * Program Description: This method will read a name entered by the user. It
     *     then creates a new String with the name centered for console output,
     *     and displays it.
     *
     * BEGIN main
     *    Init location to 0
     *    Clear screen
     *    Display input title
     *    Prompt name {prompt name method, returning name array}
     *    WHILE (name is array of two elements)
     *        Generate and assign ID to element in ID list {generate ID method}
     *        Generate and assign password to element in Pwd list {generate pwd method}
     *        Increment location
     *        IF (array is full)
     *            Set name to array of one element
     *        ELSE
     *            Display blank line
     *            Prompt name {prompt name method}
     *            IF (first name is quit string) THEN
     *                Set ID at current location to quit string
     *            END IF
     *        END IF
     *    END WHILE
     *    Check all IDs are unique {uniqueID method}
     *    Clear screen
     *    Display output title
     *    Display all login info {display logins method}
     * END Read Name
     **********************************************************************************************/
    public static void main(String[] args)
    {
        //Local constants
        final int MAX_LOGINS   = 10;                //Maximum number of logins
        final String QUIT_STR  = "done";            //Sentinel value for ending input
        final int FIRST_NAME   = 0;                 //Location of first name in names array
        final int LAST_NAME    = 1;                 //Location of last name in names array
        final int MIN_ID_NUM   = 1;                 //Minimum legal number in ID
        final int MAX_ID_NUM   = 3;                 //Maximum legal number in ID

        //Local variables
        int location;                               //Location of ID/Password in their arrays
        String[] idList  = new String[MAX_LOGINS];  //List of IDs
        String[] pwdList = new String[MAX_LOGINS];  //List of passwords
        String[] names;                             //First and last name of student

        //Utility class objects
        final Library64 myLib  = new Library64();   //Console control library
        final Random generator = new Random();      //Random number generator

        /*************************************START MAIN METHOD************************************/

        //Init location to 0
        location = 0;

        //Clear screen
        myLib.clrscr();

        //Display input title
        System.out.println("\n");
        System.out.println(Console.center("Name Entry"));
        System.out.println();

        //Prompt name {prompt name method, returning name array}
        names = promptName(QUIT_STR);

        //WHILE (name is array of two elements)
        while (names.length == 2)
        {

            //Generate and assign ID to element in ID list {generate ID method}
            idList[location]  = generateID(names[FIRST_NAME], names[LAST_NAME], MIN_ID_NUM,
                                             MAX_ID_NUM, generator);

            //Generate and assign password to element in Pwd list {generate pwd method}
            pwdList[location] = generatePwd(names[FIRST_NAME]);

            //Increment location
            location++;

            //IF (array is full)
            if (location == MAX_LOGINS)
            {

                //Set name to array of one element
                names    = new String[1];
                names[0] = QUIT_STR;
            }
            else
            {

                //Display blank line
                System.out.println();

                //Prompt name {prompt name method}
                names = promptName(QUIT_STR);

                //IF (first name is quit string) THEN
                if(names[0].equals(QUIT_STR))
                {

                    //Set ID at current location to quit string
                    idList[location] = QUIT_STR;
                }

            }//END IF

        }//END WHILE

        //Check all IDs are unique {uniqueID method}
        uniqueID(idList, MIN_ID_NUM, MAX_ID_NUM, QUIT_STR, generator);

        //Clear screen
        myLib.clrscr();

        //Display output title
        System.out.println("\n");
        System.out.println(Console.center("Login Info"));
        System.out.println();

        //Display all login info {display logins method}
        displayLogins(idList, pwdList, QUIT_STR);

    }//end method main


    //Input methods

    /**********************************************************************************************
     * Method Name    : LoginInfo - Prompt Name
     * Author         : Terry Weiss
     * Date           : January 29, 2016
     * Course/Section : CSC264 - 001
     * Program Description: This method will prompt for the student's first
     *     name. If it's not the quit string, it'll prompt for the last name and
     *     return an array of the full name. Otherwise, it'll return a
     *     one-element array with quit string.
     *
     * BEGIN Prompt Name
     *    Prompt first name
     *    IF (first name isn't quit strig) THEN
     *        Instantiate two-element array
     *        Assign first name to element 0
     *        Prompt last name to element 1
     *        Return array of first and last names
     *    ELSE
     *        Return one-element array with quit string
     *    END IF
     * END Prompt Names
     **********************************************************************************************/
    private static String[] promptName(String quitString)
    {
        //Local constants
        final int FIRST_NAME   = 0;     //Location of first name in names array
        final int LAST_NAME    = 1;     //Location of last name in names array

        //Local variables
        String[] names;                 //Student's first and last name, or quit string
        String input;                   //User's initial input to check against quit string

        /*******************************  Start Method Prompt Name  *******************************/

        //Prompt first name
        System.out.print("\t\tEnter first name (\"" + quitString + "\" to quit):  ");
        input = Keyboard.readString();

        //IF (first name isn't quit strig) THEN
        if (!input.equalsIgnoreCase(quitString))
        {

            //Instantiate two-element array
            names = new String[2];

            //Assign first name to element 0
            names[FIRST_NAME] = input;

            //Prompt last name to element 1
            System.out.print("\t\tEnter last name:                    ");
            names[LAST_NAME]  = Keyboard.readString();
        }
        else
        {

            //Return one-element array with quit string
            names    = new String[1];
            names[0] = quitString;

        }//END IF


        return names;

    }//end method Prompt Name


    //Calculation methods

    /**********************************************************************************************
     * Method Name    : LoginInfo - Random Number
     * Author         : Terry Weiss
     * Date           : January 29, 2016
     * Course/Section : CSC264 - 001
     * Program Description: This method will generate a random number between given min and max.
     *     If the maximum is less than the minimum, the minimum will be returned.
     *
     * BEGIN Random Number
     *    IF (min >= max) THEN
     *        Set number to min
     *    ELSE
     *        Generate a random number between min and max and set it to number
     *    END IF
     *    Return number
     * END Random number
     **********************************************************************************************/
    private static int randomNumber(int min, int max, Random generator)
    {
        //Local constants

        //Local variables
        int number;         //Random number to be returned

        /******************************  Start Method Random Number  ******************************/

        //IF (min >= max) THEN
        if (min >= max)
        {

            //Set number to min
            number = min;
        }
        else
        {

            //Generate a random number between min and max and set it to number
            number = generator.nextInt(max - min + 1) + min;
        }

        return number;

    }//end method Random Number


    /**********************************************************************************************
     * Method Name    : LoginInfo - Generate ID
     * Author         : Terry Weiss
     * Date           : January 29, 2016
     * Course/Section : CSC264 - 001
     * Program Description: This method will generate an ID using the student's first name,
     *     last name and a generated number.
     *
     * BEGIN Generate ID
     *    Init ID to an empty string
     *    IF (first name is shorter than max chars) THEN
     *        Append to ID full first name
     *    ELSE
     *        Append to ID first two letters of first name
     *    END IF
     *    IF (last name is shorter than max chars) THEN
     *        Append to ID full last name
     *    ELSE
     *        Append to ID first three letters of last name
     *    END IF
     *    Generate and append a random digit between min and max
     *    Return ID
     * END Generate ID
     **********************************************************************************************/
    private static String generateID(String firstName, String lastName,
                                        int min, int max, Random generator)
    {
        //Local constants
        int FIRST_NAME_CHARS = 2;   //Number of letters used from first name
        int LAST_NAME_CHARS  = 3;   //Number of letters used from last name

        //Local variables
        String id;          //Student's ID

        /*******************************  Start Method Generate ID  *******************************/

        //Init ID to an empty string
        id = "";

        //IF (first name is shorter than max chars) THEN
        if (firstName.length() <= FIRST_NAME_CHARS)
        {

            //Append to ID full first name
            id += firstName.toLowerCase();
        }
        else
        {

            //Append to ID first two letters of first name
            id += firstName.toLowerCase().substring(0, FIRST_NAME_CHARS);
        }

        //IF (last name is shorter than max chars) THEN
        if (lastName.length() <= LAST_NAME_CHARS)
        {

            //Append to ID full last name
            id += lastName.toLowerCase();
        }
        else
        {

            //Append to ID first three letters of last name
            id += lastName.toLowerCase().substring(0, LAST_NAME_CHARS);
        }

        //Generate and append a random digit between min and max
        id += randomNumber(min, max, generator);


        return id;

    }//end method Generate ID

    /**********************************************************************************************
     * Method Name    : LoginInfo - Generate Password
     * Author         : Terry Weiss
     * Date           : January 29, 2016
     * Course/Section : CSC264 - 001
     * Program Description: This method generates a password by converting the
     *     student's first name to lower case.
     *
     * BEGIN Generate Pwd
     *    Return first name in lower case
     * END Generate Pwd
     **********************************************************************************************/
    private static String generatePwd(String firstName)
    {
        //Local constants

        //Local variables

        /****************************  Start Method Generate Password  ****************************/

        //Return first name in lower case
        return firstName.toLowerCase();

    }//end method Generate Pwd


    //Data Management methods

    /**********************************************************************************************
     * Method Name    : LoginInfo - Unique ID
     * Author         : Terry Weiss
     * Date           : January 29, 2016
     * Course/Section : CSC264 - 001
     * Program Description: This method checks through each element of the ID
     *     list, comparing the current ID with the remaining IDs. If there is
     *     a duplicate, the compared ID gets changed by appending another
     *     random digit.
     *
     * BEGIN Unique ID
     *    IF (ID list is empty) THEN
     *        Display message that there are no logins entered
     *    ELSE
     *        FOR (each element left in ID list)
     *            FOR (each element left in ID list)
     *                IF (ID matches element) THEN
     *                    Append a random number in range to ID at current element
     *                END IF
     *            END FOR
     *        END FOR
     *    END IF
     * END Unique ID
     **********************************************************************************************/
    private static void uniqueID(String[] idList, int min, int max, String quitString,
                                    Random generator)
    {
        //Local constants

        //Local variables

        /********************************  Start Method Unique ID  ********************************/

        //IF (ID list is empty) THEN
        if (idList[0] == null)
        {

            //Display message that there are no logins entered
            System.out.println(Console.center("There are no logins entered."));
        }
        else
        {

            //FOR (each element left in ID list)
            for (int id = 0; id < idList.length - 1 && !idList[id].equals(quitString); id++)
            {

                //FOR (each element left in ID list)
                for (int comparedID = id + 1; comparedID < idList.length; comparedID++)
                {

                    //IF (ID matches element) THEN
                    if (idList[id].equals(idList[comparedID]))
                    {
                        //Append a random number in range to ID at current element
                        idList[comparedID] = idList[comparedID] + randomNumber(min, max, generator);

                    }//END IF
                }//END FOR EACH REMAINING ID
            }//END FOR EACH ID
        }//END IF (ID list is empty)

    }//end method Unique ID


    //Output methods

    /**********************************************************************************************
     * Method Name    : LoginInfo - Display Logins
     * Author         : Terry Weiss
     * Date           : January 29, 2016
     * Course/Section : CSC264 - 001
     * Program Description: This method displays each user ID and password
     *
     * BEGIN Display Logins
     *    IF (ID list is empty) THEN
     *        Display message that there aren't any logins
     *    ELSE
     *        Init login to 0
     *        Init pad to 0
     *        FOR (each ID)
     *            Set length to ID's length + prompt length
     *            IF (length > pad) THEN
     *                Set pad to length
     *            END IF
     *        END FOR
     *        FOR (each password)
     *            Set length to password's length + prompt length
     *            IF (length > pad) THEN
     *                Set pad to length
     *            END IF
     *        END FOR
     *        Calculate correct pad
     *        WHILE (login's ID in list isn't quit value and ID is less than ID list's length)
     *            Display ID at login
     *            Display password at login
     *            Increment login
     *        END WHILE
     *    END IF
     * END Display Logins
     **********************************************************************************************/
    private static void displayLogins(String[] idList, String[] pwdList, String quitString)
    {
        //Local constants
        final int PROMPT_LENGTH   = 21;     //Number of characters for prompt
        final int OUTPUT_COLUMNS  = 80;     //Number of columns in output window

        //Local variables
        int login;                          //Student's login's location
        int pad;                            //Left padding to center output
        int length;                         //Character length of longest output
        int ids;                            //Number of IDs that have been entered

        /*****************************  Start Method Display Logins  ******************************/

        //IF (ID list is empty) THEN
        if (idList[0] == null)
        {
            System.out.println(Console.center("There are no logins entered."));
        }
        else
        {

            //Init login to 0
            login = 0;

            //Init pad to 0
            pad   = 0;


            /*
             * The first for loop finds the longest ID length and also counts the number of IDs
             * that were entered so that the password loop stops at the same spot. This way
             * it's not necessary for the password list to have an entered quit string, and there is
             * no chance of a null pointer exception.
             */

            //FOR (each ID)
            for (ids = 0; ids < idList.length - 1 && !idList[ids].equals(quitString); ids++)
            {

                //Set length to ID's length + prompt length
                length = idList[ids].length() + PROMPT_LENGTH;

                //IF (length > pad) THEN
                if (length > pad)
                {

                    //Set pad to length
                    pad = length;
                }
            }

            //FOR (each password)
            for (int pwd = 0; pwd < pwdList.length - 1 && pwd < ids; pwd++)
            {

                //Set length to password's length + prompt length
                length = pwdList[pwd].length() + PROMPT_LENGTH;

                //IF (length > pad) THEN
                if (length > pad)
                {

                    //Set pad to length
                    pad = length;
                }
            }

            //Calculate correct pad
            pad = (OUTPUT_COLUMNS - pad) / 2;


            //WHILE (login's ID in list isn't quit value and ID is less than ID list's length)
            while (login < idList.length && !idList[login].equals(quitString))
            {

                //Display ID
                System.out.println(Console.padLeft(pad, "Student's ID:        " + idList[login]));

                //Display password
                System.out.println(Console.padLeft(pad, "Student's password:  " + pwdList[login]));

                //Display blank line
                System.out.println();

                //Increment login
                login++;
            }

        }//END IF (empty login list)
    }//end method Display Logins


}//end class LoginInfoTTW