def move_list(request, board_id, list_id):
if request.method != "POST":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
list_ = get_list_or_404(request, board_id, list_id)
except Http404:
return JsonResponseNotFound({"message": "List not found"})
post_params = json.loads(request.body)
if not post_params.get("position"):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
position = post_params.get("position")
if position != "top" and position != "bottom" and not re.match(
r"^\d+", position):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
list_.move(member, position)
serializer = Serializer(board=list_.board)
return JsonResponse(serializer.serialize_list(list_))
def add_attachment(request, board_id, card_id):
if request.method != "POST":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
board = get_user_boards(request.user).get(id=board_id)
card = board.cards.get(id=card_id)
except (Board.DoesNotExist, Card.DoesNotExist) as e:
return JsonResponseNotFound({"message": "Not found."})
uploaded_file_content = request.body
if uploaded_file_content is None:
return JsonResponseNotFound({"message": "No file sent."})
with tempfile.TemporaryFile() as uploaded_file:
uploaded_file.write(uploaded_file_content)
uploaded_file_name = request.GET.get("uploaded_file_name",
custom_uuid())
attachment = card.add_new_attachment(member, uploaded_file,
uploaded_file_name)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card_attachment(attachment))
def add_requirement(request, board_id, card_id):
if request.method != "PUT":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
board = card.board
put_body = json.loads(request.body)
if not put_body.get("requirement"):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
requirement = board.requirements.get(id=put_body.get("requirement"))
# If the requirement is already in the card, we can't continue
if card.requirements.filter(id=requirement.id).exists():
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
card.add_requirement(member, requirement)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card(card))
def modify_comment(request, board_id, card_id, comment_id):
if request.method != "DELETE" and request.method != "POST":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
try:
comment = card.comments.get(id=comment_id)
except CardComment.DoesNotExist as e:
return JsonResponseNotFound({"message": "Not found."})
if request.method == "DELETE":
comment = _delete_comment(member, card, comment)
elif request.method == "POST":
post_params = json.loads(request.body)
new_comment_content = post_params.get("content")
if not new_comment_content:
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
comment = _edit_comment(member, card, comment, new_comment_content)
else:
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card_comment(comment))
def add_new_review(request, board_id, card_id):
if request.method != "PUT":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
board = card.board
put_body = json.loads(request.body)
if not put_body.get("members"):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
reviewers = board.members.filter(id__in=put_body.get("members"))
description = put_body.get("description", "")
card.add_review(member, reviewers=reviewers, description=description)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card(card))
def _add_card(request, board_id):
if request.method != "PUT":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
put_params = json.loads(request.body)
if not put_params.get("name") or not put_params.get(
"list") or not put_params.get("position"):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
if put_params.get("position") != "top" and put_params.get(
"position") != "bottom":
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
try:
list_ = get_list_or_404(request, board_id, put_params.get("list"))
except Http404:
return JsonResponseNotFound({"message": "List not found"})
new_card = list_.add_card(member=member,
name=put_params.get("name"),
position=put_params.get("position"))
serializer = Serializer(board=new_card.board)
return JsonResponse(serializer.serialize_card(new_card))
def move_to_list(request, board_id, card_id):
if request.method != "POST":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
post_params = json.loads(request.body)
member = request.user.member
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
# The new position of the card
new_position = post_params.get("position", "top")
# If there is no new_list param, the card is going to be moved in the same list currently is
if post_params.get("new_list"):
list_ = card.board.lists.get(id=post_params.get("new_list"))
card.move(member,
destination_list=list_,
destination_position=new_position)
else:
card.change_order(member, destination_position=new_position)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_board())
def add_new_comment(request, board_id, card_id):
if request.method != "PUT":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
put_params = json.loads(request.body)
member = request.user.member
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
# Getting the comment content
comment_content = put_params.get("content")
# If the comment is empty, fail
if not comment_content:
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
# Otherwise, add the comment
new_comment = card.add_comment(member, comment_content)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card_comment(new_comment))
def _move_all_list_cards(request, board_id):
if request.method != "POST":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
board = get_board_or_404(request, board_id)
except Http404:
return JsonResponseNotFound({"message": "Board not found"})
post_params = json.loads(request.body)
if not post_params.get("source_list") or not post_params.get(
"destination_list"):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
# Check if the lists exists and if they are different
try:
source_list = board.active_lists.get(id=post_params.get("source_list"))
destination_list = board.active_lists.get(
id=post_params.get("destination_list"))
if source_list.id == destination_list.id:
raise AssertionError()
except (List.DoesNotExist, AssertionError):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
# Move the cards
source_list.move_cards(member=member, destination_list=destination_list)
serializer = Serializer(board=board)
return JsonResponse(serializer.serialize_board())
def change_labels(request, board_id, card_id):
if request.method != "POST":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
board = card.board
post_params = json.loads(request.body)
if not post_params.get("labels"):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
label_ids = post_params.get("labels")
card.labels.clear()
for label_id in label_ids:
if board.labels.filter(id=label_id).exists():
label = board.labels.get(id=label_id)
card.labels.add(label)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card(card))
def get_board(request, board_id):
if request.method != "GET":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
try:
board = get_user_boards(request.user).get(id=board_id)
except Board.DoesNotExist:
return JsonResponseNotFound({"message": "Not found."})
serializer = Serializer(board=board)
return JsonResponse(serializer.serialize_board())
def get_card(request, board_id, card_id):
if request.method != "GET":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
serializer = Serializer(board=card.board)
card_json = serializer.serialize_card(card)
return JsonResponse(card_json)
def change(request, board_id, card_id):
if request.method != "PUT":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
put_params = json.loads(request.body)
if put_params.get("name"):
card.change_attribute(member,
attribute="name",
value=put_params.get("name"))
elif put_params.get("description"):
card.change_attribute(member,
attribute="description",
value=put_params.get("name"))
elif put_params.get("is_closed") is not None:
card.change_attribute(member,
attribute="is_closed",
value=put_params.get("name"))
elif put_params.get("due_datetime"):
due_datetime_str = put_params.get("due_datetime")
due_datetime = dateutil.parser.parse(due_datetime_str)
card.change_attribute(member,
attribute="due_datetime",
value=due_datetime)
elif "due_datetime" in put_params and put_params.get(
"due_datetime") is None:
card.change_attribute(member, attribute="due_datetime", value=None)
elif "value" in put_params:
card_value = put_params.get("value")
if card_value == "":
card_value = None
card.change_value(member=member, value=card_value)
else:
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card(card))
def get_members(request):
if request.method != "GET":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
current_member = request.user.member
members = current_member.viewable_members
serializer = Serializer()
response_json = []
for member in members:
response_json.append(serializer.serialize_member(member))
return JsonResponse(response_json, safe=False)
def remove_requirement(request, board_id, card_id, requirement_id):
if request.method != "DELETE":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
board = get_user_boards(request.user).get(id=board_id)
card = board.cards.get(id=card_id)
requirement = card.requirements.get(id=requirement_id)
except (Board.DoesNotExist, Card.DoesNotExist) as e:
return JsonResponseNotFound({"message": "Not found."})
card.remove_requirement(member, requirement)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card(card))
def add_se_time(request, board_id, card_id):
if request.method != "POST":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
post_params = json.loads(request.body)
spent_time = post_params.get("spent_time")
estimated_time = post_params.get("estimated_time")
date = post_params.get("date")
description = post_params.get("description", card.name)
if spent_time != "":
try:
spent_time = float(str(spent_time).replace(",", "."))
except ValueError:
return JsonResponseNotFound({"message": "Not found."})
else:
spent_time = None
if estimated_time != "":
try:
estimated_time = float(str(estimated_time).replace(",", "."))
except ValueError:
return JsonResponseNotFound({"message": "Not found."})
else:
estimated_time = None
if spent_time is None and estimated_time is None:
return JsonResponseNotFound({"message": "Not found."})
# Optional days ago parameter
days_ago = None
matches = re.match(r"^\-(?P<days_ago>\d+)$", date)
if matches:
days_ago = int(matches.group("days_ago"))
card.add_spent_estimated_time(member, spent_time, estimated_time, days_ago,
description)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card(card))
def remove_blocking_card(request, board_id, card_id, blocking_card_id):
if request.method != "DELETE":
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
member = request.user.member
try:
board = get_user_boards(request.user).get(id=board_id)
card = board.cards.get(id=card_id)
blocking_card = card.blocking_cards.exclude(id=card_id).get(
id=blocking_card_id)
except (Board.DoesNotExist, Card.DoesNotExist) as e:
return JsonResponseNotFound({"message": "Not found."})
card.remove_blocking_card(member, blocking_card)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card(card))
def remove_member(request, board_id, member_id):
if request.method != "DELETE":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
board = get_board_or_404(request, board_id)
except Http404:
return JsonResponseNotFound({"message": "Board not found"})
try:
member_to_remove = board.members.get(id=member_id)
board.remove_member(member=member, member_to_remove=member_to_remove)
except Member.DoesNotExist:
return JsonResponseNotFound({"message": "Member nor found."})
serializer = Serializer(board=board)
return JsonResponse(serializer.serialize_member(member_to_remove))
def update_forecasts(request, board_id, card_id):
try:
board = get_user_boards(request.user).get(id=board_id)
card = board.cards.get(id=card_id)
except (Board.DoesNotExist, Card.DoesNotExist) as e:
return JsonResponseNotFound({"message": "Not found."})
available_card_forecasters = Forecaster.objects.filter(
(Q(board=None) & Q(member=None))
| (Q(board=card.board) & Q(member=None))
| (Q(board=None) & Q(member__in=card.members.all())))
serializer = Serializer(board=card.board)
estimations = []
for forecaster in available_card_forecasters:
forecast = forecaster.make_forecast(card=card)
estimations.append(serializer.serialize_forecast(forecast))
return JsonResponse(estimations, safe=False, encoder=DjangoJSONEncoder)
def add_blocking_card(request, board_id, card_id):
if request.method != "PUT":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
put_body = json.loads(request.body)
if not put_body.get("blocking_card"):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
try:
board = get_user_boards(request.user).get(id=board_id)
card = board.cards.get(id=card_id)
blocking_card = board.cards.exclude(id=card_id).get(
id=put_body.get("blocking_card"))
except (Board.DoesNotExist, Card.DoesNotExist) as e:
return JsonResponseNotFound({"message": "Not found."})
card.add_blocking_card(member, blocking_card)
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card(card))
def add_member(request, board_id):
if request.method != "PUT":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
put_body = json.loads(request.body)
if not put_body.get("member"):
return HttpResponseBadRequest()
member_id = put_body.get("member")
try:
board = get_board_or_404(request, board_id)
except Http404:
return JsonResponseNotFound({"message": "Board not found"})
serializer = Serializer(board=board)
if board.members.filter(id=member_id).exists():
return JsonResponse(
serializer.serialize_member(board.members.get(id=member_id)))
member_type = put_body.get("member_type")
if not member_type or not member_type in ("admin", "normal", "guest"):
return JsonResponseNotFound({"message": "Member type not found"})
try:
new_member = Member.objects.get(id=member_id)
board.add_member(member=member, member_to_add=new_member)
member_role, member_role_created = MemberRole.objects.get_or_create(
board=board, type=member_type)
member_role.members.add(new_member)
except Member.DoesNotExist:
return JsonResponseNotFound({"message": "Not found."})
return JsonResponse(serializer.serialize_member(new_member))
def change_members(request, board_id, card_id):
if request.method != "POST":
return JsonResponseMethodNotAllowed(
{"message": "HTTP method not allowed."})
member = request.user.member
try:
card = get_card_or_404(request, board_id, card_id)
except Http404:
return JsonResponseNotFound({"message": "Card not found."})
board = card.board
post_params = json.loads(request.body)
if not post_params.get("members"):
return JsonResponseBadRequest(
{"message": "Bad request: some parameters are missing."})
member_ids = post_params.get("members")
card.update_members(member, board.members.filter(id__in=member_ids))
serializer = Serializer(board=card.board)
return JsonResponse(serializer.serialize_card(card))