biggujo / databases-fullstack-project

Todo List Manager

Enpoints

POST /login – login

Request

{
  "username": "string",
  "password": "string"
}

Response

{
  "id": "number",
  "username": "string"
}, 200

DELETE /logout – logout

Response

• HTTP 204 No Content

POST /register - register

Request

{
  "username": "string",
  "password": "string"
}

Response

{
  "id": "number",
  "username": "string"
}, 201

databases-fullstack-project's Issues

Add groups resource

Each group has tasks and users

Important notes:

• if a user is not in /groups/:id/users, reject access to /groups/:id/tasks;
• if a user is not in groups/:id/users, reject access to this route to the user;
• other users cannot join other users (a user only can join/leave the group if he and only he wants to)

Model:

• name of the group;
• array of Users model;
• array of tasks like in Tasks controller and Tasks model;
• timestamps (created_at, updated_at)

Routes:

• GET /groups – get all groups (array of groups);
• POST /groups – create new group;
• GET /groups/:id – get one group:

Schema of response of GET /groups/:id:

{
  "name": "string",
  "members": 123
}

• PUT /groups/:id – update group

Accepted data to PUT /groups/:id:

{
"name": "string",
}

• POST /groups/:groupid/users – add new user to the group (user joins). Works only if userid == current_user.id;

Accepted data to POST /groups/:groupid/users:

{
"id": 12345,
}

• DELETE /groups/:groupid/users/:userid – remove a user from the group (user leaves). Works only if userid == current_user.id;

• ALL /groups/:id/tasks – GET, POST, PUT like in tasks controller etc.

Add subtasks for tasks on backend

Subtasks:

• subtasks has the same scheme as the tasks;
• Task model has many Tasks;
• make work possible with the following routes:
  • private tasks of the user:
    • GET /api/tasks/:id/subtasks - get all subtasks;
    • POST /api/tasks/:id/subtasks - add a subtask;
    • PUT /api/tasks/:taskid/subtasks/:subtaskid - update a subtask;
    • DELETE /api/tasks/:taskid/subtasks/:subtaskid - delete a subtask;
  • group tasks:
    • GET /api/groups/:groupid/tasks/:id/subtasks - get all subtasks;
    • POST /api/groups/:groupid/tasks/:id/subtasks - add a subtask;
    • PUT /api/groups/:groupid/tasks/:taskid/subtasks/:subtaskid - update a subtask;
    • DELETE /api/groups/:groupid/tasks/:taskid/subtasks/:subtaskid - delete a subtask

Hint: maybe I've made a mistake in routes here, but the main point must be clear

Implement a query object for tasks

Set of methods:

• sort by name (ascending, descending);
• sort by deadline (ascending, descending);
• filter by actual status: only completed/only in progress/only overdue tasks (it means deadline has passed, but the task is still in progress);
• filter by date range (e.g. tasks between 2024-03-02 12:00 and 2024-04-05 12:00);
• pagination

Hint: dates can be compared as plain strings (e.g. of a query: "deadline >= 2024-03-02 12:00 and deadline <= 2024-04-05 12:00")

Steps to implement:

• create folder backend/query;
• create file backend/query/tasks_query.py;
• implement a class TasksQuery:
  • constructor accepts an object of initial scope of data;
  • methods (better to make private, but not essential):
    • like in Rails last homework

How to use this class:

• in tasks_controller.py in def index() write something like this (it is not tested to work, though):

def index():
  user_id = session.get("id")
  if user_id is None:
      return {'message': 'Unauthorized'}, 401

  parameters = request.args
  initial_scope = Task.query_user_tasks(user_id).all()

  query_object = new TasksQuery(initial_scope) # idk if it works. It is just a pseudocode
  scoped_data = query_object.call(parameters)

  return jsonify(json_list=[i.serialize for i in scoped_data])

How to test:

• download Postman: https://www.postman.com;
• create requests and use them:
  • authorise on GET http://localhost:6001/users:
  • create tasks on POST http://localhost:6001/tasks;
  • optionally: update tasks on PUT http://localhost:6001/tasks/:id;
  • test filter query on GET http://localhost:6001/tasks?param1=qweqwe&param2=qweqwe

Authorisation request:

Create tasks request:

Update task:

Main request to test queries:

---

Example of Query Object class in Rails:

# frozen_string_literal: true

class ServiceSubcategoryQuery
  attr_accessor :initial_scope

  def initialize(initial_scope)
    @initial_scope = initial_scope
  end

  def call(params)
    scoped = @initial_scope

    scoped = filter_by_name(scoped, params)
    scoped = filter_by_domain(scoped, params)
    sort_by_categories_amount(scoped, params)
  end

  private

  def filter_by_name(scoped, params)
    query = params[:query]

    scoped.where("categoryname ILIKE ?", "%#{query}%")
  end

  def filter_by_domain(scoped, params)
    domain = params[:domain]

    is_domain_empty = domain == "" || domain.nil?

    return scoped if is_domain_empty

    scoped.where(servicedomain_id: domain.to_i)
  end

  def sort_by_categories_amount(scoped, params)
    sort_order = params[:sort_by_services_amount] == "ascending" ? "ASC" : "DESC"

    scoped.left_joins(:services)
          .group("servicesubcategories.id")
          .order("COUNT(services.id) #{sort_order}")
  end
end

CRUD of private user tasks on frontend (route: /tasks)

Tasks:

• make localhost:6002/tasks work with API;
• add description for each tasks;
• open modal for each tasks on click

Page:

Add query object for groups

• sort by name: asc/desc;
• show only with more than N members;
• show joined groups

Add header

• links: home, todo (route : /todo), sign up (/signup), sign in (/signin)

Add groups on frontend

• /groups;
• /my-groups;
• fuzzy search

Frontend: add group page on /groups and /my-groups (no logic)

Add mock todo page with subtasks

Done:

• todo list on Redux;
• subtasks

Make cool home page

• [] customise home page:

Photo: https://www.shutterstock.com/image-photo/close-womans-hands-writing-spiral-600nw-525439534.jpg

Frontend: add footer

Make sign in form on /signin endpoint

https://chakra-ui.com/getting-started/with-formik

Add i18n on frontend with i18next (EN/UA)

• install library;
• initialise i18n;
• set up translation (EN/UA);
• Save preferred language in cookies/local storage:
  https://www.npmjs.com/package/i18next-browser-languagedetector
• use translation

https://www.i18next.com/overview/getting-started

Backend: Add Task resource

• router – /api/tasks (see example in the project with users);
• REST API CRUD operations;
• fields: id, text, is_completed, created_at, updated_at. All fields are nullable=false;
• validation (see user_schemas.py);

All points must work

Set up SQLAlchemy (for now, make on one endpoint GET for one model)

Flask Auth (backend)

• User model;
• /login, /logout, /register endpoints
• cookies-based auth

Make sign up form (other route)

Fix header

• remove "About" from the header;
• remove About page from the application (from the /frontend/pages folder etc.);
• Add to header "All Groups", "My Groups" links

Auth on front-end

Add MVC

• error handler decorators;
• MVC pattern implementation;
• schema validations;
• add persist data from MySQL to mysql-data folder