# By: Riasat Ullah
# This file serves incident related pages and data.

from constants import api_paths, component_names as cnm, label_names as lnm, pages, static_vars, var_names
from context_manager import incidents_context, tutorials_context
from django.core import exceptions
from django.http import JsonResponse
from django.shortcuts import redirect, render
from django.views.decorators.http import require_http_methods
from pytz import timezone
from taskcallweb import settings
from system_tests.test_data import test_data_incidents
from translators import label_translator as lt
from utils import helpers
from validations import request_validator
import datetime
import json


@require_http_methods(['GET', 'POST'])
def get_incidents(request):
    '''
    GET: Returns the list of incidents page.
    POST: Gets the incident list data in json.
    :param request: Http request
    :return: Http response
    '''
    if request.method == 'GET':
        if request_validator.user_in_session(request):
            lang = request_validator.get_user_language(request)
            nav_bar_components = request_validator.get_nav_bar_components(request)
            component_features = request_validator.get_component_features(request)

            has_view_perm, has_edit_perm = request_validator.get_session_permission(
                request, cnm.dis_com_incidents, nav_bar_components
            )
            if not has_view_perm:
                raise exceptions.PermissionDenied

            context = incidents_context.get_incident_list_context(lang, nav_bar_components)
            context[var_names.has_edit_permission] = has_edit_perm
            context[var_names.has_team_permission] = request_validator.get_team_permission_status(request)
            context[var_names.has_incident_create_permission] =\
                True if cnm.feat_incidents_create in request_validator.get_component_features(request) else False
            context[var_names.has_contextual_search_permission] =\
                True if cnm.feat_incidents_tagging in component_features else False

            context = {**context,
                       **tutorials_context.tutorial_names_context(lang),
                       **tutorials_context.get_onboarding_welcome_context(lang),
                       **tutorials_context.get_onboarding_users_context(lang),
                       **tutorials_context.get_onboarding_incident_context(lang)}

            if 'flow' in request.GET:
                context[var_names.flow_id] = request.GET.get('flow')
            if 'step' in request.GET:
                context[var_names.step_number] = request.GET.get('step')
            if 'tutorial' in request.GET:
                context[var_names.tutorial_name] = request.GET.get('tutorial')

            return render(request, pages.incidents_page, context=context)
        else:
            helpers.set_session_redirect_page(request)
            return redirect(pages.login_url)
    elif request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                output = []
                status_type = body[var_names.status] if var_names.status in body else None
                assignee_type = body[var_names.assignee_type] if var_names.assignee_type in body else None

                if status_type is None and assignee_type is None:
                    output = test_data_incidents.incident_list
                elif status_type is not None and status_type == static_vars.open_state:
                    if assignee_type is None:
                        output = [item for item in test_data_incidents.incident_list
                                  if item[var_names.status] != static_vars.resolved_state]
                    elif assignee_type == static_vars.user_assignee:
                        output = test_data_incidents.incident_list[0:2]
                    elif assignee_type == static_vars.team_assignee:
                        output = [test_data_incidents.incident_list[2]]
                elif status_type is not None and status_type == static_vars.resolved_state:
                    resolved_items = [item for item in test_data_incidents.incident_list
                                      if item[var_names.status] == static_vars.resolved_state]
                    if assignee_type is None:
                        output = resolved_items
                    elif assignee_type == static_vars.user_assignee:
                        output = resolved_items[0:2]
                    elif assignee_type == static_vars.team_assignee:
                        output = [resolved_items[2]]
                return JsonResponse(output, safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_list, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['GET', 'POST'])
def get_incident_details(request, instance_id):
    '''
    GET: Returns the incident details page.
    POST: Gets all the details of a single incident.
    :param request: Http request
    :param instance_id: the organization instance ID
    :return: Http response
    '''
    if request.method == 'GET':
        if request_validator.user_in_session(request):
            lang = request_validator.get_user_language(request)
            nav_bar_components = request_validator.get_nav_bar_components(request)
            component_features = request_validator.get_component_features(request)

            has_view_perm, has_edit_perm = request_validator.get_session_permission(
                request, cnm.dis_com_incidents, nav_bar_components
            )
            if not has_view_perm:
                raise exceptions.PermissionDenied

            context = incidents_context.get_incident_details_context(lang, nav_bar_components)
            context[var_names.has_edit_permission] = request_validator.has_edit_permission(
                request, cnm.dis_com_incidents)
            context['context'] = json.dumps({var_names.organization_instance_id: instance_id})
            context[var_names.has_team_permission] = request_validator.get_team_permission_status(request)

            # special features context
            context[var_names.has_add_responders_permission] =\
                True if cnm.feat_incidents_add_responders in component_features else False

            context[var_names.has_conference_permission] =\
                True if cnm.feat_incidents_conference in component_features else False

            context[var_names.has_incident_redaction_permission] =\
                True if cnm.feat_incidents_redaction in component_features else False

            context[var_names.has_incident_status_permission] =\
                True if cnm.feat_incidents_status in component_features else False

            context[var_names.has_past_incidents_permission] =\
                True if cnm.feat_incidents_past in component_features else False

            context[var_names.has_similar_ongoing_incidents_permission] =\
                True if cnm.feat_incidents_similar_ongoing in component_features else False

            context[var_names.has_workflows_permission] =\
                True if cnm.feat_incidents_workflows in component_features else False

            context[var_names.has_recent_changes_permission] =\
                True if cnm.feat_incidents_recent_changes in component_features else False

            context[var_names.has_call_back_permission] =\
                True if cnm.feat_incidents_call_back in component_features else False

            context[var_names.has_secondary_integrations_permission] =\
                True if cnm.feat_integrations_secondary in component_features else False

            context[var_names.has_contextual_search_permission] =\
                True if cnm.feat_incidents_tagging in component_features else False

            context[var_names.has_postmortem_permission] = request_validator.has_edit_permission(
                request, cnm.dis_com_postmortem)
            return render(request, pages.incident_details_page, context=context)
        else:
            helpers.set_session_redirect_page(request)
            return redirect(pages.login_url)
    elif request.method == 'POST':
        lang = request_validator.get_user_language(request)
        org_instance_id = int(instance_id)
        if request_validator.user_in_session(request):
            if settings.TEST_MODE:
                return JsonResponse(test_data_incidents.incident_details[org_instance_id], safe=False)
            else:
                body = {var_names.organization_instance_id: org_instance_id}
                status, output = helpers.post_api_request(api_paths.incidents_details, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def get_incident_payload(request):
    '''
    Gets the payload of an incident
    :param request: Http request
    :return: Http response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse(test_data_incidents.alerts_payload[0], safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_payload, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def get_incident_specific_alerts(request):
    '''
    Gets the list of all incidents that were merged with a particular incident.
    :param request: Http request
    :return: Http response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse(test_data_incidents.incident_specific_alerts, safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_incidents_alerts, body, request,
                                                          lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def get_past_incidents(request):
    '''
    Gets the list of all incidents similar to a particular incident
    that have occurred in the past 6 months.
    :param request: Http request
    :return: Http response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse(test_data_incidents.past_incidents, safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_incidents_past, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def get_similar_ongoing_incidents(request):
    '''
    Gets the list of all ongoing incidents that are similar to a given incident.
    :param request: Http request
    :return: Http response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse(test_data_incidents.similar_ongoing_incidents, safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_incidents_similar_ongoing, body,
                                                          request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def acknowledge_incident(request):
    '''
    Acknowledges an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse(datetime.datetime.now(timezone('UTC')).replace(tzinfo=None) +
                                    datetime.timedelta(minutes=15), safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_acknowledge, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def resolve_incident(request):
    '''
    Resolve an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Incident has been resolved', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_resolve, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def escalate_incident(request):
    '''
    Escalate an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Incident has been escalated', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_escalate, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def reassign_incident(request):
    '''
    Reassign an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Incident has been reassigned', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_reassign, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def snooze_incident(request):
    '''
    Snooze an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Incident has been snoozed', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_snooze, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def add_incident_responders(request):
    '''
    Add more responders to an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('New responders have been added', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_add_responders, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def amend_incident_urgency(request):
    '''
    Amends the urgency of an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('The urgency of the incident has been amended', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_amend_urgency, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def notate_incident(request):
    '''
    Add a note to an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Note has been added to the incident', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_notate, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def un_acknowledge_incident(request):
    '''
    Un-acknowledge incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Incident has been unacknowledged', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_un_acknowledge, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def merge_incident(request):
    '''
    Merge incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Incident has been merged', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_merge, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def un_merge_incident(request):
    '''
    Un-merge incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Incident has been un-merged', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_un_merge, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def redact_incident(request):
    '''
    Redact incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Incident has been redacted', safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_redact, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def add_impacted_business_service(request):
    '''
    Manually add a new business service to the list of business services impacted by a given incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('New impacted business services has been added', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_add_impact, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def remove_impacted_business_service(request):
    '''
    Remove an impacted business service.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Impacted business service has been removed', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_remove_impact, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def add_subscribers(request):
    '''
    Add new subscribers to an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('New subscribers have been added', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_add_subscribers, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def remove_subscribers(request):
    '''
    Remove subscribers from an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Subscribers have been removed', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_remove_subscribers, body, request,
                                                          lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def run_response_set(request):
    '''
    Run a response set on an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Response set has been run', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_run_response_set,
                                                          body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def run_workflow(request):
    '''
    Run a workflow on an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Workflow has been run', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_run_workflow, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def update_status(request):
    '''
    Post a status update for an instance
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Status update has been posted', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_update_status, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def add_conference_bridge(request):
    '''
    Add a conference bridge to an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Success', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_add_conference_bridge,
                                                          body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def execute_custom_action(request):
    '''
    Executes a custom action. Custom actions are actions that are processed by an external vendor.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('JIRA123', safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_custom_action, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def edit_incident_title(request):
    '''
    Edit the title of an incident
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            body[var_names.access_method] = static_vars.web
            if settings.TEST_MODE:
                return JsonResponse('Success', safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_edit_title, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def get_service_recent_incidents(request):
    '''
    Get the incidents that have recently occurred on a given service.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                output = [test_data_incidents.incident_list[0], test_data_incidents.incident_list[-1]]
                return JsonResponse(output, safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.services_incidents, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def get_service_recent_suppressed_alerts(request):
    '''
    Get the alerts that have been recently suppressed on a given service.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                suppressed_alerts = [item for item in test_data_incidents.task_alerts
                                     if item[var_names.status] == static_vars.suppressed_state]
                return JsonResponse(suppressed_alerts, safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.services_suppressed_alerts, body,
                                                          request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def get_live_call_numbers(request):
    '''
    Get the caller and receiver phone numbers of a live call.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse({var_names.from_number: '+13339876123', var_names.to_number: '+18009004509'},
                                    safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_live_call_numbers, body,
                                                          request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def save_tags(request):
    '''
    Add and remove tags from an incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            body = json.loads(request.body.decode())
            if settings.TEST_MODE:
                return JsonResponse('Success', safe=False)
            else:
                body[var_names.access_method] = static_vars.web
                status, output = helpers.post_api_request(api_paths.incidents_update_tags, body, request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)


@require_http_methods(['POST'])
def create_test_incident(request):
    '''
    Create a test incident.
    :param request: Http request
    :return: JSON response
    '''
    if request.method == 'POST':
        lang = request_validator.get_user_language(request)
        if request_validator.user_in_session(request):
            if settings.TEST_MODE:
                return JsonResponse('Success', safe=False)
            else:
                status, output = helpers.post_api_request(api_paths.incidents_test_create, dict(), request, lang=lang)
                return JsonResponse(output, status=status, safe=False)
        else:
            return JsonResponse(lt.get_label(lnm.err_unauthorized_access, lang), status=401, safe=False)