flotwig / cs-2340 Goto Github PK

Create your team's Android Project and Import into Git
Create an opening or welcome screen which has options for Login and Registration. You may have some other method of differentiating login and registration, if you do not want an opening screen.
If someone selects Login, then you should display a way to enter the user name and password.
If someone requests login, you should check for the correct user name and password. For this first milestone, you may have a hard coded user with name "user" and password "pass" to check against.
If the login matches user name / password then go to your application. Otherwise, notify of the bad login attempt.
Canceling the login (press Cancel or going back a screen for example) will close out the login attempt , but no information is recorded and the application does not start up. Note here you are not explicitly required to have a cancel button, just a way to back out of the login.
Once in the application, there should be a way to logout. After logging out, the application should return to the welcome / opening page.

You should go to Assignment 3, and download the M3.zip file. Extract the file into your IDE project directory. If using Intelli-J, I have included my idea files so you can import the project. If using a different IDE, or coding from the command line, simply import the code files.

If you examine the project view, you will see there are packages for model, view, and controller.

If you run the project, it should build and execute normally. You should be able to add a student and see the list update.

Create a Context Diagram for the system
Brainstorm and list 10 user stories (title only) You may have fewer than 10 user stories if you can cover the entire system in fewer.
Each person on the team pick 1 user story and fully elaborate it (this is an individual grade, so you do not have to cover for a team mate). This includes the acceptance scenarios.

Your customer likes the application so far, but they want one minor change. They want to include the student's class standing (freshman, sophomore, etc.) This will require a change in each component (Model, View and Controller).

Normally when maintaining code and making feature enhancements and bug fixes, you can start wherever you like in the stack. I usually like to start with the Model.

Each team member should add a text file to the top level directory labeled readme.pn.txt where the pn would be p1, p2, p3, p4 or p5 based upon which person you are for the lab. The contents of the file can really be anything, but should include your name and email. Each team member should delete the text file useless.pn.txt where pn is p1,p2, p3, p4 or p5 based on your team member number. Do NOT delete the wrong files!!

Use good descriptive Log comments for your changes/commits

Roll back changes by viewing your original branch from an earlier step. Verify that none of the changes you have made are in the project version you checked out.

View Git logs. You can do this on github by viewing the blame and graphs provided
View a diff between two versions of a file
Keep playing with git until you feel comfortable. You will probably be using it extensively for the remainder of the semester.

Now we have to make the view cooperate with the model. To do this, we must add items to the StudentEditController class (since this is the controller for our view).

Add an @FXML reference to the widgets you added for class standing. This is how you will pull data out of the widget to pass to the model. Be sure the spelling for the fxid matches what is in the .fxml file exactly.
Edit the initialize method to handle any start up code you need. If you used a combobox like me, this is where you will populate the box with the different classes (Freshman, etc). Remember that calling values() on an enum will give you an array. You will need to wrap this in an ObservableList. I made a static helper function that did that for me in the model.
Edit the setStudent method to set your widget to a default value
Edit the OK button press to pull the information out of your new widget and put into the student instance.
If you used a free text entry field, you will need to edit the isInputValid method to check that a valid class was entered. If you used a constrained widget like radio buttons or combo box where it is impossible to enter a bad value, then you do not have to do any validation.
Now run the app. You should be able to enter new students and their standing and see it reflected in the UI. if not, then check your code through the complete stack. Are you calling the setters in the model to update the information? Are you pulling the information out of the widget correctly?

Each individual team member will create a build file using gradle that will allow you to perform key tasks to build the application. Name your file with your gtid.gradle for instance: gburdell3.gradle Store your file in the repository,

To run gradle with your file (build.gradle is the default if no file specified) use the -b option, for example: gradle -bgburdell3.gradle

First, each team member should install Gradle onto their machine. Instructions are in the gradle manual at: external link: http://www.gradle.org/

The manual and documentation on the gradle site covers most of the features of gradle. For this lab, we will only be using the most basic of Gradle features and the Java plugin.

You will need to create an executable jar for the project. To do that, you will need to create a manifest. If you are unfamiliar with manifests, then see the official tutorial at: external link: http://docs.oracle.com/javase/tutorial/deployment/jar/

The application you are building also uses packages. You will need to understand how to use packages, as all professional Java projects use them extensively. Again, if you unfamiliar with packages, see the official tutorial at: external link: http://docs.oracle.com/javase/tutorial/java/package/index.html

Your build file should support the following tasks:

compileJava compiles and builds the project
compileTest compiles the unit tests for the project
javadoc creates the html documentation for the project
clean removes all the files created by this project
jar creates the executable jar file for this project
The jar task should be the default if no task is designated when running gradle. Otherwise, gradle will execute the task you request, for example: gradle compileJava will compile your java project.

Now you will need to add some widgets to the view so that when adding a new student, you can get the class standing from the user. Open the StudentEditDialog.xml file.

You will see that the dialog is laid out in a grid layout with labels and input fields. You will need to add to the grid some way to input the class standing. I used a combobox, but 4 radio buttons would work. You could use a text field and type in the standing, but that is error prone and you would need to validate that an incorrect entry was not made.

Once you have made the changes to the screen be sure and save the .fxml file.

Now you should be able to run the app again, just to make sure everything is ok. You should be able to hit the add student button and your dialog should pop up with your new UI features showing. It wont actually do anything yet, and if you used a combobox like me, it won't have any values in it. To make the display actually work, we have to edit one more class, the controller.

Brainstorm candidate classes/objects for the domain model. Filter those to get rid of inappropriate objects. Create the Domain Model for the application. Use the project description to brainstorm objects. List primary attributes. Note the stereotype of the classes. Annotate relationships between objects (which objects need to use other objects). Show any multiplicity requirements. There is only one domain model required, so this is a team effort.

If you examine the src directory, you will see the files Person1.java Person2.java Person3.java Person4.java Person5.java (located in the edu.gatech.cs2340.antlab.person package)

Each person on the team should choose ONE of these so that everyone is working on a different file.

Now examine your individual file and complete the required method. The javadoc comment will explain what has to be done.

Commit your changes and push back to Git. Now each team member should edit the file edu.gatech.cs2340.antlab.pkg1.AntLabMain.java at the line indicated. You are basically sending your name to the constructor of the class you edited previously. Since you are all editing the same file, you will need to handle any merge requirements yourselves. You might want to get together and commit files to force a merge so you get some practice doing merges. You will run into them during the project.

Add the registration screen to your app. A new user should be able to register by entering their information (like name, id, and password). If accepted, the new user should be added to the system. If cancelled, the user should not be added.

During registration, the new user may designate their account type (User, Worker, Manager or Admin). In a real application, we would have controls for these, but for this class project, we will let the individual enter their capabilities during registration.

When registration is working, you may remove the hard-coded user/pass from the app.

You should also have the ability for a user to create and edit their profile. Their profile consists of all their information that the application must maintain like email address, home address, title, etc.

NOTE THAT PERSISTENCE IS NOT REQUIRED AT THIS POINT. IT IS OK TO HAVE TO RE-ENTER USERS FROM SCRATCH EACH TIME THE APPLICATION IS STARTED.

Since the customer's request is to add information to the Student, we can focus on the Student class.

To support the class standing, we will first need to create a new class named ClassStanding which is an enum with the values FRESHMAN, SOPHOMORE, JUNIOR, and SENIOR. Give each class a two character representation "FR", "SO", "JR" and "SR".
Now add an attribute to Student which holds the ClassStanding enum.
Add getter and setter for the ClassStanding
Make a new 3 param constructor which includes name, major and class standing. Keep the old two param constructor for backwards compatibility and use constructor chaining to give a default class standing of Freshman.
Change the toString method to contain the class standing also.
At this point the model should be runnable and we should see the changes reflected in the list. Go ahead and run the app at this point. You should see all the students listed as before except with their classes shown. If you don't see the classes, be sure your constructor chaining is passing the freshman value to the 3 param version. Also be sure you added the class standing to the toString method.