Esempio n. 1
0
def do_import_reco(file_path) -> Recommendation:
    reco_dataframe = pd.read_csv(file_path)
    total_reco = new_reco = 0

    for row in reco_dataframe.itertuples():
        if str(row.benefit) == 'nan':
            continue
        reco = Recommendation.query.get(row.id)
        if not reco:
            reco = Recommendation()
            reco.id = row.id
            new_reco += 1

        reco.title = row.title
        if str(row.content) != 'nan':
            reco.content = row.content
        # TODO: temporary with set a default value
        else:
            reco.content = "Contenu non défini"
        if str(row.benefit) != 'nan':
            reco.benefit = row.benefit
        else:
            reco.benefit = 0.0
        if str(row.benefit_description) != 'nan':
            reco.benefit_description = row.benefit_description
        if str(row.how_to) != 'nan':
            reco.how_to = row.how_to
        reco.type = FootprintType({'label': row.category})
        total_reco += 1
        BaseObject.check_and_save(reco)

    print('Recommendations updated : %s' % str(total_reco - new_reco))
    print('Recommendations created : %s' % new_reco)
Esempio n. 2
0
def test_get_propositions_should_return_highest_probability_reco_first(app):
    # Given
    obj_to_save = []
    user = create_user(email='*****@*****.**',
                       username='******',
                       password='******')
    obj_to_save.append(user)

    recommendation_1 = create_recommendation(title='Prends ton vélo')
    recommendation_2 = create_recommendation(title='Prends ta trottinette')
    obj_to_save.append(recommendation_1)
    obj_to_save.append(recommendation_2)

    BaseObject.check_and_save(*obj_to_save)

    # When
    proposition_request = req_with_auth(email='*****@*****.**', password='******') \
        .get(API_URL + '/propositions')

    # Then
    assert proposition_request.status_code == 200
    content = proposition_request.json()
    assert len(content.get('propositions')) == 2
    reco_1_probability = content.get('propositions')[0].get('probability')
    reco_2_probability = content.get('propositions')[1].get('probability')
    assert reco_1_probability >= reco_2_probability
Esempio n. 3
0
def test_save_property_set_value_if_property_and_user_property_exist(app):
    # Given
    obj_to_save = []
    user = create_user(email='*****@*****.**',
                       username='******',
                       password='******')
    obj_to_save.append(user)
    question = Question()
    question.question_name = 'question_1'
    obj_to_save.append(question)
    BaseObject.check_and_save(*obj_to_save)

    user_property_obj = UserProperty()
    user_property_obj.user_id = user.id
    user_property_obj.question_id = question.id
    user_property_obj.value = float(12)
    BaseObject.check_and_save(user_property_obj)

    data = dict()
    data['question_1'] = "0.5"

    # When
    property_request = req_with_auth(email='*****@*****.**', password='******') \
        .post(API_URL + '/property', json=data)

    # Then
    assert property_request.status_code == 200

    user_property_obj = UserProperty.query. \
        filter_by(user_id=user.id). \
        filter_by(question_id=question.id). \
        first()

    assert user_property_obj is not None
    assert user_property_obj.value == 0.5
Esempio n. 4
0
def create_task_quiz(user_id):
    content = request.json
    task_quiz = TaskQuiz()
    task_quiz.userID = str(content['userID'])
    task_quiz.date        = str(content['date'])
    task_quiz.startTime   = str(content['startTime'])
    task_quiz.quizTime = str(content['quizTime'])
    task_quiz.taskSession = str(content['taskSession'])
    task_quiz.taskSessionTry = str(content['taskSessionTry'])
    task_quiz.section = str(content['section'])
    task_quiz.quizQnNum = str(content['quizQnNum'])
    task_quiz.quizQnRT = str(content['quizQnRT'])
    task_quiz.quizStimIndexCount = str(content['quizStimIndexCount'])
    task_quiz.quizStimIndex = str(content['quizStimIndex'])
    task_quiz.quizStimDevalue = str(content['quizStimDevalue'])
    task_quiz.quizStimContin = str(content['quizStimContin'])
    task_quiz.quizContinDefault = str(content['quizContinDefault'])
    task_quiz.quizContin = str(content['quizContin'])
    task_quiz.quizConfDefault = str(content['quizConfDefault'])
    task_quiz.quizConf = str(content['quizConf'])
    task_quiz.quizSoundLabel= str(content['quizSoundLabel'])
    task_quiz.playNum = str(content['playNum'])
    task_quiz.quizVolume = str(content['quizVolume'])
    task_quiz.quizVolumeNotLog = str(content['quizVolumeNotLog'])
    task_quiz.quizAverDefault= str(content['quizAverDefault'])
    task_quiz.quizAver= str(content['quizAver'])
    task_quiz.checkPoint= str(content['checkPoint'])
    BaseObject.check_and_save(task_quiz)
    result = dict({"success": "yes"})
    return jsonify(result)
Esempio n. 5
0
def inexpsave():
    """
    The experiments script updates the server periodically on subjects'
    progress. This lets us better understand attrition.
    """
    print("accessing the /inexpsave route")

    if ('prolific_id' in request.form) and ('longit_id' in request.form) and (
            'datastring' in request.form):
        prolific_id = request.form['prolific_id']
        longit_id = request.form['longit_id']
        datastring = request.form['datastring']
        print("getting the save data for prolific id {0}, longit id {1}: {2}".
              format(prolific_id, longit_id, datastring))

        user = Test.query.\
                filter(Test.prolific_id == workerId).\
                filter(Test.longit_id == longit_id).\
                one()
        user.datastring = datastring
        user.status = STARTED

        BaseObject.check_and_save(user)
        result = dict({"success": "yes"})

    return render_template('error.html', errornum=1012)
Esempio n. 6
0
    def execute(self, activity_id, user_id) -> Activity:
        if activity_id is None or user_id is None:
            raise BadArgException()

        # UPDATE ACTIVITY
        activity = Activity.query.filter_by(id=activity_id).first()
        activity.set_status(ActivityStatus.success)
        activity.set_date_end()

        # CREATE NEW : footprint
        footprint = Footprint.query. \
            filter_by(user_id=user_id). \
            filter_by(type=activity.recommendation.type). \
            order_by(Footprint.date_created.desc()). \
            first()

        previous_value = footprint.get_value()
        new_footprint = Footprint(from_dict=footprint._asdict())
        new_footprint.set_value(previous_value -
                                activity.recommendation.benefit)
        new_footprint.set_date_created()

        BaseObject.check_and_save(activity, new_footprint)

        return activity
Esempio n. 7
0
    def execute(sel, activity_id, user_id) -> Activity:
        if activity_id is None or user_id is None:
            raise BadArgException()

        # UPDATE ACTIVITY
        activity = Activity.query.filter_by(id=activity_id).first()
        activity.status = ActivityStatus.pending
        activity.set_date_end()

        # UPDATE : footprint
        footprint = Footprint.query. \
            filter_by(user_id=user_id). \
            filter_by(type=activity.recommendation.type). \
            order_by(Footprint.date_created.desc()). \
            first()

        previous_value = footprint.value
        new_footprint = Footprint(from_dict=footprint._asdict())
        new_footprint.value = previous_value + activity.recommendation.benefit
        new_footprint.set_date_created()

        BaseObject.check_and_save(activity, new_footprint)

        HistoryActivity().execute(activity.id, "pending")

        return activity
Esempio n. 8
0
def signup():
    data = request.json

    new_user = User(from_dict=request.json)
    new_user.id = None

    footprints = data.get('footprints')[0]
    BaseObject.check_and_save(new_user)

    objects_to_save = []
    for footprint in footprints.get('footprints'):
        footprint_obj = Footprint(from_dict=footprint)
        footprint_obj.user_id = int(new_user.get_id())
        objects_to_save.append(footprint_obj)

    # TODO: c'est pas beau mais c'était plus rapide :(
    answers = footprints.get('answers')
    for key, value in answers.items():
        property_obj = Property.query.filter_by(property_name=key).first()
        answer_obj = UserProperty()
        answer_obj.user_id = int(new_user.get_id())
        answer_obj.property_id = property_obj.id
        answer_obj.value = float(value)
        objects_to_save.append(answer_obj)

    BaseObject.check_and_save(*objects_to_save)

    login_user(new_user)

    return jsonify(new_user._asdict(include=USER_INCLUDES)), 201
Esempio n. 9
0
def create_psych_data(user_id):
    content = request.json
    psych_quiz = PsychQuiz()
    psych_quiz.userID = str(content['userID'])
    psych_quiz.date = str(content['date'])
    psych_quiz.startTime = str(content['startTime'])
    psych_quiz.qnTimeStart = str(content['qnTimeStart'])
    psych_quiz.qnTimeEnd = str(content['qnTimeEnd'])
    psych_quiz.PgFinish_demo = str(content['PgFinish_demo'])
    psych_quiz.PgFinish_OCIR = str(content['PgFinish_OCIR'])
    psych_quiz.PgFinish_STAI_Y1 = str(content['PgFinish_STAI_Y1'])
    psych_quiz.PgFinish_STAI_Y2 = str(content['PgFinish_STAI_Y2'])
    psych_quiz.PgRT_demo = str(content['PgRT_demo'])
    psych_quiz.PgRT_OCIR = str(content['PgRT_OCIR'])
    psych_quiz.PgRT_STAI_Y1 = str(content['PgRT_STAI_Y1'])
    psych_quiz.PgRT_STAI_Y2 = str(content['PgRT_STAI_Y2'])
    psych_quiz.age = str(content['age'])
    psych_quiz.gender = str(content['gender'])
    psych_quiz.OCIR = str(content['OCIR'])
    psych_quiz.STAI_Y1= str(content['STAI_Y1'])
    psych_quiz.STAI_Y2= str(content['STAI_Y2'])

    BaseObject.check_and_save(psych_quiz)
    result = dict({"success": "yes"})
    return jsonify(result)
Esempio n. 10
0
def enterexp():
    """
    AJAX listener that listens for a signal from the user's script when they
    leave the instructions and enter the real experiment. After the server
    receives this signal, it will no longer allow them to re-access the
    experiment applet (meaning they can't do part of the experiment and
    referesh to start over).
    """
    print("/inexp")
    if ('prolific_id' in request.form) and ('longit_id' in request.form):
        prolific_id = request.form['prolific_id']
        longit_id = request.form['longit_id']

    else:
        raise ValueError('improper_inputs')\

    user = Test.query.\
            filter(Test.prolific_id == prolific_id).\
            filter(Test.longit_id   == longit_id).\
            one()
    user.status = STARTED
    user.beginexp = datetime.datetime.now()

    BaseObject.check_and_save(user)
    result = dict({"success": "yes"})
    return "Success"
Esempio n. 11
0
def create_task_data(user_id):
    print(user_id)
    content = request.json
    task_data = TaskData()
    task_data.userID = str(content['userID'])
    task_data.date = str(content['date'])
    task_data.startTime = str(content['startTime'])
    task_data.taskSession = str(content['taskSession'])
    task_data.taskSessionTry = str(content['taskSessionTry'])
    task_data.trialNum = str(content['trialNum'])
    task_data.trialTime = str(content['trialTime'])
    task_data.blockNum = str(content['blockNum'])
    task_data.trialinBlockNum = str(content['trialinBlockNum'])
    task_data.devaluedBlock = str(content['devaluedBlock'])
    task_data.fixTime = str(content['fixTime'])
    task_data.attenIndexIndiv = str(content['attenIndexIndiv'])
    task_data.attenCheckKey = str(content['attenCheckKey'])
    task_data.attenCheckTime = str(content['attenCheckTime'])
    task_data.stimIndexCondIndiv = str(content['stimIndexCondIndiv'])
    task_data.stimTime = str(content['stimTime'])
    task_data.fbProbTrack = str(content['fbProbTrack'])
    task_data.randProb = str(content['randProb'])
    task_data.responseKey = str(content['responseKey'])
    task_data.reactionTime = str(content['reactionTime'])
    task_data.playFbSound = str(content['playFbSound'])
    task_data.fbTime = str(content['fbTime'])
    task_data.volume = str(content['volume'])
    task_data.volumeNotLog = str(content['volumeNotLog'])
    BaseObject.check_and_save(task_data)
    result = dict({"success": "yes"})
    return jsonify(result)
Esempio n. 12
0
def test_get_property_should_return_value_for_property_if_already_answered(
        app):
    # Given
    obj_to_save = []
    user = create_user(email='*****@*****.**',
                       username='******',
                       password='******')
    obj_to_save.append(user)
    question = Question()
    question.question_name = 'question_1'
    obj_to_save.append(question)
    BaseObject.check_and_save(*obj_to_save)
    user_property_obj = UserProperty()
    user_property_obj.user_id = user.id
    user_property_obj.question_id = question.id
    user_property_obj.value = float(0.5)
    BaseObject.check_and_save(user_property_obj)

    # When
    property_request = req_with_auth(email='*****@*****.**', password='******') \
        .get(API_URL + '/property')

    # Then
    assert property_request.status_code == 200
    content = property_request.json()
    assert 'question_1' in content
    assert content['question_1'] == 0.5
Esempio n. 13
0
def create_pilot_data(user_id):
    content = request.json
    audio_pilot = AudioPilot()
    audio_pilot.userID = str(content['userID'])
    audio_pilot.date = str(content['date'])
    audio_pilot.startTime = str(content['startTime'])
    audio_pilot.qnNum = str(content['qnNum'])
    audio_pilot.qnTime = str(content['qnTime'])
    audio_pilot.qnRT = str(content['qnRT'])
    audio_pilot.soundIndex = str(content['soundIndex'])
    audio_pilot.soundFocus = str(content['soundFocus'])
    audio_pilot.freqFocus = str(content['freqFocus'])
    audio_pilot.volume = str(content['volume'])
    audio_pilot.volumePer = str(content['volumePer'])
    audio_pilot.checkBox = str(content['checkBox'])
    audio_pilot.playNum = str(content['playNum'])
    audio_pilot.averRating = str(content['averRating'])
    audio_pilot.arouRating = str(content['arouRating'])
    audio_pilot.averRatingDef = str(content['averRatingDef'])
    audio_pilot.arouRatingDef = str(content['arouRatingDef'])


    BaseObject.check_and_save(audio_pilot)
    result = dict({"success": "yes"})
    return jsonify(result)
Esempio n. 14
0
def create_vol_cal_data(user_id):
    print(user_id)
    content = request.json
    vol_cal = VolCal()
    vol_cal.userID      = str(content['userID'])
    vol_cal.date        = str(content['date'])
    vol_cal.startTime   = str(content['startTime'])
    vol_cal.volCalStage = str(content['volCalStage'])
    vol_cal.checkTry    = str(content['checkTry'])
    vol_cal.qnTime      = str(content['qnTime'])
    vol_cal.qnRT        = str(content['qnRT'])
    vol_cal.qnNum       = str(content['qnNum'])
    vol_cal.soundIndex  = str(content['soundIndex'])
    vol_cal.soundFocus  = str(content['soundFocus'])
    vol_cal.volume      = str(content['volume'])
    vol_cal.volumePer   = str(content['volumePer'])
    vol_cal.volumeNotLog = str(content['volumeNotLog'])
    vol_cal.playNum     = str(content['playNum'])
    vol_cal.quizAnsIndiv = str(content['quizAnsIndiv'])
    vol_cal.qnPressKey  = str(content['qnPressKey'])
    vol_cal.qnCorrIndiv = str(content['qnCorrIndiv'])
    vol_cal.averRating  = str(content['averRating'])
    vol_cal.arouRating  = str(content['arouRating'])
    vol_cal.averRatingDef= str(content['averRatingDef'])
    vol_cal.arouRatingDef= str(content['arouRatingDef'])
    BaseObject.check_and_save(vol_cal)
    result = dict({"success": "yes"})
    return jsonify(result)
Esempio n. 15
0
    def execute(self, footprint: Footprint) -> Footprint:
        if footprint is None:
            raise BadArgException()

        BaseObject.check_and_save(footprint)

        return footprint
Esempio n. 16
0
def create_tutorial_data(user_id):
    content = request.json
    tutorial_data = TutorialData()
    tutorial_data.userID = str(content['userID'])
    tutorial_data.date = str(content['date'])
    tutorial_data.startTime = str(content['startTime'])
    tutorial_data.tutorialSession = str(content['tutorialSession'])
    tutorial_data.tutorialSessionTry = str(content['tutorialSessionTry'])
    tutorial_data.trialNum = str(content['trialNum'])
    tutorial_data.trialTime = str(content['trialTime'])
    tutorial_data.fixTime = str(content['fixTime'])
    tutorial_data.attenIndex = str(content['attenIndex'])
    tutorial_data.attenCheckKey = str(content['attenCheckKey'])
    tutorial_data.attenCheckTime = str(content['attenCheckTime'])
    tutorial_data.stimTime = str(content['stimTime'])
    tutorial_data.stimIndex = str(content['stimIndex'])
    tutorial_data.fbProbTrack = str(content['fbProbTrack'])
    tutorial_data.randProb = str(content['randProb'])
    tutorial_data.responseKey = str(content['responseKey'])
    tutorial_data.reactionTime = str(content['reactionTime'])
    tutorial_data.playFbSound = str(content['playFbSound'])
    tutorial_data.fbTime = str(content['fbTime'])
    tutorial_data.volume = str(content['volume'])
    tutorial_data.volumeNotLog = str(content['volumeNotLog'])
    BaseObject.check_and_save(tutorial_data)
    result = dict({"success": "yes"})
    return jsonify(result)
Esempio n. 17
0
    def execute(self, user: User,
                reco_already_attach_to_user: [Recommendation]) -> list:
        if user is None:
            raise BadUserException()

        query = Recommendation.query. \
            filter(Recommendation.id.notin_(reco_already_attach_to_user))

        if "RECO_ENGINE" in os.environ \
                and int(os.environ.get("RECO_ENGINE")) == 1:

            possible_recommendations = np.array(query.all())

            self.compute_possible_recommendation_with_ml(
                possible_recommendations)

        else:
            possible_recommendations = query.all()
            random.shuffle(possible_recommendations)

        result = list()
        first = True
        for reco in possible_recommendations:

            proposition = Proposition.query. \
                filter_by(user_id=user.id). \
                filter_by(recommendation_id=reco.id). \
                filter_by(state=None). \
                first()

            if proposition is None:
                proposition = Proposition()
                proposition.user_id = user.id
                proposition.recommendation_id = reco.id

            if "RECO_ENGINE" in os.environ \
                    and int(os.environ.get("RECO_ENGINE")) == 0:
                proposition.probability = random.uniform(0.0, 1.0)

            proposition.date_write = datetime.utcnow()

            BaseObject.check_and_save(proposition)

            tmp_obj = dict(reco._asdict())
            tmp_obj['proposition_id'] = humanize(proposition.id)
            tmp_obj['probability'] = proposition.probability

            if first:
                tmp_obj['first'] = True
                first = False
            else:
                tmp_obj['first'] = False
            result.append(tmp_obj)

        sorted_result = sorted(result,
                               key=lambda k: k['probability'],
                               reverse=True)

        return sorted_result
Esempio n. 18
0
def start_exp():
    """
        Serves up the experiment applet.
    """
    print('prolific_id' in request.args)

    print('Start Expe')

    if not ('prolific_id' in request.args) and (
            'study_id'
            in request.args) and ('participant_id'
                                  in request.args) and ('longit_id'
                                                        in request.args):
        raise ExperimentError(
            'prolific_study_participant_longit_id_not_set_in_exp_url')

    prolific_id = request.args['prolific_id']
    study_id = request.args['study_id']
    participant_id = request.args['participant_id']
    longit_id = request.args['longit_id']

    print(
        ("Prolific ID: {0}, Study ID: {1}, Participant ID: {2}, Longit ID: {3}"
         ).format(prolific_id, study_id, participant_id, longit_id))

    # Filter for prolific id and longit id in the DB: check first to see if they exist.
    matches = Test.query.\
                        filter(Test.prolific_id == prolific_id).\
                        filter(Test.longit_id == longit_id).\
                        all()
    # print(matches)
    numrecs = len(matches)
    if numrecs == 0:  # is not in the DB -> create a record in the DB
        part = Test(prolific_id, study_id, participant_id, longit_id)

        print("No match. Status is", part.status)

        part.status = STARTED
        part.beginexp = datetime.datetime.now()
        part.prolific_id = prolific_id
        part.study_id = study_id
        part.longit_id = int(longit_id)
        part.participant_id = int(participant_id)

        BaseObject.check_and_save(part)

        result = dict({"success": "yes"})

    else:
        part = matches[0]
        print("Participant id {0} matched in the DB! Status is {1}".format(
            participant_id, part.status))

    # Start the task
    return render_template('ps_dev_exp.html',
                           study_id=study_id,
                           participant_id=participant_id,
                           prolific_id=prolific_id,
                           longit_id=longit_id)
Esempio n. 19
0
def create_psych_data(user_id):
    content = request.json
    psych_quiz = PsychQuiz()
    psych_quiz.userID = str(content['userID'])
    psych_quiz.date = str(content['date'])
    psych_quiz.startTime = str(content['startTime'])
    psych_quiz.qnTimeStart = str(content['qnTimeStart'])
    psych_quiz.qnTimeEnd = str(content['qnTimeEnd'])
    psych_quiz.PgFinish_demo = str(content['PgFinish_demo'])
    psych_quiz.PgFinish_OCIR = str(content['PgFinish_OCIR'])
    psych_quiz.PgFinish_STAI_Y1 = str(content['PgFinish_STAI_Y1'])
    psych_quiz.PgFinish_STAI_Y2 = str(content['PgFinish_STAI_Y2'])
    psych_quiz.PgFinish_BIS11 = str(content['PgFinish_BIS11'])
    psych_quiz.PgFinish_SDS = str(content['PgFinish_SDS'])
    psych_quiz.PgFinish_ASI3 = str(content['PgFinish_ASI3'])
    psych_quiz.PgFinish_BEAQ = str(content['PgFinish_BEAQ'])
    psych_quiz.PgFinish_IQ_text = str(content['PgFinish_IQ_text'])
    psych_quiz.PgFinish_IQ_image = str(content['PgFinish_IQ_image'])
    psych_quiz.PgRT_demo = str(content['PgRT_demo'])
    psych_quiz.PgRT_OCIR = str(content['PgRT_OCIR'])
    psych_quiz.PgRT_STAI_Y1 = str(content['PgRT_STAI_Y1'])
    psych_quiz.PgRT_STAI_Y2 = str(content['PgRT_STAI_Y2'])
    psych_quiz.PgRT_BIS11 = str(content['PgRT_BIS11'])
    psych_quiz.PgRT_SDS = str(content['PgRT_SDS'])
    psych_quiz.PgRT_ASI3 = str(content['PgRT_ASI3'])
    psych_quiz.PgRT_BEAQ = str(content['PgRT_BEAQ'])
    psych_quiz.PgRT_IQ_text = str(content['PgRT_IQ_text'])
    psych_quiz.PgRT_IQ_image = str(content['PgRT_IQ_image'])
    psych_quiz.age = str(content['age'])
    psych_quiz.gender = str(content['gender'])
    psych_quiz.OCIR = str(content['OCIR'])
    psych_quiz.STAI_Y1 = str(content['STAI_Y1'])
    psych_quiz.STAI_Y2 = str(content['STAI_Y2'])
    psych_quiz.BIS11 = str(content['BIS11'])
    psych_quiz.SDS = str(content['SDS'])
    psych_quiz.ASI3 = str(content['ASI3'])
    psych_quiz.BEAQ = str(content['BEAQ'])
    psych_quiz.IQ_1 = str(content['IQ_1'])
    psych_quiz.IQ_2 = str(content['IQ_2'])
    psych_quiz.IQ_1 = str(content['IQ_1'])
    psych_quiz.IQ_2 = str(content['IQ_2'])
    psych_quiz.IQ_3 = str(content['IQ_3'])
    psych_quiz.IQ_4 = str(content['IQ_4'])
    psych_quiz.IQ_5 = str(content['IQ_5'])
    psych_quiz.IQ_6 = str(content['IQ_6'])
    psych_quiz.IQ_7 = str(content['IQ_7'])
    psych_quiz.IQ_8 = str(content['IQ_8'])
    psych_quiz.IQimage_1 = str(content['IQimage_1'])
    psych_quiz.IQimage_2 = str(content['IQimage_2'])
    psych_quiz.IQimage_3 = str(content['IQimage_3'])
    psych_quiz.IQimage_4 = str(content['IQimage_4'])
    psych_quiz.IQimage_5 = str(content['IQimage_5'])
    psych_quiz.IQimage_6 = str(content['IQimage_6'])
    psych_quiz.IQimage_7 = str(content['IQimage_7'])
    psych_quiz.IQimage_8 = str(content['IQimage_8'])

    BaseObject.check_and_save(psych_quiz)
    result = dict({"success": "yes"})
    return jsonify(result)
def test_search_without_text_in_the_form(app):
    user = create_user()
    user.id = 1
    BaseObject.check_and_save(user)
    create_reco("recommendations_data_test")
    r = req.get(API_URL + '/recommendations/search?title=""')
    search_json = r.json()
    assert r.status_code == 400
    assert search_json['error'] == 'No recommendation found'
Esempio n. 21
0
    def execute(self, activity_id, user_id) -> Activity:
        if activity_id is None or user_id is None:
            raise BadArgException()

        activity = Activity.query.filter_by(id=activity_id).first()
        activity.set_status(ActivityStatus.fail)
        activity.set_date_end()

        BaseObject.check_and_save(activity)

        return activity
Esempio n. 22
0
def create_feedback(user_id):
    content = request.json
    feedback = Feedback()
    feedback.userID     = str(content['userID'])
    feedback.date        = str(content['date'])
    feedback.startTime   = str(content['startTime'])
    feedback.feedback    = str(content['feedback'])

    BaseObject.check_and_save(feedback)
    result = dict({"success": "yes"})
    return jsonify(result)
Esempio n. 23
0
    def execute(self, proposition_id: int):
        if proposition_id is None:
            raise BadArgException()

        proposition = Proposition.query.get(proposition_id)

        if proposition is None:
            raise BadIdException()

        proposition.state = PropositionStatus.refused
        BaseObject.check_and_save(proposition)

        HistoryProposition().execute(proposition.id, "refused")
Esempio n. 24
0
def create_freq_data(user_id):
    content = request.json
    audio_freq = AudioFreq()
    audio_freq.userID = str(content['userID'])
    audio_freq.date = str(content['date'])
    audio_freq.startTime = str(content['startTime'])
    audio_freq.qnNum = str(content['qnNum'])
    audio_freq.qnTime = str(content['qnTime'])
    audio_freq.qnRT = str(content['qnRT'])
    audio_freq.volume = str(content['volume'])
    audio_freq.volumeNotLog = str(content['volumeNotLog'])
    audio_freq.freqThresIndiv = str(content['freqThresIndiv'])
    audio_freq.sliderFreqDefault = str(content['sliderFreqDefault'])

    BaseObject.check_and_save(audio_freq)
    result = dict({"success": "yes"})
    return jsonify(result)
Esempio n. 25
0
def create_tutorial_quiz(user_id):
    content = request.json
    tutorial_quiz = TutorialQuiz()
    tutorial_quiz.userID = str(content['userID'])
    tutorial_quiz.date = str(content['date'])
    tutorial_quiz.startTime = str(content['startTime'])
    tutorial_quiz.quizTime = str(content['quizTime'])
    tutorial_quiz.tutorialSession = str(content['tutorialSession'])
    tutorial_quiz.tutorialSessionTry = str(content['tutorialSessionTry'])
    tutorial_quiz.quizSession = str(content['quizSession'])
    tutorial_quiz.quizQnNum = str(content['quizQnNum'])
    tutorial_quiz.quizKeypress = str(content['quizKeypress'])
    tutorial_quiz.quizQnRT = str(content['quizQnRT'])
    tutorial_quiz.quizScoreCor = str(content['quizScoreCor'])
    BaseObject.check_and_save(tutorial_quiz)
    result = dict({"success": "yes"})
    return jsonify(result)
Esempio n. 26
0
    def execute(self, recommendation_id: int, user_id: int):
        if recommendation_id is None or user_id is None:
            raise BadArgException()

        # TODO: refactor with proposition_id as a parameter of this function (from webapp)
        proposition = Proposition.query. \
            filter_by(recommendation_id=recommendation_id). \
            filter_by(user_id=user_id). \
            order_by(Proposition.date_created.desc()). \
            first()

        if proposition is None:
            raise BadIdException()

        proposition.state = PropositionStatus.accepted
        BaseObject.check_and_save(proposition)
        HistoryProposition().execute(proposition.id, "accepted")
Esempio n. 27
0
def savedata():
    """
        User has finished the experiment and is posting their data in the form of a
        (long) string. They will receive a debriefing back.
    """
    print("accessing the /done route")

    prolific_id = request.form['prolific_id']
    study_id = request.form['study_id']
    participant_id = request.form['participant_id']
    longit_id = request.form['longit_id']

    datastring = request.form['datastring']
    when = request.form['when']
    payment = request.form['payment']

    print("saving the data of subject {1} for study {0} in time point {2}".
          format(prolific_id, study_id, longit_id))

    if ('prolific_id' in request.form) and ('datastring' in request.form):
        prolific_id = request.form['prolific_id']
        datastring = request.form['datastring']
        print(
            "getting the save data {0} for prolific ID {1} and longit ID {2}".
            format(datastring, prolific_id, longit_id))
        user = Test.query.\
            filter(Test.prolific_id == prolific_id).\
            filter(Test.longit_id == longit_id).\
            one()

        print('Payment', payment)

        user.datastring = datastring
        user.status = COMPLETED
        user.endexp = datetime.datetime.now()
        user.bonus = payment

        BaseObject.check_and_save(user)

        result = dict({"success": "yes"})

        print("Exp task done route, status is", user.status)

    # return render_template('payment.html')
    return render_template('feedback.html')
Esempio n. 28
0
def test_get_propositions_should_return_empty_array_if_no_reco_in_db(app):
    # Given
    obj_to_save = []
    user = create_user(email='*****@*****.**',
                       username='******',
                       password='******')
    obj_to_save.append(user)

    BaseObject.check_and_save(*obj_to_save)

    # When
    proposition_request = req_with_auth(email='*****@*****.**', password='******') \
        .get(API_URL + '/propositions')

    # Then
    assert proposition_request.status_code == 200
    content = proposition_request.json()
    assert len(content.get('propositions')) == 0
Esempio n. 29
0
def startfeedback():
    """
        User has finished the feedback and is posting their data in the form of a
        (long) string. They will receive a prolific validation page back.

    """
    print("accessing the /feedbackDone route")

    prolific_id = request.form['prolific_id']
    study_id = request.form['study_id']
    participant_id = request.form['participant_id']
    longit_id = request.form['longit_id']

    when = request.form['when']

    print(
        "saving the feedback data of subject {1} for study {0} in time point {2}"
        .format(prolific_id, study_id, longit_id))

    if ('prolific_id' in request.form) and ('feedbackDatastring'
                                            in request.form):
        prolific_id = request.form['prolific_id']
        feedbackDatastring = request.form['feedbackDatastring']

        print(
            "getting the feedback save data {0} for prolific ID {1} and longit ID {2}"
            .format(feedbackDatastring, prolific_id, longit_id))
        user = Test.query.\
            filter(Test.prolific_id == prolific_id).\
            filter(Test.longit_id == longit_id).\
            one()

        user.feedback = feedbackDatastring
        user.status = DEBRIEFED
        user.endexp = datetime.datetime.now()

        BaseObject.check_and_save(user)

        result = dict({"success": "yes"})

        print("Feedback done route, status is", user.status)

    return render_template(
        'payment.html')  # proceed to the validation prolific page
Esempio n. 30
0
    def execute(self, recommendation_id, user_id) -> Activity:

        if recommendation_id is None:
            raise BadArgException()

        # TEST IF RECOMMENDATION ALREADY IN ACTIVITY FOR THE USER
        existing_activity = Activity.query. \
            filter_by(user_id=user_id). \
            filter_by(recommendation_id=recommendation_id).first()
        if existing_activity:
            raise AlreadyStartedException

        activity = Activity()
        activity.set_recommendation(recommendation_id)
        activity.set_user(user_id)

        BaseObject.check_and_save(activity)

        return activity