diff --git a/crud.py b/crud.py
deleted file mode 100644
index 7f64109b776a5438ac11984ea362cd7faec46345..0000000000000000000000000000000000000000
--- a/crud.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from sqlalchemy.orm import Session
-
-from . import models, schemas
-
-
-def get_user(db: Session, user_id: int):
- return db.query(models.User).filter(models.User.id == user_id).first()
-
-
-def get_user_by_email(db: Session, email: str):
- return db.query(models.User).filter(models.User.email == email).first()
-
-
-def get_users(db: Session, skip: int = 0, limit: int = 100):
- return db.query(models.User).offset(skip).limit(limit).all()
-
-
-def create_user(db: Session, user: schemas.UserCreate):
- fake_hashed_password = user.password + "notreallyhashed"
- db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
- db.add(db_user)
- db.commit()
- db.refresh(db_user)
- return db_user
-
-
-def get_items(db: Session, skip: int = 0, limit: int = 100):
- return db.query(models.Item).offset(skip).limit(limit).all()
-
-
-def create_user_item(db: Session, item: schemas.ItemCreate, user_id: int):
- db_item = models.Item(**item.dict(), owner_id=user_id)
- db.add(db_item)
- db.commit()
- db.refresh(db_item)
- return db_item
\ No newline at end of file
diff --git a/database.py b/database.py
deleted file mode 100644
index 62838e6c7cea268804fdb8ca51c0fe12b99f318f..0000000000000000000000000000000000000000
--- a/database.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-
-SQLALCHEMY_DATABASE_URL = "sqlite:///./sql_app.db"
-# SQLALCHEMY_DATABASE_URL = "postgresql://user:password@postgresserver/db"
-
-engine = create_engine(
- SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
-)
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-Base = declarative_base()
\ No newline at end of file
diff --git a/main.py b/main.py
deleted file mode 100644
index 8a2b9ebe2043bb60fc88ca93f82718c880e3cbad..0000000000000000000000000000000000000000
--- a/main.py
+++ /dev/null
@@ -1,53 +0,0 @@
-from fastapi import Depends, FastAPI, HTTPException
-from sqlalchemy.orm import Session
-
-from curd import crud, models, schemas
-from database import SessionLocal, engine
-
-models.Base.metadata.create_all(bind=engine)
-
-app = FastAPI()
-
-
-# Dependency
-def get_db():
- db = SessionLocal()
- try:
- yield db
- finally:
- db.close()
-
-
-@app.post("/users/", response_model=schemas.User)
-def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
- db_user = crud.get_user_by_email(db, email=user.email)
- if db_user:
- raise HTTPException(status_code=400, detail="Email already registered")
- return crud.create_user(db=db, user=user)
-
-
-@app.get("/users/", response_model=list[schemas.User])
-def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
- users = crud.get_users(db, skip=skip, limit=limit)
- return users
-
-
-@app.get("/users/{user_id}", response_model=schemas.User)
-def read_user(user_id: int, db: Session = Depends(get_db)):
- db_user = crud.get_user(db, user_id=user_id)
- if db_user is None:
- raise HTTPException(status_code=404, detail="User not found")
- return db_user
-
-
-@app.post("/users/{user_id}/items/", response_model=schemas.Item)
-def create_item_for_user(
- user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)
-):
- return crud.create_user_item(db=db, item=item, user_id=user_id)
-
-
-@app.get("/items/", response_model=list[schemas.Item])
-def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
- items = crud.get_items(db, skip=skip, limit=limit)
- return items
\ No newline at end of file
diff --git a/microservices/bikes_service/__pycache__/main.cpython-39.pyc b/microservices/bikes_service/__pycache__/main.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..15982096213a2d18b2dddc1f6f3da28cf06c055b
Binary files /dev/null and b/microservices/bikes_service/__pycache__/main.cpython-39.pyc differ
diff --git a/microservices/bikes_service/bikes.db b/microservices/bikes_service/bikes.db
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..352ef9786f33f0f7db1862f23eac8f9f8674509c 100644
Binary files a/microservices/bikes_service/bikes.db and b/microservices/bikes_service/bikes.db differ
diff --git a/microservices/bikes_service/bikes.py b/microservices/bikes_service/bikes.py
deleted file mode 100644
index 5b09376eff2362bc233bd990046c6f04d2ff031e..0000000000000000000000000000000000000000
--- a/microservices/bikes_service/bikes.py
+++ /dev/null
@@ -1,90 +0,0 @@
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-from typing import List
-import sqlite3
-
-app = FastAPI()
-
-# SQLite connection
-conn = sqlite3.connect('bikes.db')
-cursor = conn.cursor()
-
-# Create the Bikes table if it doesn't exist
-cursor.execute('''
- CREATE TABLE IF NOT EXISTS Bikes (
- bike_id INTEGER PRIMARY KEY,
- model TEXT,
- status TEXT,
- location TEXT,
- condition TEXT,
- price_per_hour DECIMAL(10, 2),
- last_maintenance_date DATE,
- maintenance_history TEXT
- )
-''')
-conn.commit()
-
-
-# Bike model
-class Bike(BaseModel):
- model: str
- status: str
- location: str
- condition: str
- price_per_hour: float
- last_maintenance_date: str
- maintenance_history: str
-
-
-
-# Routes
-@app.post("/bikes/", response_model=Bike)
-async def create_bike(bike: Bike):
- cursor.execute('''
- INSERT INTO Bikes
- (model, status, location, condition, price_per_hour, last_maintenance_date, maintenance_history)
- VALUES (?, ?, ?, ?, ?, ?, ?)
- ''', (
- bike.model, bike.status, bike.location, bike.condition,
- bike.price_per_hour, bike.last_maintenance_date, bike.maintenance_history
- ))
- conn.commit()
- return bike
-
-
-@app.get("/bikes/", response_model=List[Bike])
-async def read_bikes():
- cursor.execute('SELECT * FROM Bikes')
- bikes = cursor.fetchall()
- return bikes
-
-
-@app.get("/bikes/{bike_id}", response_model=Bike)
-async def read_bike(bike_id: int):
- cursor.execute('SELECT * FROM Bikes WHERE bike_id = ?', (bike_id,))
- bike = cursor.fetchone()
- if bike is None:
- raise HTTPException(status_code=404, detail="Bike not found")
- return bike
-
-
-@app.put("/bikes/{bike_id}", response_model=Bike)
-async def update_bike(bike_id: int, bike: Bike):
- cursor.execute('''
- UPDATE Bikes
- SET model = ?, status = ?, location = ?, condition = ?,
- price_per_hour = ?, last_maintenance_date = ?, maintenance_history = ?
- WHERE bike_id = ?
- ''', (
- bike.model, bike.status, bike.location, bike.condition,
- bike.price_per_hour, bike.last_maintenance_date, bike.maintenance_history, bike_id
- ))
- conn.commit()
- return bike
-
-
-@app.delete("/bikes/{bike_id}")
-async def delete_bike(bike_id: int):
- cursor.execute('DELETE FROM Bikes WHERE bike_id = ?', (bike_id,))
- conn.commit()
- return {"message": "Bike deleted successfully"}
diff --git a/microservices/bikes_service/main.py b/microservices/bikes_service/main.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..22834e6cffc9dce74ca1467e64e5212d2d187831 100644
--- a/microservices/bikes_service/main.py
+++ b/microservices/bikes_service/main.py
@@ -0,0 +1,99 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List
+import sqlite3
+
+app = FastAPI()
+
+# SQLite connection
+conn = sqlite3.connect('bikes.db')
+cursor = conn.cursor()
+
+# Create the Bikes table if it doesn't exist
+cursor.execute('''
+ CREATE TABLE IF NOT EXISTS Bikes (
+ bike_id INTEGER PRIMARY KEY,
+ model TEXT,
+ status TEXT,
+ location TEXT,
+ condition TEXT,
+ price_per_hour DECIMAL(10, 2),
+ last_maintenance_date DATE,
+ maintenance_history TEXT
+ )
+''')
+conn.commit()
+
+
+# Bike model
+class Bike(BaseModel):
+ model: str
+ status: str
+ location: str
+ condition: str
+ price_per_hour: float
+ last_maintenance_date: str
+ maintenance_history: str
+
+
+
+# Routes
+@app.post("/bikes/", response_model=Bike)
+async def create_bike(bike: Bike):
+ cursor.execute('''
+ INSERT INTO Bikes
+ (model, status, location, condition, price_per_hour, last_maintenance_date, maintenance_history)
+ VALUES (?, ?, ?, ?, ?, ?, ?)
+ ''', (
+ bike.model, bike.status, bike.location, bike.condition,
+ bike.price_per_hour, bike.last_maintenance_date, bike.maintenance_history
+ ))
+ conn.commit()
+ return bike
+
+
+@app.get("/bikes/", response_model=List[Bike])
+async def read_bikes():
+ cursor.execute('SELECT * FROM Bikes')
+ bikes = cursor.fetchall()
+ bike_objects = []
+ for bike in bikes:
+ bike_obj = Bike(
+ brand=bike[0],
+ model=bike[1],
+ year=bike[2],
+ price=bike[3]
+ )
+ bike_objects.append(bike_obj)
+ return bike_objects
+
+
+@app.get("/bikes/{bike_id}", response_model=Bike)
+async def read_bike(bike_id: int):
+ cursor.execute('SELECT * FROM Bikes WHERE bike_id = ?', (bike_id,))
+ bike = cursor.fetchone()
+ if bike is None:
+ raise HTTPException(status_code=404, detail="Bike not found")
+ return bike
+
+
+@app.put("/bikes/{bike_id}", response_model=Bike)
+async def update_bike(bike_id: int, bike: Bike):
+ cursor.execute('''
+ UPDATE Bikes
+ SET model = ?, status = ?, location = ?, condition = ?,
+ price_per_hour = ?, last_maintenance_date = ?, maintenance_history = ?
+ WHERE bike_id = ?
+ ''', (
+ bike.model, bike.status, bike.location, bike.condition,
+ bike.price_per_hour, bike.last_maintenance_date, bike.maintenance_history, bike_id
+ ))
+ conn.commit()
+ return bike
+
+
+@app.delete("/bikes/{bike_id}")
+async def delete_bike(bike_id: int):
+ cursor.execute('DELETE FROM Bikes WHERE bike_id = ?', (bike_id,))
+ conn.commit()
+ return {"message": "Bike deleted successfully"}
diff --git a/microservices/reviews_service/__pycache__/main.cpython-39.pyc b/microservices/reviews_service/__pycache__/main.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8404ca9f3a0c6afcbf3856038ea1b197ba97a44b
Binary files /dev/null and b/microservices/reviews_service/__pycache__/main.cpython-39.pyc differ
diff --git a/microservices/reviews_service/main.py b/microservices/reviews_service/main.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..fef99cc98a5f5f9f828e61d5db897c1501def2f9 100644
--- a/microservices/reviews_service/main.py
+++ b/microservices/reviews_service/main.py
@@ -0,0 +1,95 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List
+import sqlite3
+
+app = FastAPI()
+
+# SQLite connection
+conn = sqlite3.connect('review.db')
+cursor = conn.cursor()
+
+# Create the Reviews table if it doesn't exist
+cursor.execute('''
+ CREATE TABLE IF NOT EXISTS Reviews (
+ review_id INTEGER PRIMARY KEY,
+ user_id INT,
+ bike_id INT,
+ rating INT,
+ comment TEXT,
+ review_date DATETIME,
+ FOREIGN KEY (user_id) REFERENCES Users(user_id),
+ FOREIGN KEY (bike_id) REFERENCES Bikes(bike_id)
+ )
+''')
+conn.commit()
+
+
+# Review model
+class Review(BaseModel):
+ user_id: int
+ bike_id: int
+ rating: int
+ comment: str
+ review_date: str
+
+
+# Routes
+@app.post("/reviews/", response_model=Review)
+async def create_review(review: Review):
+ cursor.execute('''
+ INSERT INTO Reviews
+ (user_id, bike_id, rating, comment, review_date)
+ VALUES (?, ?, ?, ?, ?)
+ ''', (
+ review.user_id, review.bike_id, review.rating, review.comment, review.review_date
+ ))
+ conn.commit()
+ return review
+
+
+@app.get("/reviews/", response_model=List[Review])
+async def read_reviews():
+ cursor.execute('SELECT user_id, bike_id, rating, comment, review_date FROM Reviews')
+ reviews = cursor.fetchall()
+ review_objects = []
+ for review in reviews:
+ review_obj = Review(
+ user_id=review[0],
+ bike_id=review[1],
+ rating=review[2],
+ comment=review[3],
+ review_date=review[4]
+ )
+ review_objects.append(review_obj)
+ return review_objects
+
+
+@app.get("/reviews/{review_id}", response_model=Review)
+async def read_review(review_id: int):
+ cursor.execute('SELECT * FROM Reviews WHERE review_id = ?', (review_id,))
+ review = cursor.fetchone()
+ if review is None:
+ raise HTTPException(status_code=404, detail="Review not found")
+ return review
+
+
+@app.put("/reviews/{review_id}", response_model=Review)
+async def update_review(review_id: int, review: Review):
+ cursor.execute('''
+ UPDATE Reviews
+ SET user_id = ?, bike_id = ?, rating = ?, comment = ?, review_date = ?
+ WHERE review_id = ?
+ ''', (
+ review.user_id, review.bike_id, review.rating, review.comment,
+ review.review_date, review_id
+ ))
+ conn.commit()
+ return review
+
+
+@app.delete("/reviews/{review_id}")
+async def delete_review(review_id: int):
+ cursor.execute('DELETE FROM Reviews WHERE review_id = ?', (review_id,))
+ conn.commit()
+ return {"message": "Review deleted successfully"}
diff --git a/microservices/reviews_service/review.db b/microservices/reviews_service/review.db
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..2d07e1bc5127de7eeaae96265f68529a2dc32ee0 100644
Binary files a/microservices/reviews_service/review.db and b/microservices/reviews_service/review.db differ
diff --git a/microservices/reviews_service/reviews.py b/microservices/reviews_service/reviews.py
deleted file mode 100644
index 7034387f149d8537381a76a8e4f4bde86582700e..0000000000000000000000000000000000000000
--- a/microservices/reviews_service/reviews.py
+++ /dev/null
@@ -1,85 +0,0 @@
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
-from typing import List
-import sqlite3
-
-app = FastAPI()
-
-# SQLite connection
-conn = sqlite3.connect('bikes.db')
-cursor = conn.cursor()
-
-# Create the Reviews table if it doesn't exist
-cursor.execute('''
- CREATE TABLE IF NOT EXISTS Reviews (
- review_id INTEGER PRIMARY KEY,
- user_id INT,
- bike_id INT,
- rating INT,
- comment TEXT,
- review_date DATETIME,
- FOREIGN KEY (user_id) REFERENCES Users(user_id),
- FOREIGN KEY (bike_id) REFERENCES Bikes(bike_id)
- )
-''')
-conn.commit()
-
-
-# Review model
-class Review(BaseModel):
- user_id: int
- bike_id: int
- rating: int
- comment: str
- review_date: str
-
-
-# Routes
-@app.post("/reviews/", response_model=Review)
-async def create_review(review: Review):
- cursor.execute('''
- INSERT INTO Reviews
- (user_id, bike_id, rating, comment, review_date)
- VALUES (?, ?, ?, ?, ?)
- ''', (
- review.user_id, review.bike_id, review.rating, review.comment, review.review_date
- ))
- conn.commit()
- return review
-
-
-@app.get("/reviews/", response_model=List[Review])
-async def read_reviews():
- cursor.execute('SELECT * FROM Reviews')
- reviews = cursor.fetchall()
- return reviews
-
-
-@app.get("/reviews/{review_id}", response_model=Review)
-async def read_review(review_id: int):
- cursor.execute('SELECT * FROM Reviews WHERE review_id = ?', (review_id,))
- review = cursor.fetchone()
- if review is None:
- raise HTTPException(status_code=404, detail="Review not found")
- return review
-
-
-@app.put("/reviews/{review_id}", response_model=Review)
-async def update_review(review_id: int, review: Review):
- cursor.execute('''
- UPDATE Reviews
- SET user_id = ?, bike_id = ?, rating = ?, comment = ?, review_date = ?
- WHERE review_id = ?
- ''', (
- review.user_id, review.bike_id, review.rating, review.comment,
- review.review_date, review_id
- ))
- conn.commit()
- return review
-
-
-@app.delete("/reviews/{review_id}")
-async def delete_review(review_id: int):
- cursor.execute('DELETE FROM Reviews WHERE review_id = ?', (review_id,))
- conn.commit()
- return {"message": "Review deleted successfully"}
diff --git a/microservices/users_service/__pycache__/main.cpython-39.pyc b/microservices/users_service/__pycache__/main.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c7bbb65aad6d812c8095dd550bcab4eea8af8d10
Binary files /dev/null and b/microservices/users_service/__pycache__/main.cpython-39.pyc differ
diff --git a/microservices/users_service/bikes.db b/microservices/users_service/bikes.db
index 84b1acb9efcb41e46f039ef3d17b61e2da479c4e..cda0f3126502b897de95355f5de66de3ee9fa967 100644
Binary files a/microservices/users_service/bikes.db and b/microservices/users_service/bikes.db differ
diff --git a/microservices/users_service/main.py b/microservices/users_service/main.py
index f95802ca91c65d956255e5094e462061f8905d8b..f93f5efb9f390e543dd919169c875aa463d30c67 100644
--- a/microservices/users_service/main.py
+++ b/microservices/users_service/main.py
@@ -26,15 +26,14 @@ cursor.execute('''
conn.commit()
-# User model
class User(BaseModel):
username: str
password: str
email: str
phone_number: str
- credit_card_info: Optional[str]
+ credit_card_info: Optional[str] = None
registration_date: str
- last_login: Optional[str]
+ last_login: Optional[str] = None
class UserResponse(BaseModel):
@@ -63,22 +62,68 @@ async def read_users():
user_objects.append(user_obj)
return user_objects
+
# Routes
@app.post("/users/", response_model=User)
async def create_user(user: User):
print('hit')
- cursor.execute('''
- INSERT INTO Users
- (username, password, email, phone_number, credit_card_info, registration_date, last_login)
- VALUES (?, ?, Optional[str]?, ?, ?, ?, ?)
- ''', (
- user.username, user.password, user.email, user.phone_number,
- user.credit_card_info, user.registration_date, user.last_login
- ))
+ # Use a tuple to conditionally include the optional fields in the SQL query
+ if user.credit_card_info is None and user.last_login is None:
+ cursor.execute('''
+ INSERT INTO Users
+ (username, password, email, phone_number, registration_date)
+ VALUES (?, ?, ?, ?, ?)
+ ''', (
+ user.username, user.password, user.email, user.phone_number,
+ user.registration_date
+ ))
+ elif user.credit_card_info is None:
+ cursor.execute('''
+ INSERT INTO Users
+ (username, password, email, phone_number, registration_date, last_login)
+ VALUES (?, ?, ?, ?, ?, ?)
+ ''', (
+ user.username, user.password, user.email, user.phone_number,
+ user.registration_date, user.last_login
+ ))
+ elif user.last_login is None:
+ cursor.execute('''
+ INSERT INTO Users
+ (username, password, email, phone_number, credit_card_info, registration_date)
+ VALUES (?, ?, ?, ?, ?, ?)
+ ''', (
+ user.username, user.password, user.email, user.phone_number,
+ user.credit_card_info, user.registration_date
+ ))
+ else:
+ cursor.execute('''
+ INSERT INTO Users
+ (username, password, email, phone_number, credit_card_info, registration_date, last_login)
+ VALUES (?, ?, ?, ?, ?, ?, ?)
+ ''', (
+ user.username, user.password, user.email, user.phone_number,
+ user.credit_card_info, user.registration_date, user.last_login
+ ))
conn.commit()
return user
+# # Routes
+# @app.post("/users/", response_model=User)
+# async def create_user(user: User):
+# print('hit')
+# cursor.execute('''
+# INSERT INTO Users
+# (username, password, email, phone_number, credit_card_info, registration_date, last_login)
+# VALUES (?, ?, Optional[str]?, ?, ?, ?, ?)
+# ''', (
+# user.username, user.password, user.email, user.phone_number,
+# user.credit_card_info, user.registration_date, user.last_login
+# ))
+# conn.commit()
+# return user
+
+
# @app.get("/users/", response_model=List[User])
# async def read_users():
# cursor.execute('SELECT * FROM Users')
diff --git a/microservices/users_service/users.py b/microservices/users_service/users.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/models.py b/models.py
deleted file mode 100644
index 3041a3da64b67c73cd35726d5d639f915950b6e6..0000000000000000000000000000000000000000
--- a/models.py
+++ /dev/null
@@ -1,26 +0,0 @@
-from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
-from sqlalchemy.orm import relationship
-
-from .database import Base
-
-
-class User(Base):
- __tablename__ = "users"
-
- id = Column(Integer, primary_key=True)
- email = Column(String, unique=True, index=True)
- hashed_password = Column(String)
- is_active = Column(Boolean, default=True)
-
- items = relationship("Item", back_populates="owner")
-
-
-class Item(Base):
- __tablename__ = "items"
-
- id = Column(Integer, primary_key=True)
- title = Column(String, index=True)
- description = Column(String, index=True)
- owner_id = Column(Integer, ForeignKey("users.id"))
-
- owner = relationship("User", back_populates="items")
\ No newline at end of file
diff --git a/schemas.py b/schemas.py
deleted file mode 100644
index cf51ac28795ba7de747850323b500a9b6149451a..0000000000000000000000000000000000000000
--- a/schemas.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from typing import Union
-
-from pydantic import BaseModel
-
-
-class ItemBase(BaseModel):
- title: str
- description: Union[str, None] = None
-
-
-class ItemCreate(ItemBase):
- pass
-
-
-class Item(ItemBase):
- id: int
- owner_id: int
-
- class Config:
- orm_mode = True
-
-
-class UserBase(BaseModel):
- email: str
-
-
-class UserCreate(UserBase):
- password: str
-
-
-class User(UserBase):
- id: int
- is_active: bool
- items: list[Item] = []
-
- class Config:
- orm_mode = True
\ No newline at end of file
diff --git a/sql_app.db b/sql_app.db
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000