コード例 #1
0
 def test_task_save_sufficient_permissions(self):
     patched_levels = self.patched_levels(
         valid_project_levels_for_task_level={'L4': ['L4']},
         valid_task_levels_for_project_level={'L4': ['L4']})
     with patch.dict(data_access.data_access_levels, patched_levels):
         project = ProjectFactory.create()
         task = Task(project_id=project.id, info={'data_access': ['L4']})
         task_repo.save(task)
コード例 #2
0
 def test_task_save_insufficient_permissions(self):
     patched_levels = self.patched_levels(
         valid_project_levels_for_task_level={'A': ['B']},
         valid_task_levels_for_project_level={'B': ['C']})
     with patch.dict(data_access.data_access_levels, patched_levels):
         project = ProjectFactory.create(info={'data_access': ['B']})
         with assert_raises(Exception):
             task = Task(project_id=project.id, info={'data_access': ['A']})
             task_repo.save(task)
コード例 #3
0
 def test_task_2(self):
     owner = UserFactory.create(id=500)
     owner.user_pref = {'languages': ['de', 'en']}
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     project.info['sched'] = Schedulers.user_pref
     task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
     task.user_pref = {'languages': ['en', 'zh']}
     task_repo.save(task)
     assert n_available_tasks_for_user(project, 500) == 1
コード例 #4
0
 def test_no_user_pref(self):
     """
     Task has preferences set, user doesn't
     """
     owner = UserFactory.create(id=500)
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
     task.user_pref = {'languages': ['en', 'de']}
     task_repo.save(task)
     tasks = get_user_pref_task(1, 500)
     assert not tasks
コード例 #5
0
 def test_task_save_sufficient_permissions(self):
     patched_levels = self.patched_levels(
         valid_project_levels_for_task_level={'A': ['B']},
         valid_task_levels_for_project_level={'A': ['B']}
     )
     with patch.dict(data_access.data_access_levels, patched_levels):
         project = ProjectFactory.create(info={
             'data_access': ['A'],
             'ext_config': {'data_access': {'tracking_id': '123'}}
         })
         task = Task(project_id=project.id, info={'data_access': ['A']})
         task_repo.save(task)
コード例 #6
0
 def test_task_2(self):
     """
     Task has multiple preferences, user has multiple preferences; match
     """
     owner = UserFactory.create(id=500)
     owner.user_pref = {'languages': ['en', 'de']}
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
     task.user_pref = {'languages': ['en', 'es']}
     task_repo.save(task)
     tasks = get_user_pref_task(1, 500)
     assert tasks
コード例 #7
0
 def test_task_1(self):
     '''
     Default user scheduler doesn't check user preference
     '''
     owner = UserFactory.create(id=500)
     owner.user_pref = {'languages': ['de']}
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     project.info['sched'] = Schedulers.locked
     task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
     task.user_pref = {'languages': ['en', 'zh']}
     task_repo.save(task)
     assert n_available_tasks_for_user(project, 500) == 1
コード例 #8
0
 def test_task_7(self):
     """
     Invalid user preference
     """
     owner = UserFactory.create(id=500)
     owner.user_pref = {'languages': 'invalid_user_pref'}
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
     task.user_pref = {'languages': ['en', 'zh']}
     task_repo.save(task)
     tasks = get_user_pref_task(1, 500)
     assert not tasks
コード例 #9
0
 def test_task_6(self):
     """
     User has multiple preferences of different kinds,
     task has multiple preferences of different kinds, no match
     """
     owner = UserFactory.create(id=500)
     owner.user_pref = {'languages': ['de'], 'locations': ['us']}
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
     task.user_pref = {'languages': ['en', 'zh'], 'locations': ['es']}
     task_repo.save(task)
     tasks = get_user_pref_task(1, 500)
     assert not tasks
コード例 #10
0
 def test_task_routing_3(self):
     '''
     User has empty profile set, only tasks that have empty filter can be assigned to user
     '''
     user_info = dict(metadata={"profile": json.dumps({})})
     owner = UserFactory.create(id=500, info=user_info)
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     project.info['sched'] = Schedulers.user_pref
     tasks = TaskFactory.create_batch(3, project=project, n_answers=10)
     tasks[0].worker_filter = {'finance': [0.8, '>=']}
     task_repo.save(tasks[0])
     tasks[1].worker_filter = {'geography': [0.5, '>=']}
     task_repo.save(tasks[1])
     assert n_available_tasks_for_user(project, 500) == 1
コード例 #11
0
 def test_task_4(self):
     '''
     Tasks match user profile
     '''
     owner = UserFactory.create(id=500)
     owner.user_pref = {'languages': ['de', 'en']}
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     project.info['sched'] = Schedulers.user_pref
     tasks = TaskFactory.create_batch(2, project=project, n_answers=10)
     tasks[0].user_pref = {'languages': ['en', 'zh']}
     task_repo.save(tasks[0])
     tasks[1].user_pref = {'languages': ['de']}
     task_repo.save(tasks[1])
     assert n_available_tasks_for_user(project, 500) == 2
コード例 #12
0
 def test_task_6(self):
     '''
     Task is assigned to a user whose profile doesn't match task preference
     '''
     owner = UserFactory.create(id=500)
     owner.user_pref = {'languages': ['de', 'en']}
     owner.email_addr = '*****@*****.**'
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     project.info['sched'] = Schedulers.user_pref
     task = TaskFactory.create_batch(1, project=project, n_answers=10)[0]
     task.user_pref = {
         'languages': ['ch', 'zh'],
         'assign_user': ['*****@*****.**']
     }
     task_repo.save(task)
     assert n_available_tasks_for_user(project, 500) == 0
コード例 #13
0
def add_task(project):
    store_questions(project)
    project_id=project.id
    project_path=session["zzz"]
    if(session.get("question") is not None):
        for i in ["images","videos","documents","audios"]:
            if os.path.exists(project_path+"/"+i):
                print "in if"
                for file in os.listdir(project_path+"/"+i):
                    p=os.path.join(project_path+"/"+i,file)
                    p=p[p.rfind("uploads"):]
                    print p
                    dictobj={"type":i,"url":"/"+p,"subtype":file.rsplit('.',1)[1].lower()}
                    s=json.dumps(dictobj)
                    #print s.type
                    task = Task(project_id=project_id)
                    task.info=dictobj
                    task_repo.save(task)
    session.pop('question', None)
コード例 #14
0
 def test_task_7(self):
     '''
     task[0]: doesn't have any language/country preference, should be able to
     assign to the user.
     task[1]: both preference and email match, should be able to assign to the user
     '''
     owner = UserFactory.create(id=500)
     owner.user_pref = {'languages': ['de', 'en']}
     owner.email_addr = '*****@*****.**'
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     project.info['sched'] = Schedulers.user_pref
     tasks = TaskFactory.create_batch(3, project=project, n_answers=10)
     tasks[0].user_pref = {'assign_user': ['*****@*****.**']}
     task_repo.save(tasks[0])
     tasks[1].user_pref = {
         'languages': ['de'],
         'assign_user': ['*****@*****.**']
     }
     task_repo.save(tasks[1])
     assert n_available_tasks_for_user(project, 500) == 2
コード例 #15
0
    def test_task_5(self):

        from pybossa import data_access

        owner = UserFactory.create(id=500)
        user = UserFactory.create(id=501, info=dict(data_access=["L1"]))
        patch_data_access_levels = dict(
            valid_access_levels=["L1", "L2", "L3", "L4"],
            valid_user_levels_for_project_level=dict(L1=[], L2=["L1"]),
            valid_project_levels_for_user_level=dict(L1=["L2", "L3", "L4"],
                                                     L2=["L3", "L4"]),
        )

        user_repo.save(owner)
        project = ProjectFactory.create(owner=owner,
                                        info=dict(project_users=[owner.id]))
        project.info['sched'] = Schedulers.user_pref
        tasks = TaskFactory.create_batch(3,
                                         project=project,
                                         n_answers=2,
                                         info=dict(data_access=["L1"]))
        tasks[0].info['data_access'] = ["L1"]
        task_repo.save(tasks[0])
        tasks[1].info['data_access'] = ["L1"]
        task_repo.save(tasks[1])
        tasks[2].info['data_access'] = ["L2"]
        task_repo.save(tasks[2])

        with patch.object(data_access, 'data_access_levels',
                          patch_data_access_levels):
            assert n_available_tasks_for_user(project, 501) == 3
コード例 #16
0
    def test_recent_contributor_with_multiple_user_pref_notified(self):
        """
        User with multiple user pref to be notified when one of his/her
        user pref matches any new task user pref
        """
        owner = UserFactory.create(id=500)
        owner.user_pref = {'languages': ['en']}  # owner is english user
        user_repo.save(owner)
        sp_fr_user = UserFactory.create(id=501)
        sp_fr_user.user_pref = {
            'languages': ['sp', 'fr']
        }  # spanish french language user
        user_repo.save(sp_fr_user)

        # Stage 1 :
        # Create 3 tasks - 1 english, 1 spanish, 1 french.
        project = ProjectFactory.create(owner=owner)
        project.info['sched'] = Schedulers.user_pref
        tasks = TaskFactory.create_batch(6, project=project, n_answers=1)
        tasks[0].user_pref = {'languages': ['en']}
        task_repo.save(tasks[0])
        tasks[1].user_pref = {'languages': ['sp']}
        task_repo.save(tasks[1])
        tasks[2].user_pref = {'languages': ['fr']}
        task_repo.save(tasks[2])

        # Submit 1 english and spanish tasks. this will complete
        # such tasks and assoicated users to be notified about new task imported
        taskrun1 = TaskRunFactory.create(task=tasks[0], user=owner)
        taskrun2 = TaskRunFactory.create(task=tasks[1], user=sp_fr_user)

        # Stage 2 :
        # create 1 spanish task
        # at this stage, record current time.
        # there is french ongoing task, but since spanish task is complete
        # sp_fr_user will be notified
        now = datetime.datetime.utcnow().isoformat()

        tasks = TaskFactory.create_batch(1, project=project, n_answers=1)
        tasks[0].user_pref = {'languages': ['sp']}
        task_repo.save(tasks[0])
        recent_contributors = user_repo.get_user_pref_recent_contributor_emails(
            project.id, now)
        # with one spanish task completed, user2 will be notified about new spanish task imported
        err_msg = 'There should be 1 contributors'
        assert len(recent_contributors) == 1, err_msg
        err_msg = 'user1 and user3 with english and chinese language preference should be notified'
        assert '*****@*****.**' in recent_contributors, err_msg
コード例 #17
0
 def test_task_routing_2(self):
     '''
     task[0]: needs finance skill at least 0.8, should not be able to assign to the user
     task[1]: needs geography skill at least 0.5, should not be able to assign to the user
     task[3]: doesnt have filters, should be able to assign to the user
     '''
     user_info = dict(
         metadata={
             "profile": json.dumps({
                 "finance": 0.6,
                 "marketing": 0.4
             })
         })
     owner = UserFactory.create(id=500, info=user_info)
     user_repo.save(owner)
     project = ProjectFactory.create(owner=owner)
     project.info['sched'] = Schedulers.user_pref
     tasks = TaskFactory.create_batch(3, project=project, n_answers=10)
     tasks[0].worker_filter = {'finance': [0.8, '>=']}
     task_repo.save(tasks[0])
     tasks[1].worker_filter = {'geography': [0.5, '>=']}
     task_repo.save(tasks[1])
     assert n_available_tasks_for_user(project, 500) == 1
コード例 #18
0
ファイル: task_run.py プロジェクト: mykaarma/pybossa
    def _file_upload(self, data):
        """Method that must be overriden by the class to allow file uploads for
        only a few classes."""
        cls_name = self.__class__.__name__.lower()
        """Accepting both content types - text or with file"""
        content_type_file = 'multipart/form-data'
        content_type_text =  'application/x-www-form-urlencoded'
        request_headers = request.headers.get('Content-Type')
        if request_headers is None:
            request_headers = []
        """ check for content type - file or text"""
        if ( (content_type_file in request_headers or content_type_text in request_headers)
            and cls_name in self.allowed_classes_upload):
            data = dict()
            for key in list(request.form.keys()):
                #Adding user_id in data
                if key in ['project_id']:
                    data[key] = int(request.form[key])
                elif key == 'info':
                    data[key] = json.loads(request.form[key])
                else:
                    data[key] = request.form[key]

            #Check if task exists
            tasks = task_repo.getTasks(data['info']['uuid'],data['project_id'])
            try:
                #if it exists, add as task id
                task = [row[0] for row in tasks]
                data['task_id'] = task[0]
            except:
                #if does not exist, add new task
                info = data['info']
                task = Task(project_id=data['project_id'], info=info,n_answers=10)
                task_repo.save(task)
                data['task_id'] = task.id
            
            """Try to get user by uuid, if not present, add a new user"""
            user = user_repo.get_by(mykaarma_user_id=data['useruuid'])
            if(user is None):
                name = get_mykaarma_username_from_full_name(data["fullname"]) 
                user = user_repo.get_by_name(name)
                while(user is not None):
                    name = get_mykaarma_username_from_full_name(data["fullname"])
                    user = user_repo.get_by_name(name)
                user = User(fullname=data['fullname'],
                    name=name,
                    email_addr=data['email'],
                    mykaarma_user_id=data['useruuid'])
                user_repo.save(user)

            """ add user id extracted from user repo"""
            data['user_id'] = user.id
            """ delete extra keys to suit Taskrun class format"""
            del data['useruuid']
            del data['fullname']
            del data['email']
            data = self.hateoas.remove_links(data)
            inst = self.__class__(**data)
            self._add_user_info(inst)
            is_authorized(current_user, 'create', inst)
            upload_method = current_app.config.get('UPLOAD_METHOD')
            """Add user id to container"""
            container = "user_%s" % data['user_id']
            if data.get('info') is None:
                data['info'] = dict()
            data['info']['container'] = container
            if(request.files.get('file') is not None):
                _file = request.files['file']
                if _file.filename == 'blob' or _file.filename is None:
                   _file.filename = "%s.png" % time.time()
                uploader.upload_file(_file,
                                    container=container)
                avatar_absolute = current_app.config.get('AVATAR_ABSOLUTE')
                file_url = get_avatar_url(upload_method,
                                         _file.filename,
                                         container,
                                         avatar_absolute)
                data['media_url'] = file_url
                data['info']['file_name'] = _file.filename
            return data
        else:
            return None
コード例 #19
0
    def test_recent_contributors_list_as_per_user_pref(self):
        """
        Notify users about new tasks imported based on user preference and those who were not notified previously
        """
        owner = UserFactory.create(id=500)
        owner.user_pref = {'languages': ['en']}  # owner is english user
        user_repo.save(owner)
        ch_user = UserFactory.create(id=501)
        ch_user.user_pref = {'languages': ['ch']}  # chinese language user
        user_repo.save(ch_user)
        ru_user = UserFactory.create(id=502)
        ru_user.user_pref = {'languages': ['ru']}  # russian language user
        user_repo.save(ru_user)

        # Stage 1 :
        # Create 4 tasks - 3 english, 1 chinese.
        project = ProjectFactory.create(owner=owner)
        project.info['sched'] = Schedulers.user_pref
        tasks = TaskFactory.create_batch(4, project=project, n_answers=1)
        tasks[0].user_pref = {'languages': ['en']}
        task_repo.save(tasks[0])
        tasks[1].user_pref = {'languages': ['en']}
        task_repo.save(tasks[1])
        tasks[2].user_pref = {'languages': ['ru']}
        task_repo.save(tasks[2])
        tasks[3].user_pref = {'languages': ['ch']}
        task_repo.save(tasks[3])

        # Complete 2 english and 1 russian tasks
        # completing 1 russian task will mark all russian tasks completed
        # and such users to be notified about new task imported
        taskrun1 = TaskRunFactory.create(task=tasks[0], user=owner)
        taskrun2 = TaskRunFactory.create(task=tasks[1], user=owner)
        taskrun3 = TaskRunFactory.create(task=tasks[2], user=ru_user)

        # Stage 2 :
        # create 3 more tasks; 2 russian and 1 chinese

        # at this stage, record current time.
        # chinese user has existing ongoing task, hence won't be notified
        # russian user has all tasks completed, hence will be notified
        now = datetime.datetime.utcnow().isoformat()

        tasks = TaskFactory.create_batch(3, project=project, n_answers=1)
        tasks[0].user_pref = {'languages': ['ru']}
        task_repo.save(tasks[0])
        tasks[1].user_pref = {'languages': ['ru']}
        task_repo.save(tasks[1])
        tasks[2].user_pref = {'languages': ['ch']}
        task_repo.save(tasks[2])

        recent_contributors = user_repo.get_user_pref_recent_contributor_emails(
            project.id, now)
        # with russian task completed, russian user will be notified about new task imported
        err_msg = 'There should be 1 contributors'
        assert len(recent_contributors) == 1, err_msg

        err_msg = 'only user3 that has language preference russian should be notified'
        assert recent_contributors[0] == '*****@*****.**', err_msg
コード例 #20
0
    def test_recent_contributors_list_with_multiple_user_pref(self):
        """
        User with multiple user pref to be excluded from notifying when there are
        existing ongoing tasks matching any one of same user pref
        """
        owner = UserFactory.create(id=500)
        owner.user_pref = {'languages': ['en']}  # owner is english user
        user_repo.save(owner)
        sp_fr_user = UserFactory.create(id=501)
        sp_fr_user.user_pref = {
            'languages': ['sp', 'fr']
        }  # spanish french language user
        user_repo.save(sp_fr_user)
        ch_user = UserFactory.create(id=502)
        ch_user.user_pref = {'languages': ['ch']}  # russian language user
        user_repo.save(ch_user)

        # Stage 1 :
        # Create 4 tasks - 3 english, 1 chinese.
        project = ProjectFactory.create(owner=owner)
        project.info['sched'] = Schedulers.user_pref
        tasks = TaskFactory.create_batch(6, project=project, n_answers=1)
        tasks[0].user_pref = {'languages': ['en']}
        task_repo.save(tasks[0])
        tasks[1].user_pref = {'languages': ['sp']}
        task_repo.save(tasks[1])
        tasks[2].user_pref = {'languages': ['sp']}
        task_repo.save(tasks[2])
        tasks[3].user_pref = {'languages': ['fr']}
        task_repo.save(tasks[3])
        tasks[4].user_pref = {'languages': ['fr']}
        task_repo.save(tasks[4])
        tasks[5].user_pref = {'languages': ['ch']}
        task_repo.save(tasks[5])

        # Submit 1 english and chinese task runs. this will complete
        # such tasks and assoicated users to be notified about new task imported
        taskrun1 = TaskRunFactory.create(task=tasks[0], user=owner)
        taskrun2 = TaskRunFactory.create(task=tasks[5], user=ch_user)
        # Submit 1 spanish and 1 french task runs. since there are 1 each onging
        # tasks, assoicated users wont be notified about new task imported
        taskrun1 = TaskRunFactory.create(task=tasks[1], user=sp_fr_user)
        taskrun2 = TaskRunFactory.create(task=tasks[3], user=sp_fr_user)

        # Stage 2 :
        # create 3 more tasks; 1 spanish, 1 french and 1 chinese

        # at this stage, record current time.
        # spanish and french user has existing ongoing task, hence won't be notified
        # chinese and english user has all tasks completed, hence will be notified
        now = datetime.datetime.utcnow().isoformat()

        tasks = TaskFactory.create_batch(4, project=project, n_answers=1)
        tasks[0].user_pref = {'languages': ['en']}
        task_repo.save(tasks[0])
        tasks[1].user_pref = {'languages': ['sp']}
        task_repo.save(tasks[1])
        tasks[2].user_pref = {'languages': ['fr']}
        task_repo.save(tasks[2])
        tasks[3].user_pref = {'languages': ['ch']}
        task_repo.save(tasks[3])

        recent_contributors = user_repo.get_user_pref_recent_contributor_emails(
            project.id, now)
        # with english and chinese task completed, two such user will be notified about new task imported
        err_msg = 'There should be 2 contributors'
        assert len(recent_contributors) == 2, err_msg
        err_msg = 'user1 and user3 with english and chinese language preference should be notified'
        assert ('*****@*****.**' in recent_contributors
                and '*****@*****.**' in recent_contributors
                and '*****@*****.**' not in recent_contributors), err_msg