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 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'}
async def create_project(data: Project._scheme, auth: Auth, session: Session):
data.pop('id')
obj = Project(**data)
obj.user_id = auth.get_user_id()
session.add(obj)
session.commit()
return http.Response(obj.render(), status=201)
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 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 signup(session: Session, data: SignupData, settings: Settings):
user = User(username=data['username'],
password=hash_password(data['password'], settings))
session.add(user)
session.flush()
return {'id': user.id, 'username': user.username}
def create_validated_transcription(session: Session, data):
validated_transcription = ValidatedTranscription(**data)
session.add(validated_transcription)
# Flush the changes to the database. This will populate the customer
# id.
session.flush()
def create_payment(session: Session, payment: schemas.Payment):
"""
Create Payment and relation involve with User.
"""
obj = Payment(**payment)
session.add(obj)
session.flush()
return {'id': obj.id, 'method': obj.method, 'status': obj.status}
def create_user(session: Session, user: schemas.User):
"""
Create User.
"""
obj = User(**user)
session.add(obj)
session.flush()
return {'id': obj.id, 'fullname': obj.fullname}
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
}
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 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 create_video(session: Session, video: schemas.Video):
"""Cast given locale to string. Supports also callbacks that return locales.
title:
Object or "class" to use as a possible parameter to locale calla ble
length:
Locale object or string or callable that returns a locale.
"""
obj = Video(**video)
session.add(obj)
session.flush()
return {'id': obj.id, 'title': obj.title}
def create_fortune(session: Session, message: str):
"""
Create a new fortune.
"""
fortune = Fortune(message=message)
session.add(fortune)
session.commit()
data = FortuneSerializer(fortune)
return Response(data, status=201)
def test_update(self, new_obj: Base, mock: dict, session: Session,
client: TestClient):
response = client.patch('/{}/{}'.format(self.url, new_obj.id),
data=mock)
mock['id'] = new_obj.id
session.refresh(new_obj)
assert response.status_code == 200
assert response.json() == self.model(**mock).render()
assert response.json() == new_obj.render()
def create_category(session: Session, data: CategoryCreate, auth: Auth):
"""
This endpoint creates category
"""
instance = Category(
user_id=auth.user.id,
name=data['name']
)
session.add(instance)
session.flush()
return CategoryList(instance)
async def reservation_delete(session: Session, reservation_id: int) -> Response:
obj = session.query(Reservation).filter(
Reservation.id == reservation_id
).first()
if not obj:
raise NotFound
session.delete(obj)
return Response({'status': 'ok'})
async def reservation_update(session: Session, reservation_id: int, reservation_data: typing.Dict) -> ReservationType:
obj = session.query(Reservation).filter(
Reservation.id == reservation_id
).first()
if not obj:
raise NotFound
for k, v in ReservationSerializer().load(reservation_data).data.items():
setattr(obj, k, v)
session.commit()
return ReservationType(ReservationSerializer().dump(obj).data)
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 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 retrieve_student(session: Session):
queryset = session.query(Student).all()
return [{
'id': student.id,
'name': student.name,
'address': student.address
} for student in queryset]
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 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()
async def reservation_create(session: Session, reservation: ReservationType) -> ReservationType:
already_booked = session.query(Reservation).filter(
Reservation.room == reservation['room'],
Reservation.start_date >= arrow.get(reservation['start_date']).datetime,
Reservation.end_date <= arrow.get(reservation['end_date']).datetime,
).count()
if already_booked:
raise ValidationError('this room is already booked for the same dates')
obj = Reservation(**ReservationSerializer().load(reservation).data)
session.add(obj)
session.commit()
return ReservationType(ReservationSerializer().dump(obj).data)
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 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 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 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 list_fortunes(session: Session) -> typing.List[FortuneSerializer]:
"""
List all available fortunes.
"""
queryset = session.query(Fortune).all()
return [FortuneSerializer(record) for record in queryset]
