def duration(request):
    """
        API for updating call duration
    """
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'POST':
        session_id = request.POST['session_id']
        duration = request.POST['duration']
        session = Session.objects.get(session_id=session_id)

        create_session_phone_duration(session, duration)
        return HttpResponse(status=200, \
                            content=json.dumps({"status_code": "200"}))
    return HttpResponse("Should send a POST request", status=401)
def session(request):
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'GET':
        # Return all phone sessions for the authenticated user
        sessions = Session.objects.filter(subject=subject,
                                          session_type__name='phone')
        list_sessions = []
        date_format = "%Y-%m-%d %H:%M:%S"
        for session in sessions:
            str_startdate = session.start_date.strftime(date_format)
            str_enddate = session.end_date
            if str_enddate is not None:
                str_enddate = str_enddate.strftime(date_format)
            list_sessions += [{"session_id": session.session_id, \
                               "start_date": str_startdate, \
                               "end_date": str_enddate, \
                               "session_type": session.session_type.name}]
        return HttpResponse(status=200,
                            content=json.dumps({
                                "status_code": "200",
                                "sessions": list_sessions
                            }))

    elif request.method == 'POST':
        # Create a new session for the user
        session_type = Session_Type.objects.get(name='phone')
        new_session = generate_session(subject, session_type)
        return HttpResponse(status=200,
                            content=json.dumps({
                                "status_code":
                                "200",
                                "session_id":
                                new_session.session_id
                            }))

    return HttpResponse(status=405,
                        content=json.dumps({
                            "status_code": "405",
                            "error": "Invalid method"
                        }))
def task_value(request):
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'GET':
        # Return all phone-based tasks
        task_values = Task_Field_Value.objects.filter(task_field__task__instruction_phone__isnull=False, \
                                                      task_field__task__is_active=1, \
                                                      task_field__field_type__name='display')
        list_task_values = []
        for task_value in task_values:
            list_task_values += [{
                "task_value_id":
                task_value.task_field_value_id,
                "task_id":
                task_value.task_field.task.task_id,
                "value":
                task_value.value,
                "value_display":
                task_value.value_display,
                "difficulty_id":
                task_value.difficulty_id,
                "expected_response":
                task_value.response_expected,
                "task_field_value_id":
                task_value.task_field_value_id
            }]

        return HttpResponse(status=200,
                            content=json.dumps({
                                "status_code": "200",
                                "task_values": list_task_values
                            }))

    return HttpResponse(status=405,
                        content=json.dumps({
                            "status_code": "405",
                            "error": "Invalid method"
                        }))
def active_session(request):
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'GET':
        # Return all phone sessions that are active
        today = datetime.datetime.now()
        active_sessions = Session.objects.filter(
            subject_id=subject.user_id,
            session_type_id=SESSION_TYPE_ID_PHONE,
            start_date__lte=today,
            end_date__isnull=True).order_by('start_date')

        # Return oldest active session
        if active_sessions:
            return HttpResponse(status=200,
                                content=json.dumps({
                                    "status_code":
                                    "200",
                                    "session_id":
                                    active_sessions[0].session_id
                                }))

        return HttpResponse(status=404,
                            content=json.dumps({
                                "status_code": "400",
                                "error": "no active session"
                            }))
def difficulty_level(request):
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'GET':
        # Return all phone-based tasks
        difficulty_levels = Value_Difficulty.objects.all()
        list_difficulty_levels = []
        for difficulty_level in difficulty_levels:
            list_difficulty_levels += [{
                "difficulty_id": difficulty_level.value_difficulty_id,
                "name": difficulty_level.name
            }]

        return HttpResponse(status=200,
                            content=json.dumps({
                                "status_code":
                                "200",
                                "difficulty_levels":
                                list_difficulty_levels
                            }))

    return HttpResponse(status=405,
                        content=json.dumps({
                            "status_code": "405",
                            "error": "Invalid method"
                        }))
def generate_pin(request):
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'POST':
        # Generate a random 4-digit PIN for each user_id which has a blank/null PIN
        pin_length = 4
        subjects = Subject.objects.filter(phone_pin__isnull=True)
        num_updated = 0
        for next_subject in subjects:
            random_pin = random.randint(0, 10**pin_length - 1)
            next_subject.phone_pin = str(random_pin).zfill(
                pin_length)  # zero pad where necessary
            next_subject.save()
            num_updated += 1
        return HttpResponse(status=200,
                            content=json.dumps({
                                "status_code": "200",
                                "num_updated": num_updated
                            }))
    return HttpResponse(status=405,
                        content=json.dumps({
                            "status_code": "405",
                            "error": "Invalid method"
                        }))
def task(request):
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'GET':
        # Return all phone-based tasks
        tasks = Task.objects.filter(instruction_phone__isnull=False,
                                    is_active=1)
        list_tasks = []
        for task in tasks:
            list_tasks += [{"task_id": task.task_id, "task_name": task.name_id, \
                            "task_instruction": task.instruction_phone, \
                            "default_num_instances": task.default_num_instances}]

        return HttpResponse(status=200,
                            content=json.dumps({
                                "status_code": "200",
                                "tasks": list_tasks
                            }))

    return HttpResponse(status=405,
                        content=json.dumps({
                            "status_code": "405",
                            "error": "Invalid method"
                        }))
def winograd_value(request, assoc_id):
    '''
        API call for retrieving Winograd value
    '''

    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'GET':
        task_field_value = Task_Field_Value.objects.filter(
            assoc_id=assoc_id, task_field_id=TASK_FIELD_ID_WINOGRAD)
        if task_field_value:
            value = task_field_value[0].value
            return HttpResponse(status=200,
                                content=json.dumps({
                                    "status_code": "200",
                                    "value": value
                                }))
        return HttpResponse(status=404,
                            content=json.dumps({
                                "status_code": "404",
                                "error": "Not Found"
                            }))
def response(request):
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'POST':

        audio_data = None
        transcript = None

        if request.POST and 'session_task_instance_id' in request.POST and 'date_responded' in request.POST:
            session_task_instance_id = request.POST['session_task_instance_id']
            date_responded = request.POST['date_responded']
            num_repeats = None

            if 'num_repeats' in request.POST:
                num_repeats = request.POST['num_repeats'][0]
            if request.FILES and 'audio' in request.FILES:
                audio_data = ContentFile(request.FILES['audio'].read())
            if 'transcript' in request.POST:
                transcript = request.POST['transcript']

            # Check that the task instance ID is valid and that the response hasn't been submitted before
            session_response = Session_Response.objects.filter(
                session_task_instance_id=session_task_instance_id,
                session_task_instance__session_task__session__session_type__name
                ='phone',
                session_task_instance__session_task__session__subject=subject,
                date_completed__isnull=True)
            if session_response:
                session_response = session_response[0]

                # Save the audio response and/or the text response, and update the db record
                if audio_data:
                    session_response.value_audio.save('', audio_data)
                if transcript:
                    session_response.value_text = transcript
                if num_repeats:
                    session_response.num_repeats = num_repeats
                session_response.date_completed = date_responded

                # Update num_repeats if applicable
                if num_repeats:
                    session_response.num_repeats = num_repeats
                session_response.save()

            # Check if all session task instances associated with session_task are completed
            all_tasks_completed = True
            session_task_id = Session_Task_Instance.objects.get(
                session_task_instance_id=session_task_instance_id
            ).session_task_id
            session_task = Session_Task.objects.get(
                session_task_id=session_task_id)
            session_task_instances = Session_Task_Instance.objects.filter(
                session_task_id=session_task_id)
            for session_task_instance in session_task_instances:
                is_date_completed = Session_Response.objects.get(
                    session_task_instance_id=session_task_instance.
                    session_task_instance_id).date_completed
                if is_date_completed is None:
                    all_tasks_completed = False
                    break

            # If all task instances have been completed, update the session task object
            if all_tasks_completed:
                session_task.date_completed = date_responded
                session_task.save()

                # If all session_tasks have been completed, update the Session object and set it to complete
                incomplete_session_tasks = Session_Task.objects.filter(
                    session_id=session_task.session_id,
                    date_completed__isnull=True)
                if not incomplete_session_tasks:
                    session = Session.objects.get(
                        session_id=session_task.session_id)
                    session.end_date = date_responded
                    session.save()

            if session_response:
                if audio_data:
                    # Compute a checksum for the file stored on the server
                    filepath = os.path.join(MEDIA_ROOT,
                                            session_response.value_audio.name)
                    file_checksum = lib.generate_md5_checksum(filepath)
                    return HttpResponse(status=200, content=json.dumps({"status_code": "200", \
                                                                        "file_checksum": file_checksum, \
                                                                        "response_saved": True, \
                                                                        "all_tasks_completed": all_tasks_completed}))
                elif transcript:
                    return HttpResponse(status=200, content=json.dumps({"status_code": "200", \
                                                                        "response_saved": True, \
                                                                        "all_tasks_completed": all_tasks_completed}))
            return HttpResponse(status=200, content=json.dumps({"status_code": "200", \
                                                                "all_tasks_completed": all_tasks_completed, \
                                                                "response_saved": False}))
        return HttpResponse(status=404,
                            content=json.dumps({
                                "status_code": "404",
                                "error": "Not Found"
                            }))
    return HttpResponse(status=405,
                        content=json.dumps({
                            "status_code": "405",
                            "error": "Invalid method"
                        }))
Exemple #10
0
def session_task(request, session_task_id):
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    if request.method == 'GET':
        # Return all tasks for the requested session ID IFF the session belongs to the authenticated user
        session_task = Session_Task.objects.filter(
            session_task_id=session_task_id,
            session__subject=subject,
            session__session_type__name='phone')
        if session_task:
            session_task = session_task[0]
            list_session_task_instances = []
            date_format = "%Y-%m-%d %H:%M:%S"
            session_task_instance_values = Session_Task_Instance_Value.objects.filter(
                session_task_instance__session_task=session_task,
                task_field__field_type__name='display').order_by(
                    'session_task_instance', 'task_field')
            for session_task_instance_value in session_task_instance_values:
                str_datecompleted = None
                session_response = Session_Response.objects.filter(
                    session_task_instance_id=session_task_instance_value.
                    session_task_instance_id)
                if session_response:
                    session_response = session_response[0]
                    str_datecompleted = session_response.date_completed
                    if str_datecompleted is not None:
                        str_datecompleted = str_datecompleted.strftime(
                            date_format)

                task_field_value = Task_Field_Value.objects.get(
                    task_field_id=session_task_instance_value.task_field_id,
                    value=session_task_instance_value.value,
                    value_display=session_task_instance_value.value_display,
                    difficulty_id=session_task_instance_value.difficulty_id)
                list_session_task_instances += [{
                    "session_task_instance_id":
                    session_task_instance_value.session_task_instance_id,
                    "value":
                    session_task_instance_value.value,
                    "value_display":
                    session_task_instance_value.value_display,
                    "difficulty_id":
                    session_task_instance_value.difficulty_id,
                    "date_completed":
                    str_datecompleted,
                    "task_field_value_id":
                    task_field_value.task_field_value_id
                }]
            return HttpResponse(status=200,
                                content=json.dumps({
                                    "status_code":
                                    "200",
                                    "session_task_instances":
                                    list_session_task_instances
                                }))

        return HttpResponse(status=404,
                            content=json.dumps({
                                "status_code": "404",
                                "error": "Not Found"
                            }))
    return HttpResponse(status=405,
                        content=json.dumps({
                            "status_code": "405",
                            "error": "Invalid method"
                        }))
Exemple #11
0
def session_id(request, session_id):
    # Validate the headers
    auth_token = lib.validate_authorization_header(request.META)
    if not auth_token:
        response = HttpResponse(status=400, \
            content=json.dumps({"status_code": "400"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_request"'
        return response

    # Validate the access token
    subject = lib.authenticate(auth_token)
    if not subject:
        response = HttpResponse(status=401, \
            content=json.dumps({"status_code": "401"}))
        response['WWW-Authenticate'] = 'Bearer error="invalid_token"'
        return response

    # Verify the session exists and it's a phone session
    session = Session.objects.filter(subject=subject, session_id=session_id)
    if not session:
        return HttpResponse(status=404,
                            content=json.dumps({
                                "status_code": "404",
                                "error": "Not Found"
                            }))
    session = session[0]
    if session.session_type.name != 'phone':
        return HttpResponse(status=404,
                            content=json.dumps({
                                "status_code": "404",
                                "error": "Not Found"
                            }))

    if request.method == 'GET':
        # Return all tasks for the requested session ID IFF the session belongs to the authenticated user
        # Only return tasks that haven't been completed yet
        session_tasks = Session_Task.objects.filter(
            session=session, date_completed__isnull=True)
        list_session_tasks = []
        date_format = "%Y-%m-%d %H:%M:%S"
        for session_task in session_tasks:
            str_datecompleted = session_task.date_completed
            if str_datecompleted is not None:
                str_datecompleted = str_datecompleted.strftime(date_format)
            list_session_tasks += [{"session_task_id": session_task.session_task_id, \
                                    "task_name": session_task.task.name_id, \
                                    "task_instruction": session_task.task.instruction_phone, \
                                    "order": session_task.order, \
                                    "date_completed": str_datecompleted}]
        return HttpResponse(status=200,
                            content=json.dumps({
                                "status_code":
                                "200",
                                "session_tasks":
                                list_session_tasks
                            }))

    elif request.method == 'PUT' and request.body:
        # Update a particular session as completed if it is not already completed
        if not session.end_date:
            request_json = json.loads(request.body)
            if 'datetime_completed' in request_json:
                regex_datetime = re.compile(
                    r'^[0-9]{4}[-][0-9]{2}[-][0-9]{2} [0-9]{2}[:][0-9]{2}[:][0-9]{2}$'
                )
                datetime_completed = request_json['datetime_completed']
                if datetime_completed and regex_datetime.findall(
                        datetime_completed):
                    session.end_date = datetime_completed
                    session.save()
                    return HttpResponse(status=200,
                                        content=json.dumps(
                                            {"status_code": "200"}))

        return HttpResponse(status=404,
                            content=json.dumps({
                                "status_code": "404",
                                "error": "Not Found"
                            }))
    return HttpResponse(status=405,
                        content=json.dumps({
                            "status_code": "405",
                            "error": "Invalid method"
                        }))