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]