diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..89f99a4
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,116 @@
+__pycache__
+*.py[cod]
+*$py.class
+
+# dependencies
+node_modules
+/media
+*.sqlite3
+
+# testing
+/coverage
+
+# production
+/build
+/documentation
+
+# Distribution / packaging
+.Python build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+*.manifest
+*.spec
+
+# Log files
+pip-log.txt
+pip-delete-this-directory.txt
+*.log
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+.pytest_cache/
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pyflow
+__pypackages__/
+
+# Environment
+.env
+.venv
+env/
+venv/
+ENV/
+
+# If you are using PyCharm #
+.idea/
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/dictionaries
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.xml
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/gradle.xml
+.idea/**/libraries
+*.iws /out/
+
+# sftp configuration file
+sftp-config.json
+
+# Package control specific files Package
+Control.last-run
+Control.ca-list
+Control.ca-bundle
+Control.system-ca-bundle
+GitHub.sublime-settings
+
+# Visual Studio Code #
+vscode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.history
+
+# Git Auth File
+config.py
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..2e07f19
--- /dev/null
+++ b/README.md
@@ -0,0 +1,178 @@
+
+
+
+
+# Address Book API in FastAPI (Python)
+
+The purpose of this repository is to get my hands dirty with FastAPI skills. It would demonstrate various common operations which you perform for any API using FastAPI like Database connections, File uploads, Authentication, Sessions and More.
+
+# Why Fast API ?
+
+FastAPI is a modern back-end framework written in Python which can be used as an alternative to other popular Python based frameworks available like Django and Flask.
+
+### Reasons you might want to use Fast API:
+
+* **Fast**: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available.
+
+* **Fast to code**: Increase the speed to develop features by about 200% to 300%.
+
+* **Fewer bugs**: Reduce about 40% of human (developer) induced errors.
+
+* **Intuitive**: Great editor support. Completion everywhere. Less time debugging.
+
+* **Easy to learn (compared to Django and even Flask)**: Designed to be easy to use and learn. Less time reading docs.
+
+* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
+
+* **Robust**: Get production-ready code. With automatic interactive documentation.
+
+* **Standards-based**: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.
+
+## Models
+
+At the time of writing this, the API has three models which would be Task, User and Address. Task model is totally unrestricted, anyone can perform CRUD operations on it. User module is for authentication which is token based. Authenticated users can add address and perform CRUD on it. Object level filtering has been applied which would restrict users to perform CRUD operations on addresses which were not created by them.
+
+```mermaid
+erDiagram
+ TASK {
+ int id
+ string name
+ string description
+ }
+ USER {
+ int id
+ string username
+ string email
+ string password
+ }
+ ADDRESS {
+ int id
+ int user_id
+ string shipping_address
+ string created_at
+ }
+```
+
+## Database
+
+Postgres is used for the database and Alembic package is used for migrations which means accomodating real time changes in the database. The code sample below demonstates the integration of SQLAlchemy and Postgres in a FastAPI project.
+
+```
+from sqlalchemy import create_engine, MetaData
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+SQLALCHEMY_DATABASE_URL = f"postgresql://postgres:pass12345@127.0.0.1/address-book"
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+metadata = MetaData()
+
+def get_db():
+ db = SessionLocal()
+ try:
+ yield db
+ finally:
+ db.close()
+
+```
+
+## Testing with Pytest
+
+A separate database is used exclusively for testing, configuration has been put inside a config.py file in the root folder of the project.
+
+```
+DATABASE_USERNAME = 'postgres'
+DATABASE_PASSWORD = 'pass12345'
+DATABASE_HOST = '127.0.0.1'
+DATABASE_NAME = 'address-book'
+
+TEST_DATABASE_NAME = 'address-book-test'
+```
+
+Code to test the app root end-point. We need to make sure 200 status code is returned when we hit this route.
+
+```
+from fastapi.testclient import TestClient
+
+from main import app
+
+client = TestClient(app)
+
+
+def test_read_main():
+ response = client.get("/")
+ assert response.status_code == 200
+ assert response.json() == {"message": "Hello Address Book API"}
+```
+
+test_db.py
+
+```
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+import config
+from db import Base, get_db
+from main import app
+
+
+DATABASE_USERNAME = config.DATABASE_USERNAME
+DATABASE_PASSWORD = config.DATABASE_PASSWORD
+DATABASE_HOST = config.DATABASE_HOST
+DATABASE_NAME = config.TEST_DATABASE_NAME
+
+SQLALCHEMY_DATABASE_URL = f"postgresql://{DATABASE_USERNAME}:{DATABASE_PASSWORD}@{DATABASE_HOST}/{DATABASE_NAME}"
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+
+TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base.metadata.create_all(bind=engine)
+
+def override_get_db():
+ try:
+ db = TestingSessionLocal()
+ yield db
+ finally:
+ db.close()
+
+
+app.dependency_overrides[get_db] = override_get_db
+
+client = TestClient(app)
+
+
+def test_create_user():
+ response = client.post(
+ "/account/",
+ json={"username": "Deadpool", "email": "deadpool@example.com", "password": "chimichangas4life"},
+ )
+ assert response.status_code == 201
+ data = response.json()
+ assert data["email"] == "deadpool@example.com"
+```
+
+
+
+## Resources
+
+Following resources were used for motivation in designing this API.
+
+- [Fast API Official Website](https://fastapi.tiangolo.com/)
+- [Udemy Course - FastAPI](https://www.udemy.com/course/fastapi-the-complete-course/)
+
+## Authors
+
+* **Amit Prafulla (APFirebolt)** - [My Website](https://apgiiit.com)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details
+
+
+
diff --git a/alembic.ini b/alembic.ini
new file mode 100644
index 0000000..ff732de
--- /dev/null
+++ b/alembic.ini
@@ -0,0 +1,102 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to alembic/versions. When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os # Use os.pathsep. Default configuration used for new projects.
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts. See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
diff --git a/alembic/README b/alembic/README
new file mode 100644
index 0000000..98e4f9c
--- /dev/null
+++ b/alembic/README
@@ -0,0 +1 @@
+Generic single-database configuration.
\ No newline at end of file
diff --git a/alembic/env.py b/alembic/env.py
new file mode 100644
index 0000000..a77f948
--- /dev/null
+++ b/alembic/env.py
@@ -0,0 +1,87 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+from db import Base
+
+from auth.models import User
+from blog.models import Blog
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+def get_url():
+ db_user = 'postgres'
+ db_password = 'pass12345'
+ db_host ='127.0.0.1'
+ db_name = 'fast-blog'
+ return f"postgresql://{db_user}:{db_password}@{db_host}/{db_name}"
+
+def run_migrations_offline():
+ """Run migrations in 'offline' mode.
+
+ This configures the context with just a URL
+ and not an Engine, though an Engine is acceptable
+ here as well. By skipping the Engine creation
+ we don't even need a DBAPI to be available.
+
+ Calls to context.execute() here emit the given string to the
+ script output.
+
+ """
+ url = get_url()
+ context.configure(
+ url=url,
+ target_metadata=target_metadata,
+ literal_binds=True,
+ dialect_opts={"paramstyle": "named"},
+ )
+
+ with context.begin_transaction():
+ context.run_migrations()
+
+
+def run_migrations_online():
+ """Run migrations in 'online' mode.
+
+ In this scenario we need to create an Engine
+ and associate a connection with the context.
+
+ """
+ configuration = config.get_section(config.config_ini_section)
+ configuration["sqlalchemy.url"] = get_url()
+ connectable = engine_from_config(
+ configuration, prefix="sqlalchemy.", poolclass=pool.NullPool,
+ )
+
+ with connectable.connect() as connection:
+ context.configure(
+ connection=connection, target_metadata=target_metadata
+ )
+
+ with context.begin_transaction():
+ context.run_migrations()
+
+
+if context.is_offline_mode():
+ run_migrations_offline()
+else:
+ run_migrations_online()
diff --git a/alembic/script.py.mako b/alembic/script.py.mako
new file mode 100644
index 0000000..2c01563
--- /dev/null
+++ b/alembic/script.py.mako
@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade():
+ ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+ ${downgrades if downgrades else "pass"}
diff --git a/alembic/versions/ff61c3ece582_generating_initial_tables.py b/alembic/versions/ff61c3ece582_generating_initial_tables.py
new file mode 100644
index 0000000..634133d
--- /dev/null
+++ b/alembic/versions/ff61c3ece582_generating_initial_tables.py
@@ -0,0 +1,47 @@
+"""generating initial tables
+
+Revision ID: ff61c3ece582
+Revises:
+Create Date: 2022-08-06 15:45:06.215617
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'ff61c3ece582'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.create_table('user',
+ sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
+ sa.Column('username', sa.String(length=50), nullable=True),
+ sa.Column('email', sa.String(length=255), nullable=True),
+ sa.Column('firstName', sa.String(length=50), nullable=True),
+ sa.Column('lastName', sa.String(length=50), nullable=True),
+ sa.Column('password', sa.String(length=255), nullable=True),
+ sa.PrimaryKeyConstraint('id'),
+ sa.UniqueConstraint('email')
+ )
+ op.create_table('blog',
+ sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
+ sa.Column('createdDate', sa.DateTime(), nullable=True),
+ sa.Column('title', sa.String(length=50), nullable=True),
+ sa.Column('content', sa.Text(), nullable=True),
+ sa.Column('owner_id', sa.Integer(), nullable=True),
+ sa.ForeignKeyConstraint(['owner_id'], ['user.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('id')
+ )
+ # ### end Alembic commands ###
+
+
+def downgrade():
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.drop_table('blog')
+ op.drop_table('user')
+ # ### end Alembic commands ###
diff --git a/auth/hashing.py b/auth/hashing.py
new file mode 100644
index 0000000..8b5fdd6
--- /dev/null
+++ b/auth/hashing.py
@@ -0,0 +1,12 @@
+from passlib.context import CryptContext
+
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+def verify_password(plain_password, hashed_password):
+ return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password):
+ return pwd_context.hash(password)
diff --git a/auth/jwt.py b/auth/jwt.py
new file mode 100644
index 0000000..83d6013
--- /dev/null
+++ b/auth/jwt.py
@@ -0,0 +1,45 @@
+from datetime import datetime, timedelta
+
+from . import schema
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import jwt
+
+
+SECRET_KEY = "20a9bfa73de3f29b6b7a01d4fc84bb569f1b7e8ac7f83c77c62a603f2bf9f5ff"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+
+def create_access_token(data: dict):
+ to_encode = data.copy()
+ expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+ to_encode.update({"exp": expire})
+ encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+ return encoded_jwt
+
+
+def verify_token(token: str, credentials_exception):
+ try:
+ payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+ email: str = payload.get("sub")
+ id: int = payload.get("id")
+ if email is None:
+ raise credentials_exception
+ token_data = schema.TokenData(email=email, id=id)
+ return token_data
+ except:
+ raise credentials_exception
+
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
+
+
+def get_current_user(data: str = Depends(oauth2_scheme)):
+ credentials_exception = HTTPException(
+ status_code=status.HTTP_401_UNAUTHORIZED,
+ detail="Could not validate credentials",
+ headers={"Authorization": "Bearer"}
+ )
+ return verify_token(data, credentials_exception)
diff --git a/auth/models.py b/auth/models.py
new file mode 100644
index 0000000..b7c1cca
--- /dev/null
+++ b/auth/models.py
@@ -0,0 +1,28 @@
+from sqlalchemy import Column, Integer, String
+from sqlalchemy.orm import relationship
+from db import Base
+
+from .import hashing
+
+
+class User(Base):
+ __tablename__ = "user"
+
+ id = Column(Integer, primary_key=True, autoincrement=True)
+ username = Column(String(50))
+ email = Column(String(255), unique=True)
+ firstName = Column(String(50))
+ lastName = Column(String(50))
+ password = Column(String(255))
+
+ posts = relationship("Blog", back_populates="owner")
+
+ def __init__(self, username, email, password, firstName, lastName, *args, **kwargs):
+ self.username = username
+ self.email = email
+ self.firstName = firstName
+ self.lastName = lastName
+ self.password = hashing.get_password_hash(password)
+
+ def check_password(self, password):
+ return hashing.verify_password(self.password, password)
diff --git a/auth/router.py b/auth/router.py
new file mode 100644
index 0000000..3023f59
--- /dev/null
+++ b/auth/router.py
@@ -0,0 +1,69 @@
+from fastapi import APIRouter, Depends, status, Response, HTTPException, UploadFile
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from typing import List
+import db
+from . import schema
+from . import services
+from . import validator
+
+from . jwt import create_access_token, get_current_user
+
+import db
+from . import hashing
+from . models import User
+
+router = APIRouter(tags=['Auth'], prefix='/auth')
+
+
+@router.post('/', status_code=status.HTTP_201_CREATED)
+async def create_user_registration(request: schema.User,
+ database: Session = Depends(db.get_db)):
+
+ user = await validator.verify_email_exist(request.email, database)
+
+ if user:
+ raise HTTPException(
+ status_code=400,
+ detail="This user with this email already exists in the system."
+ )
+
+ new_user = await services.new_user_register(request, database)
+ return new_user
+
+
+@router.get('/', response_model=List[schema.DisplayAccount])
+async def get_all_users(database: Session = Depends(db.get_db)):
+ return await services.all_users(database)
+
+
+@router.post('/login')
+def login(request: schema.Login,
+ database: Session = Depends(db.get_db)):
+ user = database.query(User).filter(User.email == request.username).first()
+ if not user:
+ raise HTTPException(
+ status_code=status.HTTP_404_NOT_FOUND, detail="Invalid Credentials throw")
+
+ if not hashing.verify_password(request.password, user.password):
+ raise HTTPException(
+ status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid Password")
+
+ # Generate a JWT Token
+ access_token = create_access_token(data={"sub": user.email, "id": user.id})
+ return {"access_token": access_token, "token_type": "bearer"}
+
+
+@router.get('/profile', response_model=schema.DisplayAccount)
+async def get_profile(database: Session = Depends(db.get_db), current_user: schema.User = Depends(get_current_user)):
+ return await services.get_profile(database, current_user)
+
+
+
+
+
+
+
+
+
+
diff --git a/auth/schema.py b/auth/schema.py
new file mode 100644
index 0000000..4242cad
--- /dev/null
+++ b/auth/schema.py
@@ -0,0 +1,39 @@
+import email
+from typing import Optional, List
+from pydantic import BaseModel, constr, EmailStr
+from blog.schema import BlogList
+
+
+class User(BaseModel):
+ username: constr(min_length=2, max_length=50)
+ email: EmailStr
+ firstName: str
+ lastName: str
+ password: str
+
+
+class DisplayAccount(BaseModel):
+ id: int
+ username: str
+ email: str
+ firstName: Optional[str]
+ lastName: Optional[str]
+ posts: List[BlogList] = []
+
+ class Config:
+ orm_mode = True
+
+
+class Login(BaseModel):
+ username: str
+ password: str
+
+
+class Token(BaseModel):
+ access_token: str
+ token_type: str
+
+
+class TokenData(BaseModel):
+ email: Optional[str] = None
+ id: Optional[int]
\ No newline at end of file
diff --git a/auth/services.py b/auth/services.py
new file mode 100644
index 0000000..91f7ea7
--- /dev/null
+++ b/auth/services.py
@@ -0,0 +1,40 @@
+from fastapi import HTTPException, status
+from typing import List, Optional
+
+from . import schema
+from . import models
+
+
+async def new_user_register(request: schema.BaseModel, database) -> models.User:
+ new_user = models.User(username=request.username, email=request.email,
+ password=request.password,
+ firstName=request.firstName,
+ lastName=request.lastName)
+
+ database.add(new_user)
+ database.commit()
+ database.refresh(new_user)
+ return new_user
+
+
+async def all_users(database) -> List[models.User]:
+ users = database.query(models.User).all()
+ return users
+
+
+async def get_user_by_id(user_id, database) -> Optional[models.User]:
+ user_info = database.query(models.User).get(user_id)
+
+ if not user_info:
+ raise HTTPException(
+ status_code=status.HTTP_404_NOT_FOUND,
+ detail="Data not found!"
+ )
+
+ return user_info
+
+
+async def get_profile(database, current_user) -> models.User:
+ user = database.query(models.User).filter(models.User.email == current_user.email).first()
+ return user
+
diff --git a/auth/validator.py b/auth/validator.py
new file mode 100644
index 0000000..40a7e64
--- /dev/null
+++ b/auth/validator.py
@@ -0,0 +1,9 @@
+from typing import Optional
+
+from sqlalchemy.orm import Session
+
+from . models import User
+
+
+async def verify_email_exist(email: str, db_session: Session) -> Optional[User]:
+ return db_session.query(User).filter(User.email == email).first()
diff --git a/blog/__init__.py b/blog/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/blog/models.py b/blog/models.py
new file mode 100644
index 0000000..e271af5
--- /dev/null
+++ b/blog/models.py
@@ -0,0 +1,20 @@
+from datetime import datetime
+from sqlalchemy.orm import relationship
+from sqlalchemy import Column, Float, String, ForeignKey, Text, DateTime, Integer
+
+
+from db import Base
+
+
+class Blog(Base):
+ __tablename__ = "blog"
+
+ id = Column(Integer, primary_key=True, autoincrement=True)
+ createdDate = Column(DateTime, default=datetime.now)
+ title = Column(String(50))
+ content = Column(Text)
+ owner_id = Column(Integer, ForeignKey("user.id", ondelete="CASCADE"))
+
+ owner = relationship("User", back_populates="posts")
+
+
diff --git a/blog/router.py b/blog/router.py
new file mode 100644
index 0000000..22f7b77
--- /dev/null
+++ b/blog/router.py
@@ -0,0 +1,52 @@
+from typing import List
+from fastapi import APIRouter, Depends, status, Response, Request
+from sqlalchemy.orm import Session
+from auth.jwt import get_current_user
+from auth.models import User
+
+import db
+
+from .import schema
+from .import services
+
+
+router = APIRouter(
+ tags=["Blog"],
+ prefix='/blog'
+)
+
+
+@router.post('/', status_code=status.HTTP_201_CREATED,
+ response_model=schema.BlogBase)
+async def create_new_blog(request: schema.BlogBase, database: Session = Depends(db.get_db),
+ current_user: User = Depends(get_current_user)):
+ user = database.query(User).filter(User.email == current_user.email).first()
+ result = await services.create_new_blog(request, database, user)
+ return result
+
+
+@router.get('/', status_code=status.HTTP_200_OK,
+ response_model=List[schema.BlogList])
+async def blog_list(database: Session = Depends(db.get_db),
+ current_user: User = Depends(get_current_user)):
+ result = await services.get_blog_listing(database)
+ return result
+
+
+@router.get('/{blog_id}', status_code=status.HTTP_200_OK, response_model=schema.BlogBase)
+async def get_blog_by_id(blog_id: int, database: Session = Depends(db.get_db),
+ current_user: User = Depends(get_current_user)):
+ return await services.get_blog_by_id(blog_id, current_user.id, database)
+
+
+@router.delete('/{blog_id}', status_code=status.HTTP_204_NO_CONTENT, response_class=Response)
+async def delete_blog_by_id(blog_id: int,
+ database: Session = Depends(db.get_db),
+ current_user: User = Depends(get_current_user)):
+ return await services.delete_blog_by_id(blog_id, current_user.id, database)
+
+
+@router.patch('/{blog_id}', status_code=status.HTTP_200_OK, response_model=schema.BlogBase)
+async def update_blog_by_id(request: schema.BlogUpdate, blog_id: int, database: Session = Depends(db.get_db),
+ current_user: User = Depends(get_current_user)):
+ return await services.update_blog_by_id(request, blog_id, current_user.id, database)
diff --git a/blog/schema.py b/blog/schema.py
new file mode 100644
index 0000000..fdad1a0
--- /dev/null
+++ b/blog/schema.py
@@ -0,0 +1,28 @@
+from typing import Optional
+from pydantic import BaseModel, constr
+
+
+class BlogBase(BaseModel):
+ id: Optional[int]
+ title: str
+ content: str
+
+ class Config:
+ orm_mode = True
+
+class BlogUpdate(BaseModel):
+ title: Optional[str]
+ content: Optional[str]
+
+ class Config:
+ orm_mode = True
+
+
+class BlogList(BaseModel):
+ title: str
+ content: str
+ owner_id: int
+ createdAt: Optional[str]
+
+ class Config:
+ orm_mode = True
diff --git a/blog/services.py b/blog/services.py
new file mode 100644
index 0000000..cd3d8be
--- /dev/null
+++ b/blog/services.py
@@ -0,0 +1,54 @@
+from fastapi import HTTPException, status
+from typing import List
+from . import models
+from datetime import datetime
+
+
+async def create_new_blog(request, database, current_user) -> models.Blog:
+ new_blog = models.Blog(title=request.title, content=request.content,
+ owner_id=current_user.id, createdDate=datetime.now().strftime('%m/%d/%Y'))
+ database.add(new_blog)
+ database.commit()
+ database.refresh(new_blog)
+ return new_blog
+
+
+async def get_blog_listing(database) -> List[models.Blog]:
+ blogs = database.query(models.Blog).all()
+ return blogs
+
+
+async def get_blog_by_id(blog_id, user_id, database):
+ blog = database.query(models.Blog).filter_by(id=blog_id, owner_id=user_id).first()
+ if not blog:
+ raise HTTPException(
+ status_code=status.HTTP_404_NOT_FOUND,
+ detail="Blog Not Found !"
+ )
+ return blog
+
+
+async def delete_blog_by_id(blog_id, user_id, database):
+ database.query(models.Blog).filter(
+ models.Blog.id == blog_id and models.Blog.owner_id == user_id).delete()
+ database.commit()
+
+
+async def update_blog_by_id(request, blog_id, user_id, database):
+ blog = database.query(models.Blog).filter_by(id=blog_id, owner_id=user_id).first()
+ if not blog:
+ raise HTTPException(
+ status_code=status.HTTP_404_NOT_FOUND,
+ detail="Blog Not Found !"
+ )
+ blog.title = request.title if request.title else blog.title
+ blog.content = request.content if request.content else blog.content
+ database.commit()
+ database.refresh(blog)
+ return blog
+
+
+
+
+
+
diff --git a/client/.gitignore b/client/.gitignore
new file mode 100644
index 0000000..4d29575
--- /dev/null
+++ b/client/.gitignore
@@ -0,0 +1,23 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
diff --git a/client/README.md b/client/README.md
new file mode 100644
index 0000000..f91225f
--- /dev/null
+++ b/client/README.md
@@ -0,0 +1,44 @@
+This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app), using the [Redux](https://redux.js.org/) and [Redux Toolkit](https://redux-toolkit.js.org/) template.
+
+## Available Scripts
+
+In the project directory, you can run:
+
+### `npm start`
+
+Runs the app in the development mode.React Redux App
+
+
+ You need to enable JavaScript to run this app.
+
+
+
+
diff --git a/client/public/logo192.png b/client/public/logo192.png
new file mode 100644
index 0000000..3362410
Binary files /dev/null and b/client/public/logo192.png differ
diff --git a/client/public/logo512.png b/client/public/logo512.png
new file mode 100644
index 0000000..b351622
Binary files /dev/null and b/client/public/logo512.png differ
diff --git a/client/public/manifest.json b/client/public/manifest.json
new file mode 100644
index 0000000..080d6c7
--- /dev/null
+++ b/client/public/manifest.json
@@ -0,0 +1,25 @@
+{
+ "short_name": "React App",
+ "name": "Create React App Sample",
+ "icons": [
+ {
+ "src": "favicon.ico",
+ "sizes": "64x64 32x32 24x24 16x16",
+ "type": "image/x-icon"
+ },
+ {
+ "src": "logo192.png",
+ "type": "image/png",
+ "sizes": "192x192"
+ },
+ {
+ "src": "logo512.png",
+ "type": "image/png",
+ "sizes": "512x512"
+ }
+ ],
+ "start_url": ".",
+ "display": "standalone",
+ "theme_color": "#000000",
+ "background_color": "#ffffff"
+}
diff --git a/client/public/robots.txt b/client/public/robots.txt
new file mode 100644
index 0000000..01b0f9a
--- /dev/null
+++ b/client/public/robots.txt
@@ -0,0 +1,2 @@
+# https://www.robotstxt.org/robotstxt.html
+User-agent: *
diff --git a/client/src/App.js b/client/src/App.js
new file mode 100644
index 0000000..6001694
--- /dev/null
+++ b/client/src/App.js
@@ -0,0 +1,40 @@
+import { BrowserRouter as Router, Routes, Route } from 'react-router-dom'
+import { ToastContainer } from 'react-toastify'
+import 'react-toastify/dist/ReactToastify.css'
+import Header from './components/Header'
+import PrivateRoute from './components/PrivateRoute'
+import Home from './pages/Home'
+import Login from './pages/Login'
+import Register from './pages/Register'
+import NewTicket from './pages/NewTicket'
+import Tickets from './pages/Tickets'
+import Ticket from './pages/Ticket'
+
+function App() {
+ return (
+ <>
+
+
+
+
+
+
+
+
+
+
+
+ {user ? (
+
+
+
+
+ ) : (
+ <>
+
+
+
+
+
+ )}
+
+
+ )
+}
+
+export default Header
diff --git a/client/src/components/NoteItem.js b/client/src/components/NoteItem.js
new file mode 100644
index 0000000..4b4f7cc
--- /dev/null
+++ b/client/src/components/NoteItem.js
@@ -0,0 +1,25 @@
+import { useSelector } from 'react-redux'
+
+function NoteItem({ note }) {
+ const { user } = useSelector((state) => state.auth)
+
+ return (
+
+
+ Note from {note.isStaff ? Staff : {user.name} }
+
+
{note.text}
+
+ {new Date(note.createdAt).toLocaleString('en-US')}
+
+
+
{new Date(ticket.createdAt).toLocaleString('en-US')}
+
{ticket.product}
+
{ticket.status}
+
+ View
+
+
+
+
+ ,
+ document.getElementById('root')
+);
+
+// If you want your app to work offline and load faster, you can change
+// unregister() to register() below. Note this comes with some pitfalls.
+// Learn more about service workers: https://bit.ly/CRA-PWA
+serviceWorker.unregister();
diff --git a/client/src/pages/Home.jsx b/client/src/pages/Home.jsx
new file mode 100644
index 0000000..25cd103
--- /dev/null
+++ b/client/src/pages/Home.jsx
@@ -0,0 +1,23 @@
+import { Link } from 'react-router-dom'
+import { FaQuestionCircle, FaTicketAlt } from 'react-icons/fa'
+
+function Home() {
+ return (
+ <>
+
+ What do you need help with?
+ Please choose from an option below
+
+
+
+
+
+ Please log in to get support
+
+
+
+
+ )
+}
+
+export default Login
diff --git a/client/src/pages/NewTicket.jsx b/client/src/pages/NewTicket.jsx
new file mode 100644
index 0000000..d091dc1
--- /dev/null
+++ b/client/src/pages/NewTicket.jsx
@@ -0,0 +1,98 @@
+import { useState, useEffect } from 'react'
+import { useSelector, useDispatch } from 'react-redux'
+import { useNavigate } from 'react-router-dom'
+import { toast } from 'react-toastify'
+import { createTicket, reset } from '../features/tickets/ticketSlice'
+import Spinner from '../components/Spinner'
+import BackButton from '../components/BackButton'
+
+function NewTicket() {
+ const { user } = useSelector((state) => state.auth)
+ const { isLoading, isError, isSuccess, message } = useSelector(
+ (state) => state.tickets
+ )
+
+ const [name] = useState(user.name)
+ const [email] = useState(user.email)
+ const [product, setProduct] = useState('iPhone')
+ const [description, setDescription] = useState('')
+
+ const dispatch = useDispatch()
+ const navigate = useNavigate()
+
+ useEffect(() => {
+ if (isError) {
+ toast.error(message)
+ }
+
+ if (isSuccess) {
+ dispatch(reset())
+ navigate('/tickets')
+ }
+
+ dispatch(reset())
+ }, [dispatch, isError, isSuccess, navigate, message])
+
+ const onSubmit = (e) => {
+ e.preventDefault()
+ console.log(product)
+ dispatch(createTicket({ product, description }))
+ }
+
+ if (isLoading) {
+ return
+ Create New Ticket
+ Please fill out the form below
+
+
+
+
+ )
+}
+
+export default NewTicket
diff --git a/client/src/pages/Register.jsx b/client/src/pages/Register.jsx
new file mode 100644
index 0000000..89465c9
--- /dev/null
+++ b/client/src/pages/Register.jsx
@@ -0,0 +1,162 @@
+import { useState, useEffect } from 'react'
+import { useNavigate } from 'react-router-dom'
+import { toast } from 'react-toastify'
+import { FaUser } from 'react-icons/fa'
+import { useSelector, useDispatch } from 'react-redux'
+import { register, reset } from '../features/auth/authSlice'
+import Spinner from '../components/Spinner'
+
+function Register() {
+ const [formData, setFormData] = useState({
+ username: '',
+ firstName: '',
+ lastName: '',
+ email: '',
+ password: '',
+ password2: '',
+ })
+
+ const { username, firstName, lastName, email, password, password2 } = formData
+
+ const dispatch = useDispatch()
+ const navigate = useNavigate()
+
+ const { user, isLoading, isError, isSuccess, message } = useSelector(
+ (state) => state.auth
+ )
+
+ useEffect(() => {
+ if (isError) {
+ toast.error(message)
+ }
+
+ // Redirect when logged in
+ if (isSuccess || user) {
+ navigate('/')
+ }
+
+ dispatch(reset())
+ }, [isError, isSuccess, user, message, navigate, dispatch])
+
+ const onChange = (e) => {
+ setFormData((prevState) => ({
+ ...prevState,
+ [e.target.name]: e.target.value,
+ }))
+ }
+
+ const onSubmit = (e) => {
+ e.preventDefault()
+
+ if (password !== password2) {
+ toast.error('Passwords do not match')
+ } else {
+ const userData = {
+ username,
+ firstName,
+ lastName,
+ email,
+ password,
+ }
+
+ dispatch(register(userData))
+ }
+ }
+
+ if (isLoading) {
+ return
+
+
+ Please create an account
+
+
+
+
+ )
+}
+
+export default Register
diff --git a/client/src/pages/Ticket.jsx b/client/src/pages/Ticket.jsx
new file mode 100644
index 0000000..3290945
--- /dev/null
+++ b/client/src/pages/Ticket.jsx
@@ -0,0 +1,154 @@
+import { useEffect, useState } from 'react'
+import { toast } from 'react-toastify'
+import Modal from 'react-modal'
+import { FaPlus } from 'react-icons/fa'
+import { useSelector, useDispatch } from 'react-redux'
+import { getTicket, closeTicket } from '../features/tickets/ticketSlice'
+import {
+ getNotes,
+ createNote,
+ reset as notesReset,
+} from '../features/notes/noteSlice'
+import { useParams, useNavigate } from 'react-router-dom'
+import BackButton from '../components/BackButton'
+import Spinner from '../components/Spinner'
+import NoteItem from '../components/NoteItem'
+
+const customStyles = {
+ content: {
+ width: '600px',
+ top: '50%',
+ left: '50%',
+ right: 'auto',
+ bottom: 'auto',
+ marginRight: '-50%',
+ transform: 'translate(-50%, -50%)',
+ position: 'relative',
+ },
+}
+
+Modal.setAppElement('#root')
+
+function Ticket() {
+ const [modalIsOpen, setModalIsOpen] = useState(false)
+ const [noteText, setNoteText] = useState('')
+ const { ticket, isLoading, isSuccess, isError, message } = useSelector(
+ (state) => state.tickets
+ )
+
+ const { notes, isLoading: notesIsLoading } = useSelector(
+ (state) => state.notes
+ )
+
+ const params = useParams()
+ const navigate = useNavigate()
+ const dispatch = useDispatch()
+ const { ticketId } = useParams()
+
+ useEffect(() => {
+ if (isError) {
+ toast.error(message)
+ }
+
+ dispatch(getTicket(ticketId))
+ dispatch(getNotes(ticketId))
+ // eslint-disable-next-line
+ }, [isError, message, ticketId])
+
+ // Close ticket
+ const onTicketClose = () => {
+ dispatch(closeTicket(ticketId))
+ toast.success('Ticket Closed')
+ navigate('/tickets')
+ }
+
+ // Create note submit
+ const onNoteSubmit = (e) => {
+ e.preventDefault()
+ dispatch(createNote({ noteText, ticketId }))
+ closeModal()
+ }
+
+ // Open/close modal
+ const openModal = () => setModalIsOpen(true)
+ const closeModal = () => setModalIsOpen(false)
+
+ if (isLoading || notesIsLoading) {
+ return Something Went Wrong
+ }
+
+ return (
+
+
+
+ Ticket ID: {ticket._id}
+
+ {ticket.status}
+
+
+
+ Date Submitted: {new Date(ticket.createdAt).toLocaleString('en-US')}
+
+ Product: {ticket.product}
+
+
Description of Issue
+
{ticket.description}
+
Notes
+
+
+ {ticket.status !== 'closed' && (
+
+
+ )}
+
+
+ Add Note
+
+ X
+
+
+
+
+ {notes.map((note) => (
+
+ ))}
+
+ {ticket.status !== 'closed' && (
+
+ Close Ticket
+
+ )}
+
Tickets
+
+
+
Date
+
Product
+
Status
+
+
+ {tickets.map((ticket) => (
+
+ ))}
+