def mutate(self, info, list_id: str):
if not ListModel.objects.filter(id=map_id(list_id)).exists():
raise exceptions.ObjectDoesNotExist('Provided list does not exist')
user = get_user_by_context(info.context)
originalList = ListModel.objects.get(id=map_id(list_id))
board = originalList.board
board.check_user(user, "User is not allowed to modify old board")
# update positions of other lists on board
for eachList in board.lists.all():
if eachList.position_on_board > originalList.position_on_board:
eachList.position_on_board = eachList.position_on_board + 1
eachList.save()
copiedList = ListModel(
title=originalList.title,
board=originalList.board,
position_on_board=originalList.position_on_board + 1,
is_hidden=originalList.is_hidden)
copiedList.save()
for originalCard in originalList.cards.all():
newCard = originalCard.copy_without_id()
newCard.list = copiedList
newCard.save()
return MoveList(copiedList)
def mutate(self, info: ResolveInfo, card_id: str, content: str, **kwargs):
user = get_user_by_context(info.context)
type_val = kwargs.get('type_val', None)
created_on = kwargs.get('created_on', None)
type_val = type_val if type_val is not None else ActivityTypeEnum.ACTIVITY_LOG_VAL
if not CardModel.objects.filter(id=map_id(card_id)):
return exceptions.ObjectDoesNotExist(
"Provided card does not exist")
if not ActivityTypeEnum.is_viable_enum(type_val):
return exceptions.FieldError(
"type_val is not a viable ActivityType value")
card = CardModel.objects.get(id=map_id(card_id))
card.list.board.check_user(user,
"User is not allowed to modify this board")
if created_on is None:
activity = ActivityModel(
card=card,
user=user,
content=content,
type=type_val,
)
else:
activity = ActivityModel(
card=card,
user=user,
content=content,
created_on=created_on,
type=type_val,
)
activity.save()
return CreateActivity(activity=activity)
def mutate(self, info: ResolveInfo, admin_id: str, board_id: str):
success = False
user = get_user_by_context(info.context)
if BoardModel.objects.filter(id=map_id(board_id)).exists():
board = BoardModel.objects.get(id=map_id(board_id))
if not UserModel.objects.filter(id=map_id(admin_id)).exists():
raise exceptions.ObjectDoesNotExist(
'Cannot entitle user to become admin, that does not exist')
would_be_admin = UserModel.objects.get(id=map_id(admin_id))
if (user not in board.admins):
raise exceptions.PermissionDenied(
'User has no permissions to give somebody administrative privileges'
)
if (would_be_admin in board.admins
or would_be_admin is board.maker):
raise exceptions.SuspiciousOperation(
'User is already board admin, it\'s kinda sus')
board.admins.add(would_be_admin)
board.save()
success = True
return AddAdmin(board=board, success=success)
else:
raise exceptions.ObjectDoesNotExist(
'Cannot add admin to board that does not exist')
def mutate(self, info: ResolveInfo, list_id: str):
if not ListModel.objects.filter(id=map_id(list_id)).exists():
raise exceptions.ObjectDoesNotExist('Provided list does not exist')
user = get_user_by_context(info.context)
list = ListModel.objects.get(id=map_id(list_id))
board = list.board
board.check_user(user, "User is not allowed to modify this board")
list.hide()
list.save()
return HideList(list=list)
def mutate(self, info: ResolveInfo, card_id: str):
user = get_user_by_context(info.context)
if CardModel.objects.filter(id=map_id(card_id)).exists():
card = CardModel.objects.get(id=map_id(card_id))
listdb = card.list
listdb.board.check_user(
user, "User is not allowed to modify this board")
card.delete()
return DeleteCard(card=card, success=True)
else:
raise exceptions.ObjectDoesNotExist("Provided card does not exist")
def mutate(self, info: ResolveInfo, boardId: str, visibility: bool):
if BoardModel.objects.filter(id=map_id(boardId)).exists():
board: BoardModel = BoardModel.objects.get(id=map_id(boardId))
user = get_user_by_context(info.context)
board.check_user_update(
user=user, message='User has no permissions to update board')
board.is_visible = visibility
board.save()
board.save()
return ChangeBoardVisibility(board=board)
return exceptions.ObjectDoesNotExist("Given board does not exist")
def resolve_activitysByCard(self, info: ResolveInfo, cardId: str,
**kwargs):
if not CardModel.objects.filter(id=map_id(cardId)).exists():
return exceptions.ObjectDoesNotExist(
"Provided card does not exist")
user = get_user_by_context(info.context)
card = CardModel.objects.get(id=map_id(cardId))
card.list.board.check_user(
user,
"User is not allowed to even LOOK at this board. Get him outa here"
)
return ActivityModel.objects.filter(card=card)
def mutate(self, info: ResolveInfo, name: str, color: str, board_id: str):
user = get_user_by_context(info.context)
if not BoardModel.objects.filter(id=map_id(board_id)).exists():
raise exceptions.ObjectDoesNotExist(
"Provided board does not exist")
board = BoardModel.objects.get(id=map_id(board_id))
board.check_user(user, "User is not allowed to modify this board")
label = LabelModel(name=name, color=color, board=board)
label.save()
return CreateLabel(label=label)
def mutate(self, info, board_id: str, title: str, description: str,
background: str):
if BoardModel.objects.filter(id=map_id(board_id)).exists():
board: BoardModel = BoardModel.objects.get(id=map_id(board_id))
user = get_user_by_context(info.context)
board.check_user_update(
user=user, message='User has no permissions to update board')
board.title = title if title is not None else board.title
board.description = description if description is not None else board.description
board.background = background if background is not None else board.background
board.save()
return UpdateBoard(board=board)
return exceptions.ObjectDoesNotExist("Given board does not exist")
def mutate(self, info: ResolveInfo, board_id: str):
board = None
user = get_user_by_context(info.context)
if BoardModel.objects.filter(id=map_id(board_id)).exists():
board: BoardModel = BoardModel.objects.get(id=map_id(board_id))
board.check_user_update(
user=user, message='User has no permission to close the board')
board.close()
board.save()
return CloseBoard(board=board)
else:
raise exceptions.ObjectDoesNotExist(
'Cannot close board that does not exist')
def mutate(self,
info,
list_id: str,
title: str = None,
position_on_board: int = None):
if ListModel.objects.filter(id=map_id(list_id)).exists():
list = ListModel.objects.get(id=map_id(list_id))
user = get_user_by_context(info.context)
board = list.board
board.check_user(user, "User is not allowed to modify this board")
list.title = title if title is not None else list.title
list.position_on_board = position_on_board if position_on_board is not None else list.position_on_board
list.save()
return UpdateList(list=list)
return exceptions.ObjectDoesNotExist('Provided list does not exist')
def mutate(self, info: ResolveInfo, jti: str, user_id: str):
user = UserModel.objects.filter(pk=map_id(user_id)).get()
user.jtis.filter(value=jti).delete()
user.save()
return RevokeJTI(success=True)
def mutate(self, info: ResolveInfo, label_id: str):
user = get_user_by_context(info.context)
if not LabelModel.objects.filter(id=map_id(label_id)).exists():
raise exceptions.ObjectDoesNotExist(
"Provided label does not exist")
label = LabelModel.objects.get(id=map_id(label_id))
board = label.board
if board is None:
raise exceptions.ObjectDoesNotExist(
"Provided board does not exist")
board.check_user(user, "User is not allowed to modify this board")
label.delete()
return DeleteLabel(success=True)
def mutate(self, info: ResolveInfo, board_id: str):
success = False
user = get_user_by_context(info.context)
if BoardModel.objects.filter(id=map_id(board_id)).exists():
board: BoardModel = BoardModel.objects.get(id=map_id(board_id))
board.check_user_update(
user=user,
message="User has no permissions to delete the board")
board.delete()
success = True
return DeleteBoard(board=board, success=success)
else:
raise exceptions.ObjectDoesNotExist(
'Cannot delete board that does not exist')
def mutate(self, info: ResolveInfo, card_id: str, **kwargs):
# user = get_user_by_context(info.context)
title = kwargs.get('title', None)
description = kwargs.get('description', None)
list_id = kwargs.get('list_id', None)
archived = kwargs.get('archived', None)
due_date = kwargs.get('due_date', None)
position_in_list = kwargs.get('position_in_list', None)
cover = kwargs.get('cover', None)
if CardModel.objects.filter(id=map_id(card_id)).exists():
user = get_user_by_context(info.context)
card = CardModel.objects.get(id=map_id(card_id))
card.list.board.check_user(
user, 'User have no permission to update this board')
listdb: ListModel = None
if list_id is not None and ListModel.objects().filter(
id=map_id(list_id)).exists():
listdb = ListModel.objects().get(id=map_id(list_id))
elif list_id is not None:
raise exceptions.ObjectDoesNotExist(
'Provided list does not exist')
# listdb.board.check_user(user, "User is not allowed to modify this board")
card.edit(
title=title,
description=description,
listdb=listdb,
archived=archived,
due_date=due_date,
position_in_list=position_in_list,
cover=cover,
)
activityContent = user.name + " " + user.last_name + " edited card in list " + card.list.title
activity = ActivityModel(card=card,
user=user,
content=activityContent,
type=ActivityTypeEnum.ACTIVITY_LOG_VAL)
activity.save()
card.save()
return EditCard(card=card, success=True)
else:
raise exceptions.ObjectDoesNotExist("Provided card does not exist")
def mutate(self, info: ResolveInfo, title: str, board_id: str,
position_on_board: int):
success = False
user = get_user_by_context(info.context)
if BoardModel.objects.filter(id=map_id(board_id)).exists():
board = BoardModel.objects.get(id=map_id(board_id))
board.check_user(user, "User is not allowed to modify this board")
list = ListModel(title=title,
board=board,
position_on_board=position_on_board)
list.save()
success = True
return CreateNewList(list=list, success=success)
else:
raise exceptions.ObjectDoesNotExist(
'Provided board does not exist')
def resolve_labels(self, info: ResolveInfo, boardId: str, **kwargs):
print(info.path)
if not BoardModel.objects.filter(id=map_id(boardId)).exists():
raise exceptions.ObjectDoesNotExist(
"Provided board does not exist")
board = BoardModel.objects.get(id=boardId)
return LabelModel.objects.filter(board=board).all()
def mutate(self, info: ResolveInfo, activity_id: str, content: str):
user = get_user_by_context(info.context)
activity = ActivityModel.objects.get(id=map_id(activity_id))
activity.card.list.board.check_user(
user, "User is not allowed to modify this board")
activity.content = content
activity.save()
return EditActivity(activity=activity)
def mutate(self, info: ResolveInfo, name: str, color: str, label_id: str):
user = get_user_by_context(info.context)
if not LabelModel.objects.filter(id=map_id(label_id)).exists():
raise exceptions.ObjectDoesNotExist(
"Provided label does not exist")
label = LabelModel.objects.get(id=map_id(label_id))
board = label.board
if board is None:
raise exceptions.ObjectDoesNotExist(
"Provided board does not exist")
board.check_user(user, "User is not allowed to modify this board")
label.color = color if color is not None else label.color
label.name = name if name is not None else label.name
label.save()
return EditLabel(label=label)
def mutate(self, info, list_id: str, new_board_id: str,
new_position_on_board: int):
if not ListModel.objects.filter(id=map_id(list_id)).exists():
raise exceptions.ObjectDoesNotExist('Provided list does not exist')
if not BoardModel.objects.filter(id=map_id(new_board_id)).exists():
raise exceptions.ObjectDoesNotExist(
'Providede new board does not exist')
user = get_user_by_context(info.context)
listModel = ListModel.objects.get(id=map_id(list_id))
old_board = listModel.board
old_board.check_user(user, "User is not allowed to modify old board")
new_board = BoardModel.objects.get(id=map_id(new_board_id))
new_board.check_user(user, "User is not allowed to modify new board")
# update positions of other lists on old board
old_position_on_board = listModel.position_on_board
for eachList in old_board.lists.all():
if eachList.position_on_board >= old_position_on_board:
eachList.position_on_board = eachList.position_on_board - 1
eachList.save()
# if new_position_on_board is greater than number of lists already on board
# than new_position_on_board is truncated to this number
if new_position_on_board > len(new_board.lists):
new_position_on_board = len(new_board.lists)
# update positions of other lists on new board
for eachList in new_board.lists.all():
if eachList.position_on_board >= new_position_on_board:
eachList.position_on_board = eachList.position_on_board + 1
eachList.save()
listModel.board = new_board
listModel.position_on_board = new_position_on_board
listModel.save()
return MoveList(listModel)
def mutate(self, info: ResolveInfo, title: str, list_id: str):
user = get_user_by_context(info.context)
if not ListModel.objects.filter(id=map_id(list_id)).exists():
raise exceptions.ObjectDoesNotExist("Provided list does not exist")
list_db = ListModel.objects.filter(id=map_id(list_id)).get()
list_db.board.check_user(user,
"User is not allowed to modify this board")
lists_cards = CardModel.objects.filter(list=list_db)
card = CardModel(list=list_db,
title=title,
position_in_list=len(lists_cards))
card.save()
activityContent = user.name + " " + user.last_name + " created card and added it to list " + card.list.title
activity = ActivityModel(card=card,
user=user,
content=activityContent,
type=ActivityTypeEnum.ACTIVITY_LOG_VAL)
activity.save()
return CreateCard(card=card, success=True)
def resolve_board(self, info: ResolveInfo, id: str, **kwargs):
user = None
board: BoardModel = BoardModel.objects.filter(id=map_id(id)).get()
if board.is_visible and not board.is_closed:
return board
try:
user = get_user_by_context(info.context)
except:
raise GraphQLError('Not found')
board.check_user(user=user,
message="User has no permission to view this board")
return board
def resolve_activitysByBoard(self, info: ResolveInfo, boardId: str,
**kwargs):
if not BoardModel.objects.filter(id=map_id(boardId)).exists():
return exceptions.ObjectDoesNotExist(
"Provided board does not exist")
user = get_user_by_context(info.context)
# *sniff* *sniff* reeks of newbie maybe will change it later
# sick, probably not :)
board = BoardModel.objects.get(id=map_id(boardId))
board.check_user(
user,
"User is not allowed to even LOOK at this board. Get him outa here"
)
activitiesQuerySet = ActivityModel.objects.filter(card=None)
lists = ListModel.objects.get(board=board)
for eachList in lists:
cards = CardModel.objects.filter(list=eachList)
for card in cards:
activitiesQuerySet.union(
ActivityModel.objects.filter(card=card))
return activitiesQuerySet
def resolve_card(self, info: ResolveInfo, **kwargs):
print(info.path)
return CardModel.objects.filter(id=map_id(id)).get()
def resolve_list(self, info: ResolveInfo, id: str, **kwargs):
return ListModel.objects.filter(id=map_id(id)).get()
def resolve_activity(self, info: ResolveInfo, id: str, **kwargs):
print(info.path)
user = get_user_by_context(info.context)
return ActivityModel.objects.filter(id=map_id(id)).get()
