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 save(self, session: Session, commit=True):
"""Save the record."""
session.add(self)
if commit:
session.commit()
session.flush()
return self
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 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 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 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_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 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)
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)
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 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 signup(session: Session, data: Signup, settings: Settings):
"""
This endpoint creates user
"""
user = User(
username=data['username'],
password=hash_password(data['password'], settings)
)
session.add(user)
session.flush()
token = AccessToken(token=generate_key(), user_id=user.id)
session.add(token)
return {
'id': user.id,
'username': user.username,
'token': token.token
}
def add_book(session: Session, book: BookType) -> Response:
try:
publish_date = datetime.strptime(book.get('publish_date'),
'%Y-%m-%d').date()
except ValueError:
return (Response({'publish_date': 'invalid date. use YYYY-MM-DD'},
status=400))
new_book = BookModel(title=book.get('title'),
author=book.get('author'),
publisher=book.get('publisher'),
publish_date=publish_date,
rating=book.get('rating'),
checked_out=book.get('checked_out'))
session.add(new_book)
session.commit()
return {
'id': new_book.id,
'title': new_book.title,
'checked_out': new_book.checked_out
}
def create_user(session: Session, user: UserSchemas):
print(user)
user = User(**user)
session.add(user)
session.flush()
return UserSchemas(user)
async def func(data: model._scheme, session: Session):
data.pop('id')
obj = model(**data)
session.add(obj)
session.commit()
return http.Response(obj.render(), status=201)
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()
async def create_user(data: User._scheme, session: Session):
data.pop('id')
obj = User(**data)
session.add(obj)
session.commit()
return http.Response(obj.render(), status=201)
def create_student(session: Session, name: str, address: str):
student = Student(name=name, address=address)
session.add(student)
session.flush(
) # Flush the changes to the database. This will populate the customer id.
return {'id': student.id, 'name': student.name, 'address': student.address}
def create_auto(session: Session, data: http.RequestData) -> dict:
""" Creates auto in db. Called from POST /autos/ """
auto = Auto(**data)
session.add(auto)
session.flush()
return make_auto_dict(auto)
def test_create(self, mock: dict, session: Session, client: TestClient):
obj = User(id=1234)
session.add(obj)
session.commit()
return super().test_create(mock, session, client)