def read_list(request: BoardDataRequest, board: BoardModel,
user_id: int) -> (List[CardsList], BaseError):
query = CardListModel.select()
list_response = []
if request.id is not None:
query = query.where(CardListModel.id == request.id)
if request.name is not None:
query = query.where(CardListModel.name == request.name)
if board is not None:
query = query.where(CardListModel.board == board)
if query.count() == 0:
return None, BaseError(
code=provider.StorageProviderErrors.LIST_DOES_NOT_EXIST,
description="List doesn't exist")
for card_list in query:
if bool(check_access_to_list(card_list, user_id) & AccessType.READ):
cards = [card.id for card in card_list.cards]
list_response += [CardsList(card_list.name, card_list.id, cards)]
if not list_response:
return None, BaseError(
code=provider.StorageProviderErrors.ACCESS_DENIED,
description="This user can't read this list")
else:
return list_response, None
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 write_list(request: BoardDataRequest, board: BoardModel,
user_id: int) -> (List[CardsList], BaseError):
try:
card_list = CardListModel.get(CardListModel.id == request.id)
if bool(check_access_to_list(card_list, user_id) & AccessType.WRITE):
card_list.name = request.name
card_list.save()
cards = [card_id for card_id in card_list.cards]
if board is not None:
card_list.board = board
return [CardsList(card_list.name, card_list.id, cards)], None
else:
return None, BaseError(
provider.StorageProviderErrors.ACCESS_DENIED,
"This user can't write to this list")
except DoesNotExist:
if bool(check_access_to_board(board, user_id) & AccessType.WRITE):
card_list = CardListModel.create(name=request.name, board=board)
CardListUserAccess.create(user_id=user_id, card_list=card_list)
return [CardsList(card_list.name, card_list.id)], None
else:
return None, BaseError(
provider.StorageProviderErrors.ACCESS_DENIED,
"This user has not enough rights for "
"this board")
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 execute(self, request: namedtuple) -> (namedtuple, BaseError):
if type(request.request_type) is not RequestType:
return None, BaseError(
code=StorageProviderErrors.REQUEST_TYPE_NOT_SPECIFIED,
description='Request type is not specified')
handler = self.handler_map[type(request)]
if handler is None:
return None, BaseError(
code=StorageProviderErrors.INVALID_REQUEST,
description='This request cannot be handled by this provider')
return handler(request)
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 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_list(request: BoardDataRequest,
user_id: int) -> (List[CardsList], BaseError):
try:
card_list = CardListModel.get(CardListModel.id == request.id)
access = check_access_to_list(card_list, user_id)
if bool(access & AccessType.WRITE):
CardListUserAccess.delete().where(
CardListUserAccess.card_list == card_list).execute()
_delete_list(card_list)
else:
return None, BaseError(
code=provider.StorageProviderErrors.ACCESS_DENIED,
description="This user can't delete this list")
except DoesNotExist:
return None, BaseError(
code=provider.StorageProviderErrors.LIST_DOES_NOT_EXIST,
description="List doesn't exist")
return None, None
def process_card_call(request: CardDataRequest) -> (namedtuple, BaseError):
try:
card_list = CardListModel.get(CardListModel.id == request.list_id) if request.list_id is not None else None
user_id = request.request_user_id
card_response, error = METHOD_MAP[request.request_type](request, user_id, card_list)
return provider.CardDataResponse(cards=card_response, request_id=request.request_id), error
except DoesNotExist:
return None, BaseError(code=provider.StorageProviderErrors.LIST_DOES_NOT_EXIST,
description="List or board doesn't exist")
def delete_tag(request: TagDataRequest) -> (List[TagModel], BaseError):
try:
tag_model = TagModel.get((TagModel.id == request.id)
| (TagModel.name == request.name))
TagCard.delete().where(TagCard.tag == tag_model).execute()
tag_model.delete_instance()
except DoesNotExist:
return None, BaseError(
code=provider.StorageProviderErrors.TAG_DOES_NOT_EXIST,
description="Tag doesn't exist")
return None, None
def delete_board(request: BoardDataRequest,
user_id: int) -> (List[Board], BaseError):
try:
board = BoardModel.get(BoardModel.id == request.id)
access = check_access_to_board(board, user_id)
if bool(access & AccessType.WRITE):
BoardUserAccess.delete().where(
BoardUserAccess.board == board).execute()
for card_list in board.card_lists:
list_processor._delete_list(card_list)
board.delete_instance()
else:
return None, BaseError(
code=StorageProviderErrors.ACCESS_DENIED,
description="This user can't delete this board")
except DoesNotExist:
return None, BaseError(code=StorageProviderErrors.BOARD_DOES_NOT_EXIST,
description="Board doesn't exist")
return None, None
def write_board(request: BoardDataRequest,
user_id: int) -> (List[Board], BaseError):
try:
board = BoardModel.get(BoardModel.id == request.id)
if bool(check_access_to_board(board, user_id) & AccessType.WRITE):
board.name = request.name
board.save()
lists = [list_id for list_id in board.card_lists]
return [Board(board.name, board.id, lists)], None
else:
return None, BaseError(StorageProviderErrors.ACCESS_DENIED,
"This user can't write to this board")
except DoesNotExist:
return [_create_board_with_defaults(request.name, user_id)], None
def read_board(request: BoardDataRequest,
user_id: int) -> (List[Board], BaseError):
query = BoardModel.select()
board_response = []
if request.id is not None:
query = query.where(BoardModel.id == request.id)
if request.name is not None:
query = query.where(BoardModel.name == request.name)
if query.count() == 0:
return None, BaseError(code=StorageProviderErrors.BOARD_DOES_NOT_EXIST,
description="Board doesn't exist")
for board in query:
if bool(check_access_to_board(board, user_id) & AccessType.READ):
lists = [card_list.id for card_list in board.card_lists]
board_response += [Board(board.name, board.id, lists)]
if not board_response:
return None, BaseError(code=StorageProviderErrors.ACCESS_DENIED,
description="This user can't read this board")
else:
return board_response, None
def process_list_call(
request: BoardDataRequest) -> (provider.ListDataResponse, BaseError):
try:
board = BoardModel.get(BoardModel.id == request.board_id
) if request.board_id is not None else None
user_id = request.request_user_id
list_response, error = METHOD_MAP[request.request_type](request,
user_id, board)
return provider.ListDataResponse(lists=list_response,
request_id=request.request_id), error
except DoesNotExist:
return None, BaseError(
code=provider.StorageProviderErrors.BOARD_DOES_NOT_EXIST,
description="Board doesn't exist")
def read_tag(request: TagDataRequest) -> (List[TagModel], BaseError):
if request.id is None and request.name is None:
tag_models = TagModel.select()
return [
Tag(tag_model.name, tag_model.id, tag_model.color)
for tag_model in tag_models
], None
else:
try:
tag_model = TagModel.get((TagModel.id == request.id)
| (TagModel.name == request.name))
return [Tag(tag_model.name, tag_model.id, tag_model.color)], None
except DoesNotExist:
return None, BaseError(
code=provider.StorageProviderErrors.TAG_DOES_NOT_EXIST,
description="Tag doesn't exist")
def process_plan_call(request: PlanDataRequest) -> (namedtuple, BaseError):
if type(request) == PlanTriggerRequest:
return create_cards_by_plans()
try:
card = CardModel.get(CardModel.id == request.card_id)
user_id = request.request_user_id
plan_response, error = METHOD_MAP[request.request_type](request,
user_id, card)
return provider.PlanDataResponse(plan=plan_response,
request_id=request.request_id), error
except DoesNotExist:
return None, BaseError(
code=provider.StorageProviderErrors.CARD_DOES_NOT_EXIST,
description="Card doesn't exist")
def _database_call(request: namedtuple) -> (List[User], BaseError):
if request.request_type == RequestType.WRITE:
user = User.create(id=request.id, username=request.name)
return [create_user_from_orm(user)], None
elif request.request_type == RequestType.READ:
query = User.select()
if request.id is not None or request.name is not None:
query = query.where((User.id == request.id)
| (User.username == request.name))
if query.count() == 0:
return None, BaseError(
code=UserProviderErrorCodes.USER_DOES_NOT_EXIST,
description="User doesn't "
"exist")
return [create_user_from_orm(orm_user) for orm_user in query], None
elif request.request_type == RequestType.DELETE:
User.delete().where(User.id == request.id).execute()
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")