def read_card(request: CardDataRequest, user_id: int, card_list: CardListModel) -> (List[Card], BaseError):
card_response = []
query = CardModel.select()
if request.id is not None:
query = query.where(CardModel.id == request.id)
if request.name is not None:
query = query.where(CardModel.name == request.name)
if card_list is not None:
query = query.where(CardModel.list == card_list)
if request.board_id is not None:
query = query.join(CardListModel).join(BoardModel).where(CardModel.list.board == request.board_id)
if request.tags:
query = query.switch(CardModel).join(TagCard).join(TagModel).where(TagModel.id == request.tags[0])
query = query.order_by(-CardModel.priority)
if query.count() == 0:
return None, BaseError(code=provider.StorageProviderErrors.CARD_DOES_NOT_EXIST,
description="Card doesn't exist")
for card in query:
if bool(check_access_to_card(card, user_id) & AccessType.READ):
card_response += [_create_card_from_orm(card)]
if not card_response:
return None, BaseError(code=provider.StorageProviderErrors.ACCESS_DENIED,
description="This user can't read this card")
else:
return card_response, None
def delete_plan(user_id: int, card: CardModel) -> (None, BaseError):
if bool(check_access_to_card(card, user_id) & AccessType.WRITE):
count = PlanModel.delete().where(PlanModel.card == card).execute()
if count == 0:
return None, BaseError(
code=provider.StorageProviderErrors.PLAN_DOES_NOT_EXIST,
description="There is no plan for this task")
return None, None
def delete_card(request: CardDataRequest, user_id: int) -> (List[Card], BaseError):
try:
card = CardModel.get(CardModel.id == request.id)
access = check_access_to_card(card, user_id)
if bool(access & AccessType.WRITE):
_delete_card(card)
else:
return None, BaseError(code=provider.StorageProviderErrors.ACCESS_DENIED,
description="This user can't delete this card")
except DoesNotExist:
return None, BaseError(code=provider.StorageProviderErrors.LIST_DOES_NOT_EXIST,
description="Card doesn't exist")
return None, None
def read_plan(user_id: int, card: CardModel) -> (Plan, BaseError):
if bool(check_access_to_card(card, user_id) & AccessType.READ):
try:
plan_model = PlanModel.get(PlanModel.card == card)
return Plan(datetime.timedelta(seconds=plan_model.interval),
card.id, plan_model.last_created_at,
plan_model.id), None
except DoesNotExist:
return None, BaseError(
code=provider.StorageProviderErrors.PLAN_DOES_NOT_EXIST,
description="There is no plan for this task")
else:
return None, BaseError(
code=provider.StorageProviderErrors.ACCESS_DENIED,
description="This user can't read this card")
def write_plan(request: PlanDataRequest, user_id: int,
card: CardModel) -> (Plan, BaseError):
if bool(check_access_to_card(card, user_id) & AccessType.WRITE):
try:
plan_model = PlanModel.get(PlanModel.card == card)
if request.interval is not None:
plan_model.interval = request.interval.total_seconds()
if request.last_created is not None:
plan_model.last_created_at = request.last_created
plan_model.save()
except DoesNotExist:
plan_model = PlanModel.create(
card=card,
interval=request.interval.total_seconds(),
last_created_at=request.last_created)
return Plan(datetime.timedelta(seconds=plan_model.interval), card.id,
plan_model.last_created_at, plan_model.id), None
else:
return None, BaseError(
code=provider.StorageProviderErrors.ACCESS_DENIED,
description="This user can't write to this card")
def write_card(request: CardDataRequest, user_id: int, card_list: CardListModel) -> (List[Card], BaseError):
try:
card = CardModel.get(CardModel.id == request.id)
if bool(check_access_to_card(card, user_id) & AccessType.WRITE):
card.name = request.name
card.description = request.description
card.expiration_date = request.expiration_date
card.priority = request.priority if request.priority is not None else Priority.MEDIUM
card.assignee_id = request.assignee
if card_list is not None:
card.list = card_list
actual_children_quarry = ParentChild.select().where(ParentChild.parent == card)
for parent_child in actual_children_quarry:
if parent_child.child.id not in request.children:
parent_child.delete_instance()
if request.children is not None:
potential_children_quarry = CardModel.select().where(CardModel.id.in_(request.children))
for iter_card in potential_children_quarry:
if bool(check_access_to_card(iter_card, user_id) & AccessType.READ) and not (iter_card == card):
try:
ParentChild.get(ParentChild.parent == card, ParentChild.child == iter_card)
except DoesNotExist:
ParentChild.create(parent=card, child=iter_card)
for tag_card in TagCard.select().where(TagCard.card == card):
if tag_card.tag.id not in request.tags:
tag_card.delete_instance()
if request.tags is not None:
for tag in TagModel.select().where(TagModel.id.in_(request.tags)):
TagCard.get_or_create(tag=tag, card=card)
card.save()
return [_create_card_from_orm(card)], None
else:
return None, BaseError(provider.StorageProviderErrors.ACCESS_DENIED, "This user can't write to this card")
except DoesNotExist:
if bool(check_access_to_list(card_list, user_id) & AccessType.WRITE):
card = CardModel.create(name=request.name,
description=request.description,
expiration_date=request.expiration_date,
priority=Priority.MEDIUM if request.priority is None else request.priority,
assignee_id=request.assignee,
list=card_list,
user_id=user_id)
if request.tags is not None:
for tag in TagModel.select().where(TagModel.id.in_(request.tags)):
TagCard.create(tag=tag, card=card)
if request.children is not None:
potential_children_quarry = CardModel.select().where(CardModel.id.in_(request.children))
for iter_card in potential_children_quarry:
if bool(check_access_to_card(iter_card, user_id) & AccessType.READ) and not (iter_card == card):
ParentChild.create(parent=card, child=iter_card)
return [_create_card_from_orm(card)], None
else:
return None, BaseError(provider.StorageProviderErrors.ACCESS_DENIED, "This user has not enough rights for "
"this list")