def get_parents_baby(id: int,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
auth.jwt_required()
baby = db.query(Baby).filter(Baby.parent_ids.contains([id])).one()
validate_baby_relationship(auth, baby.id)
return PBaby.from_orm(baby)
def get_baby_feeds(
baby_id: int,
start_at: Optional[datetime] = None,
end_at: Optional[datetime] = None,
page: Optional[int] = None,
page_size: Optional[int] = None,
db: Session = Depends(get_db),
auth: AuthJWT = Depends(),
):
validate_baby_relationship(auth, baby_id)
current_filter = Feed.baby_id == baby_id
if start_at is not None:
current_filter &= Feed.start_at >= start_at
if end_at is not None:
current_filter &= Feed.end_at <= end_at
if page_size is not None:
page = page or 0
if page is not None:
page_size = page_size or 30
feeds_query = db.query(Feed).order_by(desc(
Feed.start_at)).filter(current_filter)
if page is not None:
feeds = feeds_query[page * page_size:(page * page_size) + page_size]
else:
feeds = feeds_query.all()
return [PFeed.from_orm(feed) for feed in feeds]
def get_baby_sleeps(
baby_id: int,
page: Optional[int] = None,
page_size: Optional[int] = None,
start_at: Optional[datetime] = None,
end_at: Optional[datetime] = None,
db: Session = Depends(get_db),
auth: AuthJWT = Depends(),
):
validate_baby_relationship(auth, baby_id)
current_filter = Sleep.baby_id == baby_id
if start_at is not None:
current_filter &= Sleep.start_at >= start_at
if end_at is not None:
current_filter &= Sleep.end_at <= end_at
if page_size is not None:
page = page or 0
if page is not None:
page_size = page_size or 30
sleeps_query = db.query(Sleep).order_by(desc(
Sleep.start_at)).filter(current_filter)
if page is not None:
sleeps = sleeps_query[page * page_size:(page * page_size) + page_size]
else:
sleeps = sleeps_query.all()
return [PSleep.from_orm(sleep) for sleep in sleeps]
def create_feed(p_feed: PFeed,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_feed.baby_id)
feed = Feed(**p_feed.dict())
db.add(feed)
db.commit()
return PFeed.from_orm(feed)
def delete_sleep(id: int,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
sleep: Sleep = db.query(Sleep).get(id)
validate_baby_relationship(auth, sleep.baby_id)
db.delete(sleep)
db.commit()
return PSleep.from_orm(sleep)
def update_sleep(p_sleep: PSleep,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_sleep.baby_id)
sleep: Sleep = db.query(Sleep).get(p_sleep.id)
sleep.update(p_sleep)
db.add(sleep)
db.commit()
return PSleep.from_orm(sleep)
def create_sleep(p_sleep: PSleep,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_sleep.baby_id)
sleep = Sleep(**p_sleep.dict())
db.add(sleep)
db.commit()
return PSleep.from_orm(sleep)
def delete_poop(id: int,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
poop: Poop = db.query(Poop).get(id)
validate_baby_relationship(auth, poop.baby_id)
db.delete(poop)
db.commit()
return PPoop.from_orm(poop)
def update_poop(p_poop: PPoop,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_poop.baby_id)
poop: Poop = db.query(Poop).get(p_poop.id)
poop.update(p_poop)
db.add(poop)
db.commit()
return PPoop.from_orm(poop)
def create_poop(p_poop: PPoop,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_poop.baby_id)
poop = Poop(**p_poop.dict())
db.add(poop)
db.commit()
return PPoop.from_orm(poop)
def delete_feed(id: int,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
feed: Feed = db.query(Feed).get(id)
validate_baby_relationship(auth, feed.baby_id)
db.delete(feed)
db.commit()
return PFeed.from_orm(feed)
def update_feed(p_feed: PFeed,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_feed.baby_id)
feed: Feed = db.query(Feed).get(p_feed.id)
feed.update(p_feed)
db.add(feed)
db.commit()
return PFeed.from_orm(feed)
def delete_pee(id: int,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
pee: Pee = db.query(Pee).get(id)
validate_baby_relationship(auth, pee.baby_id)
db.delete(pee)
db.commit()
return PPee.from_orm(pee)
def create_pee(p_pee: PPee,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_pee.baby_id)
pee = Pee(**p_pee.dict())
db.add(pee)
db.commit()
return PPee.from_orm(pee)
def update_pee(p_pee: PPee,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_pee.baby_id)
pee: Pee = db.query(Pee).get(p_pee.id)
pee.update(p_pee)
db.add(pee)
db.commit()
return PPee.from_orm(pee)
def delete_growth(id: int,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
growth: Growth = db.query(Growth).get(id)
validate_baby_relationship(auth, growth.baby_id)
db.delete(growth)
db.commit()
return PGrowth.from_orm(growth)
def update_growth(p_growth: PGrowth,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_growth.baby_id)
growth: Growth = db.query(Growth).get(p_growth.id)
growth.update(p_growth)
db.add(growth)
db.commit()
return PGrowth.from_orm(growth)
def create_growth(p_growth: PGrowth,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
validate_baby_relationship(auth, p_growth.baby_id)
growth = Growth(**p_growth.dict())
db.add(growth)
db.commit()
return PGrowth.from_orm(growth)
def update_baby(
id: int,
p_baby: PBaby,
db: Session = Depends(get_db),
auth: AuthJWT = Depends(),
):
parent = get_parent_from_token(auth)
validate_baby_relationship(auth, id)
baby: Baby = db.query(Baby).get(id)
_validate_p_baby_with_parent(p_baby, parent)
baby.update(p_baby)
return PBaby.from_orm(baby)
def remove_parents_baby(
baby_id: int,
parent_id: int,
db: Session = Depends(get_db),
auth: AuthJWT = Depends(),
):
validate_baby_relationship(auth, baby_id)
baby = db.query(Baby).get(baby_id).one()
baby.parent_ids.remove(parent_id)
db.add(baby)
db.commit()
return PBaby.from_orm(baby)
def new_parent_for_baby(
id: int,
new_parent_email: str,
db: Session = Depends(get_db),
auth: AuthJWT = Depends(),
):
baby: Baby = db.query(Baby).get(id)
validate_baby_relationship(auth, id)
new_parent = db.query(Parent).filter_by(email=new_parent_email).one()
if new_parent.id not in baby.parent_ids:
baby.parent_ids.append(new_parent.id)
db.add(baby)
db.commit()
return PBaby.from_orm(baby)
def get_baby_pees(
baby_id: int,
page: Optional[int] = None,
page_size: Optional[int] = None,
db: Session = Depends(get_db),
auth: AuthJWT = Depends(),
):
validate_baby_relationship(auth, baby_id)
current_filter = Pee.baby_id == baby_id
if page_size is not None:
page = page or 0
if page is not None:
page_size = page_size or 30
pees_query = db.query(Pee).order_by(desc(Pee.at)).filter(current_filter)
if page is not None:
pees = pees_query[page * page_size:(page * page_size) + page_size]
else:
pees = pees_query.all()
return [PPee.from_orm(pee) for pee in pees]
def get_baby_growths(
baby_id: int,
page: Optional[int] = None,
page_size: Optional[int] = None,
db: Session = Depends(get_db),
auth: AuthJWT = Depends(),
):
validate_baby_relationship(auth, baby_id)
current_filter = Growth.baby_id == baby_id
if page_size is not None:
page = page or 0
if page is not None:
page_size = page_size or 30
growths_query = db.query(Growth).order_by(desc(
Growth.at)).filter(current_filter)
if page is not None:
growths = growths_query[page * page_size:(page * page_size) +
page_size]
else:
growths = growths_query.all()
return [PGrowth.from_orm(growth) for growth in growths]