Description

• This page displays how it is planned to proceed throughout the development process of Zenith App.

• For project plan tracking, ProjectLibre is mainly used and general scheme of the project is divided into subtasks.

• Necessary charts describing the process and general partition tasks of projects are listed and explained at the bottom of this page.

• You can find the ProjectLibre file of the project plan in our repository as named Zenith_Project_Plan.pod here.

Project Plan Scheme (Gantt Chart & Network Chart)

Gantt Chart

• Here general tasks and their corresponding sub-tasks are shown through the expected timeline of the project. It is important to note that there will be more detailed sub-tasks as the project is developed. There will be parts to be added and parts to be changed while implementing the app.
• In order to catch expected deadlines required by CmpE352 course schedules, non-sequential tasks shall be executed in parallel and those tasks are displayed in Gantt Chart.
• As an another important note, specified deadlines for tasks and overall project can show elastic behaviors as a result of CmpE352 Course's state of affairs throughout the semester. Therefore, deadlines for tasks include possible error margins for latencies, especially for implementation task.

Network Chart

• In Network Chart, dependencies among the general are displayed.
• There are two review tasks associated with Requirement Specification task and Software Design task. Since reviews can be executed parallel with succeeding tasks, they don't create any sequential dependencies after completion dates.
• Software Design and UI/UX tasks are not linked with sequential dependency since UI/UX Design task should start to be executed while Software Design task is in process as the team planned.
• For the implementation phase of the project, there will be three different teams for each branch and these teams will always be in contact through their development actions.

Task Explanations

Milestone 1

This task mostly covers Requirement Specification and creation of Scenarios and Mock-Ups.

Software Design

This task covers where team creates UML Diagrams for different aspects of the project such as Use-Case, Class Diagrams, Sequence Diagrams for program behaviors. Here can be assessed as last point before the UI/UX Design.

1. Use-Case Diagrams
2. Class Diagrams
3. Sequence Diagrams

UI/UX Design

This task covers the process of creation of screens according the proceeding design steps that will constitute the overall application. It is important to note that this task is conducted just after the Software Design process. This work package completes the End of the Design Phase specified by our team.

UI/UX Design part is very much related to mockups and it can be checked out here.

End of the Design Phase

As it is stated above, we want to place a milestone before starting any development related task, where we can evaluate our progression and take necessary actions if needed.

Implementation

This task covers the main implementation part of the project that are designed at proceeding steps. It is splited into three main branches: Backend, frontend and mobile. These three main branches have their own teams with communicators between teams.

1. Backend

1.1. Getting Familiar with the Tools

Learning about the tools that will be used, DjangoRestFramework, Docker, etc. All team members in backend team will create a small practice application using DjangoRestFramework.

1.2. Bootstrap Backend Application

Setting the very basic version of the backend application and initializing the backend project with Django.

1.3. Login Endpoint

Creation of login endpoint and API methods for it.

1.4. Signup Endpoint

Creation of signup endpoint and API methods for it.

1.5. Unit Tests for Login & Signup Endpoints

Checking if the login and signup endpoints are working as planned comparing it with the test data with unit tests.

1.6. Database Initialization

After deciding on which Database to use, initialization and connection to the database will be completed. Firstly a managed database will be used for testing API purposes, then a dockerized, deployed database will be used with backend and frontend apps.

1.7. Dockerization

Backend application in the repository and a decided database image will be dockerized in separate containers. Docker Compose will be used to manage both containers.

1.8. Deployment to DigitalOcean

Another container will be built for the frontend/web application and it will be included in the compose file. This compose file will build the whole Zenith application's structure in our deployed machine in the DigitalOcean.

1.9. WikiData API Calls

Building the functions handling WikiData API calls for preparing the infrastructure of the semantic search operation in the application.

1.10. Pipeline for CD/CI

A pipeline managing CD/CI environment is required for development efficiency. A pipeline starting from the Github repository ending in our deployed machine will be created using Github Actions.

1.11. The Milestone

Every task that has done to this point will be a part of the Customer Milestone 2.

1.12. Post Methods

Post methods include handling all user operations about posts such as liking, bookmarking, etc. These operations along with the storage actions will be implemented for posts.

1.13. User Profile Endpoint

User Profile methods include handling all operations such as viewing profile with profile's posts and attributes, following operations, etc. These operations along with the storage actions in the database will be implemented for user profiles.

1.14. Feed Endpoint

Feed methods include handling all operations such as viewing user specific feed, creating posts, etc. These operations mostly about database interactions will be implemented.

1.15. Search Logic

Search in our app will be implemented with a semantic search logic using WikiData API calls. API calls should be defined in previous Customer Milestone 2. The designed search logic will be implemented which includes entity selection by user and keyword list search.

1.16. Search Endpoint

Search endpoint is created for Customer Milestone 2 with mock purpose. API methods will be well defined at this stage.

1.17. Unit Tests for Search Endpoint

Search endpoint will be again tested with unit tests such as other endpoints.

2. Frontend

2.1. Bootstrap Frontend Application

The first version of the frontend application is initialized. It does not include much however this is the foundation which we will build upon.

2.2. Library Determination

Determining which libraries to use in the implementation of the application. Picking the right libraries makes our job easier. We picked libraries like vite, and react router. Libraries can be seen here

2.3. Style Tokens

Creating the style tokens which include typography and colors. Most of the other work depend on this task because we need to standardized style for every thing on the front end.

2.4. Routes Determination

Routes are the ways which the users navigate through our application.

2.5. React Routes Creation

After determining on routes, we used React Router to handle the routing process.

2.6. Registration Page

Implementation of sign up page for the web which asks user to enter name, email, username, and password. The user can also navigate to login page from here.

2.7. Login Page

Implementation of log in page for the web which asks user to enter username and password to log in. The user can also navigate to register page from here.

2.8. Initial Deployment

Deployment of the application with the features that have been done to this point. In this phase the front end will be able to communicate with the back end for register, login and basic search.

2.9. The Milestone

Every task that has done to this point will be a part of the customer milestone 2.

2.10. Home Page

Implementation of home page for the web. This page will contain a feed consisting of posts, a button to create new post, button to get the user's profile or login and register button if the user is not logged in or registered.

2.11. New Post

Implementation of creating a new post for web. This interface will asks user for text and image(optional) to create a new post.

2.13. Edit Post

Implementation of editing a post after creating it for web. This interface will allow user to change stuff on an existing post.

2.14. Delete Post

Implementation of deleting a post that has created for web. This interface will allow user to delete an existing post.

2.15. Search

Implementation of searching operation for web. This search will do semantic search and get posts and relevant wiki info. For example, it will get information about Spider-man and posts about Spider-man, if the user searches Peter Parker.

2.16. Profile Page

Implementation of user profile page for web. This page will allow user to change his/her bio, view his/her personal info, delete his/her account or save changes.

3. Mobile

3.1. Bootstrap Mobile Application

Setting the very basic version of the mobile application. It gives an idea about the structure of the project and not more.

3.2. UI Library Determination

Determining which UI libraries to use in the implementation of the application. This is critical since it will be used through all the implementation of mobile application.

3.3. Registration Page

Implementation of sign up page for the mobile. There will be four fields on registration page: fullname, email, username, and password.

3.4. Login Page

Implementation of log in page for the mobile. There will be two field on login page: username and password. Additionally, there will be remember me checkbox if the user wants to be logged in after closing the application.

3.5. Home Page

Implementation of home page for the mobile. It will connect all the pages including login, signup, search, profile, and more. There will be a bar that helps navigating between various pages.

3.6. Navigation Between Pages

Implementation of the feature that provides navigation between the implemented pages(signup, login and home).

3.7. Storage Access to Mobile Devices

Implementation of the feature that provides access to a mobile devices' storage so that required data can be accessed. Being able to use the storage will be especially required for keeping users logged in by storing their tokens.

3.8. Communication with API

Implementation of communication with API. Communication with backend team will be crucial for this part. Token check for making sure if the user is a valid user will be implemented in this part.

3.9. Initial Deployment

Deployment of the application with the features that have been done to this point. For the demo, the deployed app we are going to show will be this.

3.10. The Milestone

Every task that has done to this point will be a part of the customer milestone 2.

3.11. New Post

Implementation of creating a new post for mobile. This functionality will be available for registered users.

3.12. Edit Post

Implementation of editing a post after creating it for mobile. As one expects, this functionality will be available for registered users.

3.13. Delete Post

Implementation of deleting a post that has created for mobile. As one expects, this functionality will be available for registered users.

3.14. Search

Implementation of searching operation for mobile. This functionality will be available for all the users. Search will provide the ability to retrieve information from WikiData and posts from the database. For example, it will get information about Spider-man and posts about Spider-man, if the user searches Peter Parker.

3.15. Profile Page

Implementation of user profile page for mobile. This functionality will be available for registered users. Non-registered users will be directed to login/signup page.

Milestone 2

After completion of a specific part of the implementation, we have our deliverable as initially deployed application where we wanted to place another milestone.

Specific parts are as follows:

1. Till the Creating Pipeline for CD/CI for the implementation part of the backend.
2. Till the Login page implementation for the implementation part of the frontend.
3. Till the Communication with API for the implementation part of the mobile.

Non-Functional Requirements Implementation

While implementing functional requirements such as implementation and tests & bugfixing, our team works on this part in parallel. Since this task is done at the background, this part is not added specifically to the plan. This task covers the main three sub-tasks defined by our team as Non-Functional Requirements, which are:

1. Security Requirements Implementation

2. Performance Requirements Implementation

3. Compatibility Requirements Implementation

Whole process starting from Implementation until the end of the Deployment includes necessary Security related actions to be taken, thus it is provided with more time than other two sub-tasks.

Performance Requirements Implementation and Compatibility Requirements Implementation sub-tasks are assessed more relevant with the Tests & Bug Fixes and Deployment tasks, thus they are conducted parallel with those main tasks.

Tests & Bug Fixes

After the completion of implementation, unit tests and compatibility related works should be handled in this period while also handling the deployment of the app. As team, we have decided to allocate one week after Implementation for this task together with deployment.

Tests will be done for each part of the implementation branch: backend, frontend, and mobile. Though there might be already conducted unit tests to this point, more will be done in order to be sure about the completeness of the project.

Deployment

This task covers the work where the deployment process will take place while conducting Tests & Bug Fixes. Here can be thought as the part where the team will be focusing the Security, Performance and Compatibility related issues before releasing the application.

Milestone 3

After completion of all development and releasing process, we have our deliverable as application where we wanted to place another milestone.

Milestones

Milestone 1 - 18.03.2024

• After Requirement Specification and Reviews, the first milestone shall be done and delivered at 18.03.2024 because the requirements and details of the project will be decided and boundaries will be known after Requirement Specification.

End of the Design Phase - 17.04.2024

• After Software Design and Reviews, another milestone that is other than the compulsory milestones shall be reached at 17.04.2024 and design part of the software that will be used in the implementation of Zenith App shall be concluded. It can be named also end of the design phase milestone.

Milestone 2 - 30.04.2024

• After End of the Design Phase, the next milestone shall be done and delivered at 30.03.2024 and this milestone, Milestone 2, shall cover the combination of design part and initial part of the implementation phase.

Milestone 3 - 14.05.2024

• After the Deployment of Zenith App, the project shall be successfully completed and the final milestone shall be reached.