4.

10 Relevant Code
4.10.1 Catalog Class

This is the final iteration of the “Catalog” class. This class is responsible for initialising the
observable collections as well as loading them, along with adding new stations, tasks or notes if
needed. The class is also in charge of organising all the tasks by the Station Ids so that selecting a
station will display all the tasks currently assigned to it.
We chose to have almost every attribute contained in a string type. The reason is due to the fact that
most attributes will be plain labels or descriptions, Those that only contained number
were not nessessary for anything else than to show the use what it contains, no calculation
or similar. The only attribute we choose to do different is ‘’ Date_Time’’ which contains the time
and date for when the task needs to be completed.

4.10.2 WebApiTaskTest

The class WebApiTaskTest uses a webservice to access and modify objects into the database. It can
retrieve data, display it, update or delete it by calling the respective methods for each operation. By
using Json, these operations are completed much faster than they would’ve been by using xml.
4.11 Database Design
A database is a shared collection of logically related data (and a description of this data),
designed to meet the information needs of an organization.
First step to create a database is finding entities and creating ERD. An entity relationship
diagram (ERD) shows the relationships of entity sets stored in a database. An entity in this context is
a component of data. In other words, ER diagrams illustrate the logical structure of
databases.

In order to identify entities to design the entity relationship diagram we turn to conceptual
classes in the domain model.

[Poza cu domain model aici]

In the Station database table we chose Station_Id as the primary key since each station has a unique
Id by which it can be identified, these being sorted ascendantly.

In the Task database table, the Task_Id is the primary key for the same reasons as with the Station
table. Here we have a foreign key,which is the Task_TO_StationID,it makes the connection between
Station table and the Task table. We need the Task_TO_StationID foreign key in the Task table so we
can assign specific tasks to specific stations.

4.12 Normalization
1st Normalization Form
A table in which the intersection of every column and record contains only one value.It is
critical in creating appropriate tables for relational databases. All subsequent normalization
forms are optional.
2nd Normalization Form
A table that is in 1st normalization form and in which the values of each nonprimarykey
column can be worked out from the values in all the columns that make up the primary key.
Only applies to tables with composite primary keys.
3rd Normalization Form
A table that is in 1st and 2nd normalization form and in which all nonprimarykey
column
can be worked out from only the primary key column(s) and no other columns.
The formal definition of 3rd normalization form, is a table that is in 1st and 2nd normalization
form and in which no nonprimarykey
column is transitively dependent on the primary key.
4.13 Architectural analysis
The structure of our system consist of three dependent parts. They are an Application,
Webservice and Database.
The first part represents windows store application. It consist of three layers: View ,
ViewModel and Model. In this architecture all the Views are connected to the Model through
ViewModel.
The second part consist of Webservice. It is an important part because our application gets
connected to the Database through Webservice.
The third part contains Database.This is the place where all the data is stored. It is divided
into four tables which are Station,Task,Notes and Logs.

Application:
● View
○ AddNoteView
○ AddTask View
○ Login
○ ToDoTaskPage
● ViewModel
○ Catalog
○ NotifyPropertyChange
● Model
○ Log
○ Notes
○ Station
○ StationTask

Web Service:
● Controllers
○ HomeController
○ LogsController
○ NotesController
○ StationsController
○ TasksController
○ ValuesController

Database:
● dbo.Log(table)
○ Log_Id
○ Description
○ Date_Time
○ StationID
○ TaskID
● dbo.Note(table)
○ Note_Id
○ Desc
○ TaskID
● dbo.Station(table)
○ Station_Id
○ Station_Name
● dbo.Task(table)
○ Task_Id
○ Task_Desc
○ Schedule
○ Register
○ StationID

4.14 Testing
All of our methods that required testing, changes data in the database. Therefor using
“UnitTesting” would result in more work than necessary, because every time the “UnitTest”
would be executed once and the test results would be positive, we would have to open the
database query and edit the data manually before running another test. The reason is
because there can only exist one copy of an object in the database.
All test that was done was done during the building of the code and after parts of the code
were completed. The code testing and GUI testing was done by us.

4.15 Overview of Elaboration phase

We started the elaboration phase by choosing a use case which has high risk,
high business value and important part in the core architecture. We chose the use case to be
AddTask. Then we decided to write it in fully dressed format which gives us
thorough information about it. After that we developed a domain model which is the most
important model which illustrates a visualization of the domain concepts, from that we were
able to proceed in elaboration by creating System Sequence Diagram showing the rough
interaction between the primary actor and the system. We then do the Design Sequence Diagram
for visualization of the process and a class diagram of this feature to see the structure
containing all the classes and methods. In the elaboration phase we explained the GRASP
patterns and the MVVM as well. We established our database and webservice, implemented
some of the use cases. We think that we did serious investigations in this phase, resolved
the highrisk elements and allowed us to implement the core architecture. Now that we have
the fundamental part of the program we can continue to build our features upon that, but this
does not mean we cannot return to change parts of the core architecture.
Our WebFacade (Persistency) methods started out to only contain “Post,Put,Delete, Update and Get”
methods for the “Task” class only, we quickly figured out that the better solution would be to make
the methods for the ‘’Notes’’, ‘’Logs’’ and ‘’Stations’’ classes as well.

5.Elaboration Iteration 2
[Trebuie ceva graph aici]

5.1 GUI Design

After the rough prototype, our client wanted from us something simple, easy to understand
and work with. At the beginning of our work we were focused entirely on the code in our
model and viewmodel. We had some fields and buttons to test our hard work ,but the actual
GUI design we left for the end. By doing that we have a clear vision of how the core program
should work and from there how it should look like.

Our main page when the user start the program is the login page.
Here the user can login in order to access the stations list and all the other features.
When the user click on the “Login” button after entering his creditentials, he is navigated to this page.

Here the user can access all the stations and see all the tasks assigned to each and every one of them
on the right side as well as add new tasks or check the logs and inspect the previously completed
tasks.If the user wants to go back he must click on the “Back” button,which is in the left upper
corner(The back button applies for all pages). The user can also click the ‘’Home’’ button to be taken
back to the login page, regardless of the page on which he was currently on, or the ‘’Refresh’’ button
to update the data on the current page.

Clicking on the ‘’Add Task’’ will redirect you to the AddTask page. On this page the user can add a task
manually. When the user fills out the required fields he must click on the “Add Task” button and with
that the task will be saved and added to the database.
By accessing the ‘’Go to Log’’ button on the main page, you’ll be taken on the Logs page. Simillar to
the main page, once the user selects a station, on the right side he’ll be able to see all the tasks that
have been completed for that particular station and the date at which they’ve been marked as
completed.

5.6 Think Out Loud testing

With all what we were able to do in time the application was ready to be tested by Andrew.
First we let him take a look at the application and let him go through the different features.
We wanted to see if the application was easy to understand without any guidence.
He gave us many new ideas on how we could continue and improve the application. He
would have liked if we could link the tasks to some sort of timer application that refreshes a task
every day/week/month at the time when it’s due for taking care of again. Unfortunately we do not
have the knowledge or skills to fulfill the task and create that kind of application.
He mentioned that it would be a good idea to present a storyboard if we are going to present
for him again, even though the application was easy to go through, a slight tutorial just to know what
the client is working with could always come in handy.
As a whole he was pleased with what we have done so far.

6. Conclusion

We have created an application that allows the user to store stations data to a database. Having
the stations data all stored in one place and that place being a database, reduces the time and resources
you need to spend managing all the mail and hardcopies with data. To make it even
less time consuming we have created a feature for the user to use, where he/she is able to
open a file with station data, the application will read in all data and display it to the user in a
listview, there he/she will be able to save that data to the database. With the overview feature
the use will be able to view all the stations in the database and the detailed tasks each station
contains.
The easy management of data was only one part of the task handed to us. The other part being
creating use of all the data.
This is where the ‘’Persistency’’ gets to be useful. The user is able to create a task and assign it to
a station in mere moments.
This part of the application eases the workflow of the user and the employees.
The teacher was overall satisfied with the application. We let him try out the application before we
started talking about it. He felt that most of it was easy to understand. There were some
suggestions from his side, some changes he would like to have. Most of those change we
would be able to make if we had more time, while we lack the knowledge to implement a few
of his ideas.

7. Personal evaluation of the process

M.Antonio-Alex

Looking at the project I am satisfied with what we have accomplished. In my opinion the project for
this semester was a good opportunity to practice what we have learned during the classes. Through the
project I got a better understanding of the MVVM and how to use it.
Even though we spend much time on planning our work flow, it was hard for us to keep up with the
plan while we had regular lessons each day. It resulted in some work being piled up and we had to use
a lot of time in the beginning of the assigned project time to catch up to our timeplan.It has been a
great experience to create an application where we are not the ones that determine the requirements.
Though i believe that our client expected much more than we are able to produce.
Since we were just a two man group, we didn’t have enough time to implement all of the features we
would’ve liked but we still consider that the overall requirements have been met

Despite me not finding the topic of the project particulary interesting or captivating, it certainly posed
a challenge. We had to apply a great amount of things that we’ve learned during our first two
semesters and come up with inovative solutions when certain problems arised. I’ve managed to get a
better grasp at understanding concepts such as MVVM, despite having to deal with such a consistent
amount of work in such a short period of time.It has been a great experience to create an application
where we are not the ones that determine the requirements. Though i believe that our client expected
much more than we are able to produce. We would’ve loved being able to add more features and more
functionality but I consider we’ve done a pretty good job so far.