def add_culinary(session: Session, auth: Auth, culinary_name: str,
description: str, location: str, img_url: str,
authorization: http.Header):
ba = "".join(authorization.split())
decode = base64.b64decode(ba[5:]).decode('utf-8')
username, password = decode.split(':')
isPublisher = session.query(Publisher).filter_by(
username=username).first() and session.query(Publisher).filter_by(
password=password).first()
query = session.query(Publisher).filter_by(
username=auth.get_user_id()).first()
if isPublisher:
if query:
addCulinary = Culinary(publisher=auth.get_user_id(),
culinary_name=culinary_name,
description=description,
location=location,
img_url=img_url)
session.add(addCulinary)
session.commit()
return {'message': 'success add culinary'}
else:
return {'message': 'error add culinary'}
else:
return {'message': 'not authorized'}
def put_publisher(session: Session, username: str, full_name: str,
img_url: str, email: str, password: str,
authorization: http.Header):
ba = "".join(authorization.split())
decode = base64.b64decode(ba[5:]).decode('utf-8')
usernamex, passwordx = decode.split(':')
isAdmin = session.query(Admin).filter_by(
username=usernamex).first() and session.query(Admin).filter_by(
password=passwordx).first()
queryset = session.query(Publisher).filter_by(email=email).first()
if isAdmin:
if email is not None:
if queryset:
if queryset and username is not None:
queryset.username = username
if queryset and full_name is not None:
queryset.full_name = full_name
if queryset and email is not None:
queryset.email = email
if queryset and img_url is not None:
queryset.img_url = img_url
if queryset and password is not None:
queryset.password = password
return {'message': 'success edit publisher'}
else:
return {'message': 'email not found !'}
else:
return {'message': 'please input your email !'}
else:
return {'massage': 'not authorized'}
def get_token(session: Session, auth: Auth, authorization: http.Header):
if authorization is None:
return {'message': 'not authorization and please login'}
ba = "".join(authorization.split())
decode = base64.b64decode(ba[5:]).decode('utf-8')
username, password = decode.split(':')
query_admin = session.query(Admin).filter_by(
username=auth.get_user_id()).first()
query_publisher = session.query(Publisher).filter_by(
username=auth.get_user_id()).first()
if query_admin:
if query_admin.password == password:
return {
'username': auth.get_user_id(),
'user_id': query_admin.id,
'basic_token': ba[5:],
}
else:
return {'message': 'auth Password wrong !'}
elif query_publisher:
if query_publisher.password == password:
return {
'username': auth.get_user_id(),
'user_id': query_publisher.id,
'token': ba[5:],
}
else:
return {'message': 'auth Password wrong !'}
else:
return {'message': 'error authorization'}
def update_fortune(session: Session, uuid: str, message: str):
"""
Update a specific fortune, given a specific UUID.
"""
if uuid is None:
data = {'message': 'Please select a message.'}
return Response(data, status=404)
if not message:
data = {'message': 'Please set a new message.'}
return Response(data, status=400)
queryset = session.query(Fortune).filter(Fortune.uuid==uuid)
record = queryset.first()
if not record:
data = {'message': 'Please select a message.'}
return Response(data, status=404)
record.message = message
session.commit()
queryset = session.query(Fortune).filter(Fortune.uuid==uuid)
record = queryset.first()
return FortuneSerializer(record)
def cols(session: Session, id: int):
return [{
'id': col.id,
'name': col.name,
'sort': col.sort,
'options': options(session, col.options)
} for col in session.query(Col).filter(Col.matrix == id)]
def test_create(self, mock: dict, session: Session, client: TestClient):
response = client.post('/{}/'.format(self.url), data=mock)
resp_obj = response.json()
obj = session.query(self.model).filter_by(id=resp_obj['id']).first()
assert response.status_code == 201
assert response.json() == obj.render()
def get_culinary(session: Session, count: str):
queryset = session.query(Culinary).all()
if count is not None:
countx = int(count) * 10
data_page = []
culinary_data = [{
'id': data.id,
'publisher': data.publisher,
'culinary_name': data.culinary_name,
'description': data.description,
'img_url': data.img_url,
'at_created': str(data.at_created)
} for data in queryset]
if countx > len(culinary_data) and len(culinary_data) < countx:
for s in range((countx - 10), len(culinary_data)):
data_page.append(culinary_data[s])
else:
for s in range((countx - 10), countx):
data_page.append(culinary_data[s])
return {'culinarys': data_page, 'total': len(data_page)}
else:
return {'message': 'input count !'}
def options(session: Session, id: int):
grp = session.query(Options).get(id)
return {
'id':
grp.id,
'key':
grp.key,
'value':
grp.value,
'options': [{
'id': opt.id,
'key': opt.key,
'value': opt.value,
'sort': opt.sort
} for opt in session.query(Option).filter(Option.options == grp.id)]
}
def retrieve_student(session: Session):
queryset = session.query(Student).all()
return [{
'id': student.id,
'name': student.name,
'address': student.address
} for student in queryset]
def create_note(session: Session, data: NoteCreate, auth: Auth):
"""
This endpoint created note
"""
instance = Note(
user_id=auth.user.id,
title=data['title'],
text=data['text'],
device_token=data['device_token']
)
if data.get('reminder_date'):
try:
instance.reminder_date = datetime.strptime(
data['reminder_date'], '%Y/%m/%d %H:%M'
)
except ValueError:
raise ValidationError({
'message': 'invalid reminder date'
})
if data.get('category'):
category = session.query(Category).filter(
Category.id == data['category'],
Category.user_id == auth.user.id
).first()
if not category:
raise ValidationError({'message': 'Invalid category'})
instance.category_id = category.id
session.add(instance)
session.flush()
return NoteList(instance)
def list_notes(session: Session, auth: Auth):
"""
This endpoint shows notes
"""
notes = session.query(Note).filter(
Note.user_id == auth.user.id
).outerjoin(Category, Category.id == Note.category_id).all()
response = []
for note in notes:
props = {
'title': note.title,
'text': note.text,
'id': note.id,
'reminder_date': note.reminder_date,
'created_at': note.created_at
}
if note.category:
props['category'] = CategoryList(note.category)
response.append(NoteList(**props))
return {
'count': len(response),
'results': response
}
def fixtures(session: Session):
# Add a test user
user = User(email="*****@*****.**", password="******")
session.add(user)
session.flush()
# Add matrix
session.add(Matrix(name="Candidates", active=True, user=user.id))
session.add(Matrix(name="Multiplication", active=False, user=user.id))
session.add(Matrix(name="Gradebook", active=False, user=user.id))
session.add(Matrix(name="Survey Grid 1", active=False, user=user.id))
session.flush()
# Populate matrix axis
m = session.query(Matrix).get(1)
session.add(Row(name="Bob", sort=1, matrix=m.id))
session.add(Row(name="Suzy", sort=2, matrix=m.id))
session.add(Row(name="Joe", sort=3, matrix=m.id))
o5 = Options(key="text")
o2 = Options(key="drop")
session.add(o2)
session.add(o5)
session.flush()
session.add(Option(key="0", value="Sad", options=o2.id, sort=1))
session.add(Option(key="1", value="Meh", options=o2.id, sort=2))
session.add(Option(key="2", value="Happy", options=o2.id, sort=3))
session.add(Col(name="Skills (1 - 5)", sort=1, matrix=m.id, options=o5.id))
session.add(Col(name="Looks (1 - 5)", sort=1, matrix=m.id, options=o5.id))
session.add(Col(name="Joy", sort=2, matrix=m.id, options=o2.id))
session.add(Col(name="Notes", sort=3, matrix=m.id, options=o5.id))
session.flush()
def delete_auto(session: Session, auto_id: int,
data: http.RequestData) -> None:
""" Delete a given auto. Called from DELETE /autos/:id """
auto = session.query(Auto).get(auto_id)
session.delete(auto)
session.flush()
return None
def test_delete(self, new_obj: Base, session: Session, client: TestClient):
query = session.query(self.model).filter_by(id=new_obj.id)
response = client.delete('/{}/{}'.format(self.url, new_obj.id))
assert response.status_code == 204
assert response.text == ""
assert query.count() == 0
def add_admin(session: Session, username: str, full_name: str, img_url: str,
email: str, password: str, authorization: http.Header):
ba = "".join(authorization.split())
decode = base64.b64decode(ba[5:]).decode('utf-8')
usernamex, passwordx = decode.split(':')
isAdmin = session.query(Admin).filter_by(
username=usernamex).first() and session.query(Admin).filter_by(
password=passwordx).first()
if isAdmin:
add_Admin = Admin(username, full_name, img_url, email, password)
session.add(add_Admin)
session.commit()
return {'message': 'success add admin'}
else:
return {'message': 'not authorized'}
def list_fortunes(session: Session) -> typing.List[FortuneSerializer]:
"""
List all available fortunes.
"""
queryset = session.query(Fortune).all()
return [FortuneSerializer(record) for record in queryset]
def get_validation_stats(session: Session):
# select count(*) as total, count(v.subject_id) as validated from raw r
# left join validated v on v.subject_id = r.subject_id;
stats = session.query(
func.count(RawTranscription.subject_id).label("total"),
func.count(ValidatedTranscription.subject_id).label(
"validated")).outerjoin(ValidatedTranscription).first()
return stats
def get_node_settings(
node_id,
session: sqlalchemy_backend.Session) -> typing.List[Node.NodeSetting]:
"""
Return the nodes nodes settings
"""
queryset = session.query(Node.NodeSetting.db).first()
return Node.NodeSetting(queryset)
def list_payment(session: Session):
"""
List Payment.
"""
queryset = session.query(Payment).all()
return [
{'id': obj.id, 'user_id': obj.user_id, 'amount': obj.amount, 'method': obj.method}
for obj in queryset
]
def delete_publisher(session: Session, email: str, authorization: http.Header):
ba = "".join(authorization.split())
decode = base64.b64decode(ba[5:]).decode('utf-8')
username, password = decode.split(':')
isAdmin = session.query(Admin).filter_by(
username=username).first() and session.query(Admin).filter_by(
password=password).first()
queryset = session.query(Publisher).filter_by(email=email).first()
if isAdmin:
if queryset:
session.delete(queryset)
return {"message": "success delete publisher"}
else:
return {"message": "error delete publisher"}
else:
return {'massage': 'not authorized'}
async def reservation_view(session: Session, reservation_id: int) -> ReservationType:
obj = session.query(Reservation).filter(
Reservation.id == reservation_id
).first()
if not obj:
raise NotFound
return ReservationType(ReservationSerializer().dump(obj).data)
def get_matrix(session: Session, id: int):
matrix = session.query(Matrix).get(id)
return {
'id': matrix.id,
'name': matrix.name,
'active': matrix.active,
'rows': rows(session, matrix.id),
'cols': cols(session, matrix.id)
}
def get_random_fortune(session: Session):
"""
Get a random fortune from the queryset.
"""
queryset = session.query(Fortune).all()
record = random.choice(queryset)
data = FortuneSerializer(record)
return Response(data, status=200)
def patch_book(session: Session, book_id: int, checked_out: bool) -> Response:
book = session.query(BookModel).get(book_id)
book.checked_out = checked_out
session.commit()
session.flush()
return {
'id': book.id,
'title': book.title,
'checked_out': book.checked_out
}
def list_matrix(session: Session):
queryset = session.query(Matrix).all()
return [{
'id': matrix.id,
'name': matrix.name,
'active': matrix.active,
'rows': rows(session, matrix.id),
'cols': cols(session, matrix.id)
} for matrix in queryset]
def list_user(session: Session):
"""
List Users.
"""
queryset = session.query(User).all()
return [
{'id': user.id, 'fullname': user.fullname, 'email': user.email, 'payment': user.payment,
'subscription_type': user.subscription_type, 'subscription_plan': user.subscription_plan}
for user in queryset
]
def update_auto(session: Session, auto_id: int,
data: http.RequestData) -> dict:
""" Update a given auto. Called from PATCH /autos/:id """
auto_properties = ["name", "make", "model", "year"]
auto = session.query(Auto).get(auto_id)
for auto_prop in auto_properties:
if auto_prop in data:
setattr(auto, auto_prop, data[auto_prop])
session.flush()
return make_auto_dict(auto)
def list_autos(session: Session) -> list:
""" Lists autos from db. Called from GET /autos/ """
queryset = session.query(Auto).all()
return [{
"id": auto.id,
"name": auto.name,
"make": auto.make,
"model": auto.model,
"year": auto.year
} for auto in queryset]
async def func(id: int, data: model._scheme, session: Session):
if data:
data.pop('id')
obj = session.query(model).filter(model.id == id).first()
if not obj:
raise NotFound()
for key, value in data.items():
setattr(obj, key, value)
session.commit()
return obj.render()
def list_video(session: Session):
"""
List videos.
"""
queryset = session.query(Video).all()
return [
{'id': video.id, 'title': video.title, 'length': video.length, 'description': video.description,
'release_date': video.release_date, 'quality': video.quality}
for video in queryset
]