Example #1
0
 def process_response(self, request, response):
     if response.status_code < 400 and settings.REQUEST_ONLY_ERRORS:
         return response
     
     allow = patterns(True, *settings.REQUEST_ALLOW_PATHS)
     if not allow.resolve(request.path[1:]):
         return response
     
     ignore = patterns(False, *settings.REQUEST_IGNORE_PATHS)
     if ignore.resolve(request.path[1:]):
         return response
     
     if request.is_ajax() and settings.REQUEST_IGNORE_AJAX:
         return response
     
     if request.META.get('REMOTE_ADDR') in settings.REQUEST_IGNORE_IP:
         return response
     
     if getattr(request, 'user', False):
         if request.user.username in settings.REQUEST_IGNORE_USERNAME:
             return response
     
     r = Request()
     r.from_http_request(request, response)
     
     return response
Example #2
0
class GetAllLibrariesAdminTest(TestCase):
    _is_staff = True

    def setUp(self):
        user = User.objects.create_user(
            email='*****@*****.**',
            password='******',
            is_staff=self._is_staff,
        )
        user.save()

        library = Library.get_test_library('Library')
        sample = Sample.get_test_sample('Sample')
        library.save()
        sample.save()

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(library)
        self.request.samples.add(sample)

    def test_get_all(self):
        self.client.login(email='*****@*****.**', password='******')
        response = self.client.get(reverse('library.get_all'))
        self.assertEqual(response.status_code, 200)
        self.assertNotEqual(response.content, b'[]')

    def test_wrong_http_method(self):
        self.client.login(email='*****@*****.**', password='******')
        response = self.client.post(reverse('library.get_all'))
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.content, b'[]')
    def process_response(self, request, response):
        if request.method.lower() not in settings.REQUEST_VALID_METHOD_NAMES:
            return response

        if response.status_code < 400 and settings.REQUEST_ONLY_ERRORS:
            return response

        ignore = patterns(False, *settings.REQUEST_IGNORE_PATHS)
        if ignore.resolve(request.path[1:]):
            return response

        if request.is_ajax() and settings.REQUEST_IGNORE_AJAX:
            return response

        if request.META.get('REMOTE_ADDR') in settings.REQUEST_IGNORE_IP:
            return response

        ignore = patterns(False, *settings.REQUEST_IGNORE_USER_AGENTS)
        if ignore.resolve(request.META.get('HTTP_USER_AGENT', '')):
            return response

        if getattr(request, 'user', False):
            if request.user.username in settings.REQUEST_IGNORE_USERNAME:
                return response

        r = Request()
        r.from_http_request(request, response)

        return response
Example #4
0
class PoolInfo(TestCase):
    def setUp(self):
        user = User.objects.create_user(email='*****@*****.**', password='******')
        pool = Pool(name='_Foo', user=user)
        pool.save()

        library_1 = Library.get_test_library('Library1')
        library_2 = Library.get_test_library('Library2')
        library_1.save()
        library_2.save()

        sample_1 = Sample.get_test_sample('Sample1')
        sample_2 = Sample.get_test_sample('Sample2')
        sample_1.save()
        sample_2.save()

        pool.libraries.add(library_1)
        pool.samples.add(sample_1)

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(*[library_1, library_2])
        self.request.samples.add(*[sample_1, sample_2])

    def test_pool_info(self):
        self.client.login(email='*****@*****.**', password='******')
        response = self.client.get(reverse('pool_info'), {'pool_id': 1})

        self.assertNotEqual(response.content, b'[]')
        self.assertEqual(response.status_code, 200)
Example #5
0
class GetAllLibrariesAdminTest(TestCase):
    _is_staff = True

    def setUp(self):
        user = User.objects.create_user(
            email='*****@*****.**', password='******', is_staff=self._is_staff,
        )
        user.save()

        library = Library.get_test_library('Library')
        sample = Sample.get_test_sample('Sample')
        library.save()
        sample.save()

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(library)
        self.request.samples.add(sample)

    def test_get_all(self):
        self.client.login(email='*****@*****.**', password='******')
        response = self.client.get(reverse('library.get_all'))
        self.assertEqual(response.status_code, 200)
        self.assertNotEqual(response.content, b'[]')

    def test_wrong_http_method(self):
        self.client.login(email='*****@*****.**', password='******')
        response = self.client.post(reverse('library.get_all'))
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.content, b'[]')
Example #6
0
    def process_response(self, request, response):
        if request.method.lower() not in settings.VALID_METHOD_NAMES:
            return response

        if response.status_code < 400 and settings.ONLY_ERRORS:
            return response

        ignore = patterns(False, *settings.IGNORE_PATHS)
        if ignore.resolve(request.path[1:]):
            return response

        if request.is_ajax() and settings.IGNORE_AJAX:
            return response

        if request.META.get('REMOTE_ADDR') in settings.IGNORE_IP:
            return response

        ignore = patterns(False, *settings.IGNORE_USER_AGENTS)
        if ignore.resolve(request.META.get('HTTP_USER_AGENT', '')):
            return response

        if getattr(request, 'user', False):
            if request.user.username in settings.IGNORE_USERNAME:
                return response

        r = Request()
        r.from_http_request(request, response)

        return response
Example #7
0
class PoolInfo(TestCase):
    def setUp(self):
        user = User.objects.create_user(email='*****@*****.**', password='******')
        pool = Pool(name='_Foo', user=user)
        pool.save()

        library_1 = Library.get_test_library('Library1')
        library_2 = Library.get_test_library('Library2')
        library_1.save()
        library_2.save()

        sample_1 = Sample.get_test_sample('Sample1')
        sample_2 = Sample.get_test_sample('Sample2')
        sample_1.save()
        sample_2.save()

        pool.libraries.add(library_1)
        pool.samples.add(sample_1)

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(*[library_1, library_2])
        self.request.samples.add(*[sample_1, sample_2])

    def test_pool_info(self):
        self.client.login(email='*****@*****.**', password='******')
        response = self.client.get(reverse('pool_info'), {'pool_id': 1})

        self.assertNotEqual(response.content, b'[]')
        self.assertEqual(response.status_code, 200)
Example #8
0
    def test_from_http_request_not_commit(self):
        http_request = HttpRequest()
        http_request.method = 'GET'

        request = Request()
        request.from_http_request(http_request, commit=False)
        self.assertIsNone(request.id)
Example #9
0
    def test_from_http_request_with_user(self):
        http_request = self.factory.get('/')
        http_request.user = get_user_model().objects.create(username='******')

        request = Request()
        request.from_http_request(http_request, commit=False)
        self.assertEqual(request.user.id, http_request.user.id)
    def test_from_http_request_not_commit(self):
        http_request = HttpRequest()
        http_request.method = 'GET'

        request = Request()
        request.from_http_request(http_request, commit=False)
        self.assertIsNone(request.id)
    def process_response(self, request, response):
        if request.method.lower() not in settings.REQUEST_VALID_METHOD_NAMES:
            return response

        if response.status_code < 400 and settings.REQUEST_ONLY_ERRORS:
            return response

        ignore = patterns(False, *settings.REQUEST_IGNORE_PATHS)
        if ignore.resolve(request.path[1:]):
            return response

        if request.is_ajax() and settings.REQUEST_IGNORE_AJAX:
            return response

        if get_remote_addr(request) in settings.REQUEST_IGNORE_IP:
            return response

        if getattr(request, 'user', False):
            if request.user.username in settings.REQUEST_IGNORE_USERNAME:
                return response

        r = Request()
        r.from_http_request(request, response)

        return response
Example #12
0
    def setUpClass(cls):
        super(GraphsTestCase, cls).setUpClass()
        cls.factory = RequestFactory()

        Request(path="/admin/", ip="127.0.0.1").save()
        Request(path="/admin/", ip="127.0.0.1").save()
        Request(path="/admin/login/", ip="127.0.0.1").save()

        staff_user = User.objects.create_user(username="******", password="******")
        staff_user.is_staff = True
        staff_user.save()
        cls.staff_user = staff_user

        cls.coordinator = EditorFactory(user__email="*****@*****.**").user
        coordinators = get_coordinators()
        coordinators.user_set.add(cls.coordinator)

        user = UserFactory()
        cls.user = user

        cls.partner = PartnerFactory()

        cls.app = ApplicationFactory(partner=cls.partner)
        cls.app.status = Application.APPROVED
        cls.app.save()

        cls.dashboard_url = reverse("dashboard")
    def test_from_http_request_with_user(self):
        http_request = HttpRequest()
        http_request.method = 'GET'
        http_request.user = get_user_model().objects.create(username='******')

        request = Request()
        request.from_http_request(http_request, commit=False)
        self.assertEqual(request.user.id, http_request.user.id)
Example #14
0
    def test_from_http_request_with_user(self):
        http_request = HttpRequest()
        http_request.method = 'GET'
        http_request.user = User.objects.create(username='******')

        request = Request()
        request.from_http_request(http_request)
        self.assertEqual(request.user.id, http_request.user.id)
Example #15
0
    def setUp(self):
        self.user = self.create_user('*****@*****.**', 'foo-foo')
        self.client.login(email='*****@*****.**', password='******')

        self.sample = create_sample(self._get_random_name())
        self.request = Request(user=self.user)
        self.request.save()
        self.request.samples.add(self.sample)
Example #16
0
    def test_from_http_request_with_user(self):
        http_request = HttpRequest()
        http_request.method = 'GET'
        http_request.user = get_user_model().objects.create(username='******')

        request = Request()
        request.from_http_request(http_request, commit=False)
        self.assertEqual(request.user.id, http_request.user.id)
Example #17
0
    def test_from_http_request_redirection(self):
        http_request = HttpRequest()
        http_request.method = 'GET'
        http_response = HttpResponse(status=301)
        http_response['Location'] = '/foo'

        request = Request()
        request.from_http_request(http_request, http_response)
        self.assertEqual(request.redirect, '/foo')
Example #18
0
    def test_from_http_request_redirection(self):
        http_request = self.factory.get('/')

        http_response = HttpResponse(status=301)
        http_response['Location'] = '/foo'

        request = Request()
        request.from_http_request(http_request, http_response, commit=False)
        self.assertEqual(request.redirect, '/foo')
    def test_from_http_request_redirection(self):
        http_request = HttpRequest()
        http_request.method = 'GET'
        http_response = HttpResponse(status=301)
        http_response['Location'] = '/foo'

        request = Request()
        request.from_http_request(http_request, http_response, commit=False)
        self.assertEqual(request.redirect, '/foo')
Example #20
0
    def test_from_http_request_with_user(self):
        http_request = HttpRequest()
        http_request.method = 'GET'
        http_request.user = User.objects.create(username='******')
        http_request.META['REMOTE_ADDR'] = '32.64.128.16'

        request = Request()
        request.from_http_request(http_request)
        self.assertEqual(request.user.id, http_request.user.id)
Example #21
0
    def setUp(self):
        user = User.objects.create_user(
            email='*****@*****.**',
            password='******',
            is_staff=True,
        )
        user.save()

        self.request = Request(user=user)
        self.request.save()
Example #22
0
 def test_browser_detection_with_no_path(self):
     request = Request(
         user_agent=
         'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:43.0) Gecko/20100101 Firefox/43.0'
     )
     self.assertEqual(request.browser, 'Firefox')
     request = Request(
         user_agent=
         'Mozilla/5.0 (compatible; MSIE 9.0; America Online Browser 1.1; Windows NT 5.0)'
     )
     self.assertEqual(request.browser, 'AOL')
Example #23
0
    def test_from_http_request_redirection(self):
        http_request = HttpRequest()
        http_request.method = 'GET'
        http_request.META['HTTP_USER_AGENT'] = 'test user agent'
        http_request.META['REMOTE_ADDR'] = '32.64.128.16'
        http_response = HttpResponse(status=301)
        http_response['Location'] = '/foo'

        request = Request()
        request.from_http_request(http_request, http_response)
        self.assertEqual(request.redirect, '/foo')
Example #24
0
def create_interview(request):
    positions = PositionAll.objects.all()
    existing_order = get_user_pending_order(request)
    cart_amount = ''
    if existing_order!=0:
        cart_amount = existing_order.items.all().count()
    else:
        return redirect(reverse('candidate_cart:order_summary'))
    if request.method == 'POST':
        request_id = generate_request_id()
        request_title = request.POST.get('request_title')

        date_interview = request.POST.get('date_interview')
        note_interview = request.POST.get('note_interview')

        request_position_id = request.POST.get('request_position')
        request_position_other = request.POST.get('request_position_other_name')
        print(request_position_id,"||||||||||",request_position_other)
        request_position = get_object_or_404(PositionAll, position_id=request_position_id)

        user_profile = get_object_or_404(Profile, user=request.user)
        user_order = Order.objects.get(owner=user_profile, is_ordered=False)

        status = get_object_or_404(Status, status_id='1')
        request_type = get_object_or_404(RequestType, request_type_id='2')

        existing_order = get_user_pending_order(request)
        if existing_order!=0:
            request_interview = RequestInterview(order = user_order,date_interview = date_interview,note_interview =note_interview)
            request_interview.save()

            request_detail = Request(request_id=request_id,request_type=request_type,request_interview=request_interview,request_title=request_title,request_position=request_position,request_position_other=request_position_other,owner=user_profile,status=status)
            request_detail.save()

            # context = {
            #     'order': existing_order,
            #     'Cart_amount': cart_amount,
            # }
            #
            # return render(request, 'create-interview.html', context)
            return redirect(reverse('candidate_cart:update_interview',
                        kwargs={
                            'order_id': user_order.ref_code
                        })
                    )

    context = {
        'Positions' : positions,
        'order': existing_order,
        'Cart_amount': cart_amount,
    }

    return render(request, 'create-interview.html', context)
Example #25
0
    def setUpClass(cls):
        super(GraphsTestCase, cls).setUpClass()
        cls.factory = RequestFactory()

        Request(path='/admin/', ip='127.0.0.1').save()
        Request(path='/admin/', ip='127.0.0.1').save()
        Request(path='/admin/login/', ip='127.0.0.1').save()

        user = User.objects.create_user(username='******', password='******')
        user.is_staff = True
        user.save()
        cls.staff_user = user
Example #26
0
def create_library_preparation_obj(sample_name, user, sample_status):
    sample = create_sample(sample_name, status=sample_status)
    sample.save()

    request = Request(user=user)
    request.save()
    request.samples.add(sample)

    pool = create_pool(user)
    pool.samples.add(sample)

    return LibraryPreparation.objects.get(sample=sample)
Example #27
0
    def process_response(self, request, response):
        if response.status_code < 400 and settings.REQUEST_ONLY_ERRORS:
            return response
        
        ignore = patterns(False, *settings.REQUEST_IGNORE_PATHS)
        if ignore.resolve(request.path[1:]):
            return response
        
        if request.is_ajax() and settings.REQUEST_IGNORE_AJAX:
            return response
        
        if request.META.get('REMOTE_ADDR') in settings.REQUEST_IGNORE_IP:
            return response
        
        if getattr(request, 'user', False):
            if request.user.username in settings.REQUEST_IGNORE_USERNAME:
                return response
        
        if not getattr(request, 'session', None):
            return response

        r = Request()
        now = datetime.datetime.now()
        path = request.path
        if path[len(path)-1] != '/':
            path = path + '/'
    
        if path in settings.REQUEST_ALWAYS_INSERT_FROM_URLS:
            try:
                request.session['last_request_log'] = now
            except:
                pass
            r.from_http_request(request, response, commit=False)
            record_request(r)
            return response

        try:
            last_log = request.session['last_request_log']
            if settings.REQUEST_USER_TRACKING_LOGAGAIN_DELAY:
                last_log_limit = last_log + \
                    settings.REQUEST_USER_TRACKING_LOGAGAIN_DELAY
                if now < last_log_limit :
                    return response
        except KeyError:
            pass 
        request.session['last_request_log'] = now
        r.from_http_request(request, response, commit=False)
        record_request(r)
        return response
Example #28
0
    def test_from_http_request(self):
        http_request = HttpRequest()
        http_request.method = 'PATCH'
        http_request.path = '/kylef'
        http_request.META['REMOTE_ADDR'] = '32.64.128.16'

        http_response = HttpResponse(status=204)

        request = Request()
        request.from_http_request(http_request, http_response, commit=False)

        self.assertEqual(request.path, '/kylef')
        self.assertEqual(request.method, 'PATCH')
        self.assertEqual(request.ip, '32.64.128.16')
        self.assertEqual(request.response, 204)
Example #29
0
 def process_response(self, request, response):
     if request.is_ajax() and settings.REQUEST_IGNORE_AJAX:
         return response
     
     if request.META.get('REMOTE_ADDR') in settings.REQUEST_IGNORE_IP:
         return response
     
     if getattr(request, 'user', False):
         if request.user.username in settings.REQUEST_IGNORE_USERNAME:
             return response
     
     r = Request()
     r.from_http_request(request, response)
     
     return response
Example #30
0
    def setUp(self):
        user = self.create_user()
        self.create_user('*****@*****.**', 'test', False)  # non-staff user

        # Submission completed
        self.library1 = create_library(self._get_random_name(), status=1)
        self.sample1 = create_sample(self._get_random_name(), status=1)
        self.sample2 = create_sample(self._get_random_name(), status=1)

        # Failed library
        self.library2 = create_library(self._get_random_name(), status=-1)

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(*[self.library1, self.library2])
        self.request.samples.add(*[self.sample1, self.sample2])
Example #31
0
class GetAllLibraries(TestCase):
    def setUp(self):
        user = User.objects.create_user(
            email='*****@*****.**', password='******', is_staff=True,
        )
        user.save()

        self.request = Request(user=user)
        self.request.save()

    def test_get_all(self):
        self.client.login(email='*****@*****.**', password='******')

        library = Library.get_test_library('Library1')
        library.status = 1
        library.save()

        sample = Sample.get_test_sample('Sample1')
        sample.status = 1
        sample.save()

        self.request.libraries.add(library)
        self.request.samples.add(sample)

        response = self.client.get(reverse('library.get_all'), {
            'quality_check': 'true'
        })
        self.assertEqual(response.status_code, 200)
        self.assertNotEqual(response.content, b'[]')

    def test_get_all_empty(self):
        self.client.login(email='*****@*****.**', password='******')

        library = Library.get_test_library('Library2')
        library.save()

        sample = Sample.get_test_sample('Sample2')
        sample.save()

        self.request.libraries.add(library)
        self.request.samples.add(sample)

        response = self.client.get(reverse('library.get_all'), {
            'quality_check': 'true'
        })
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.content, b'[]')
Example #32
0
class GetAllLibraries(TestCase):
    def setUp(self):
        user = User.objects.create_user(
            email='*****@*****.**',
            password='******',
            is_staff=True,
        )
        user.save()

        self.request = Request(user=user)
        self.request.save()

    def test_get_all(self):
        self.client.login(email='*****@*****.**', password='******')

        library = Library.get_test_library('Library1')
        library.status = 1
        library.save()

        sample = Sample.get_test_sample('Sample1')
        sample.status = 1
        sample.save()

        self.request.libraries.add(library)
        self.request.samples.add(sample)

        response = self.client.get(reverse('library.get_all'),
                                   {'quality_check': 'true'})
        self.assertEqual(response.status_code, 200)
        self.assertNotEqual(response.content, b'[]')

    def test_get_all_empty(self):
        self.client.login(email='*****@*****.**', password='******')

        library = Library.get_test_library('Library2')
        library.save()

        sample = Sample.get_test_sample('Sample2')
        sample.save()

        self.request.libraries.add(library)
        self.request.samples.add(sample)

        response = self.client.get(reverse('library.get_all'),
                                   {'quality_check': 'true'})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.content, b'[]')
Example #33
0
def create_pooling_object(user,
                          save=True,
                          add_library=False,
                          add_sample=False,
                          sample_failed=False):
    library = None
    sample = None

    if add_library:
        library = create_library(get_random_name(), 2)

    if add_sample:
        sample = create_sample(get_random_name(), 2)

    pool = create_pool(user)

    request = Request(user=user)
    request.save()

    if library:
        request.libraries.add(library)
        pool.libraries.add(library)
        pooling_object = Pooling.objects.get(library=library)

    if sample:
        request.samples.add(sample)
        pool.samples.add(sample)

        # Update the sample instance because after being added to the pool,
        # it was modified
        sample = sample.__class__.objects.get(pk=sample.pk)

        if sample_failed:
            sample.status = -1  # failed quality check
            sample.save()
            pooling_object = sample

        else:
            sample.status = 3  # passed quality check
            sample.save()
            pooling_object = Pooling.objects.get(sample=sample)

    if save:
        pooling_object.save()

    return pooling_object
Example #34
0
    def setUp(self):
        user = User.objects.create_user(
            email='*****@*****.**',
            password='******',
            is_staff=self._is_staff,
        )
        user.save()

        library = Library.get_test_library('Library')
        sample = Sample.get_test_sample('Sample')
        library.save()
        sample.save()

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(library)
        self.request.samples.add(sample)
Example #35
0
    def setUp(self):
        user = User.objects.create_user(
            email='*****@*****.**', password='******', is_staff=True,
        )
        user.save()

        self.request = Request(user=user)
        self.request.save()
Example #36
0
    def test_multiple_sample_contains_invalid(self):
        """
        Ensure get multiple samples containing invalid ids behaves correctly.
        """
        sample = create_sample(get_random_name())

        request = Request(user=self.user)
        request.save()
        request.samples.add(sample)

        response = self.client.get(reverse('samples-list'), {
            'request_id': request.pk,
            'ids': json.dumps([sample.pk, 'blah'])
        })
        data = response.json()
        self.assertEqual(response.status_code, 400)
        self.assertFalse(data['success'])
        self.assertEqual(data['message'], 'Invalid payload.')
Example #37
0
    def test_from_http_request(self):
        http_request = HttpRequest()
        http_request.method = 'PATCH'
        http_request.path = '/kylef'
        http_request.META['REMOTE_ADDR'] = '32.64.128.16'
        http_request.META['HTTP_USER_AGENT'] = 'test user agent'
        http_request.META['HTTP_REFERER'] = 'https://fuller.li/'

        http_response = HttpResponse(status=204)

        request = Request()
        request.from_http_request(http_request, http_response, commit=False)

        self.assertEqual(request.path, '/kylef')
        self.assertEqual(request.method, 'PATCH')
        self.assertEqual(request.ip, '32.64.128.16')
        self.assertEqual(request.response, 204)
        self.assertEqual(request.user_agent, 'test user agent')
        self.assertEqual(request.referer, 'https://fuller.li/')
Example #38
0
    def test_from_http_request(self):
        http_request = self.factory.patch(
            '/kylef',
            REMOTE_ADDR='32.64.128.16',
            HTTP_USER_AGENT='test user agent',
            HTTP_REFERER='https://fuller.li/',
        )

        http_response = HttpResponse(status=204)

        request = Request()
        request.from_http_request(http_request, http_response, commit=False)

        self.assertEqual(request.path, '/kylef')
        self.assertEqual(request.method, 'PATCH')
        self.assertEqual(request.ip, '32.64.128.16')
        self.assertEqual(request.response, 204)
        self.assertEqual(request.user_agent, 'test user agent')
        self.assertEqual(request.referer, 'https://fuller.li/')
    def test_from_http_request(self):
        http_request = HttpRequest()
        http_request.method = 'PATCH'
        http_request.path = '/kylef'
        http_request.META['REMOTE_ADDR'] = '32.64.128.16'
        http_request.META['HTTP_USER_AGENT'] = 'test user agent'
        http_request.META['HTTP_REFERER'] = 'https://fuller.li/'

        http_response = HttpResponse(status=204)

        request = Request()
        request.from_http_request(http_request, http_response, commit=False)

        self.assertEqual(request.path, '/kylef')
        self.assertEqual(request.method, 'PATCH')
        self.assertEqual(request.ip, '32.64.128.16')
        self.assertEqual(request.response, 204)
        self.assertEqual(request.user_agent, 'test user agent')
        self.assertEqual(request.referer, 'https://fuller.li/')
Example #40
0
class TestLibrarySampleTree(BaseTestCase):
    """ Tests for the libraries and samples tree. """
    def setUp(self):
        user = self.create_user('*****@*****.**', 'foo-foo')
        self.client.login(email='*****@*****.**', password='******')

        library = create_library(self._get_random_name())
        sample = create_sample(self._get_random_name())

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(library)
        self.request.samples.add(sample)

    def test_libraries_and_samples_list(self):
        """ Ensure get all libraries and samples works correctly. """
        response = self.client.get(reverse('libraries-and-samples-list'))
        data = response.json()['children'][0]
        self.assertEqual(response.status_code, 200)
        self.assertIn(self.request.name, data['name'])
Example #41
0
    def test_multiple_samples(self):
        """ Ensure get multiple samples behaves correctly. """
        sample1 = create_sample(get_random_name())
        sample2 = create_sample(get_random_name())
        sample3 = create_sample(get_random_name())

        request = Request(user=self.user)
        request.save()
        request.samples.add(*[sample1.pk, sample2.pk, sample3.pk])

        response = self.client.get(reverse('samples-list'), {
            'request_id': request.pk,
            'ids': json.dumps([sample1.pk, sample2.pk])
        })
        data = response.json()
        self.assertEqual(response.status_code, 200)
        self.assertTrue(data['success'])
        samples = [x['name'] for x in data['data']]
        self.assertIn(sample1.name, samples)
        self.assertIn(sample2.name, samples)
        self.assertNotIn(sample3.name, samples)
Example #42
0
def index(request, lang):
    data = {'lang': lang}
    if lang not in LANGUAGES:
        return render_to_response('client/404.html', {'data': data}, RequestContext(request))
    contact_info = ContactInfo.objects.all()
    if contact_info:
        data['contact_info'] = contact_info[0]
    comments = Comment.objects.filter(deleted=False).order_by('-date')
    data['comments'] = comments
    order = ''
    if lang == 'es':
        order = 'spanish_name'
    elif lang == 'en':
        order = 'english_name'
    elif lang == 'de':
        order = 'german_name'
    elif lang == 'pt':
        order = 'portuguese_name'
    elif lang == 'fr':
        order = 'french_name'
    services_list = Service.objects.filter(deleted=False).order_by(order)
    data['services'] = services_list
    if request.method == 'POST':
        if 'btn_comment' in request.POST:
            content = request.POST['text_comment']
            comment = Comment(content=content)
            comment.save()
            return HttpResponseRedirect('/services/' + lang)
        elif 'btn_suggestion' in request.POST:
            content = request.POST['text_suggestion']
            suggestion = Suggestion(content=content)
            suggestion.save()
            return HttpResponseRedirect('/services/' + lang)
        elif 'btn_request' in request.POST:
            content = request.POST['request']
            contact_info = request.POST['contact_info']
            req = Request(content=content, contact_info=contact_info)
            req.save()
            return HttpResponseRedirect('/services/' + lang)
    return render_to_response('client/main/index.html', {'data': data}, RequestContext(request))
Example #43
0
    def setUp(self):
        user = User.objects.create_user(email='*****@*****.**', password='******')
        pool = Pool(name='_Foo', user=user)
        pool.save()

        library_1 = Library.get_test_library('Library1')
        library_2 = Library.get_test_library('Library2')
        library_1.save()
        library_2.save()

        sample_1 = Sample.get_test_sample('Sample1')
        sample_2 = Sample.get_test_sample('Sample2')
        sample_1.save()
        sample_2.save()

        pool.libraries.add(library_1)
        pool.samples.add(sample_1)

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(*[library_1, library_2])
        self.request.samples.add(*[sample_1, sample_2])
Example #44
0
    def test_multiple_libraries(self):
        """ Ensure get multiple libraries behaves correctly. """
        library1 = create_library(get_random_name())
        library2 = create_library(get_random_name())
        library3 = create_library(get_random_name())

        request = Request(user=self.user)
        request.save()
        request.libraries.add(*[library1.pk, library2.pk, library3.pk])

        response = self.client.get(
            reverse('libraries-list'), {
                'request_id': request.pk,
                'ids': json.dumps([library1.pk, library2.pk])
            })
        data = response.json()
        self.assertEqual(response.status_code, 200)
        self.assertTrue(data['success'])
        libraries = [x['name'] for x in data['data']]
        self.assertIn(library1.name, libraries)
        self.assertIn(library2.name, libraries)
        self.assertNotIn(library3.name, libraries)
Example #45
0
    def setUpClass(cls):
        super(GraphsTestCase, cls).setUpClass()
        cls.factory = RequestFactory()

        Request(path='/admin/', ip='127.0.0.1').save()
        Request(path='/admin/', ip='127.0.0.1').save()
        Request(path='/admin/login/', ip='127.0.0.1').save()

        staff_user = User.objects.create_user(username='******', password='******')
        staff_user.is_staff = True
        staff_user.save()
        cls.staff_user = staff_user

        user = UserFactory()
        cls.user = user

        cls.partner = PartnerFactory()

        cls.app = ApplicationFactory(partner=cls.partner)
        cls.app.status = Application.APPROVED
        cls.app.save()

        cls.dashboard_url = reverse('dashboard')
Example #46
0
    def process_response(self, request, response):
        if request.method.lower() not in settings.REQUEST_VALID_METHOD_NAMES:
            return response

        if response.status_code < 400 and settings.REQUEST_ONLY_ERRORS:
            return response

        if self.exceptions.resolve(request.path):
            return response

        if request.is_ajax() and settings.REQUEST_IGNORE_AJAX:
            return response

        if request.META.get('REMOTE_ADDR') in settings.REQUEST_IGNORE_IP:
            return response

        if getattr(request, 'user', False):
            if request.user.username in settings.REQUEST_IGNORE_USERNAME:
                return response

        Request.create_from_http_request(request, response)

        return response
 def create_test_client_and_request(self):
     client = Client(name="client A")
     data = [
         Request(title=f'title {index+1}',
                 description=f'description {index+1}',
                 client_id=1,
                 priority=index + 1,
                 target_date=date(2018, 11, 6),
                 product=product)
         for index, product in enumerate(ProductEnum)
     ]
     data.append(client)
     db.session.add_all(data)
     db.session.commit()
Example #48
0
    def setUp(self):
        user = User.objects.create_user(
            email='*****@*****.**', password='******', is_staff=self._is_staff,
        )
        user.save()

        library = Library.get_test_library('Library')
        sample = Sample.get_test_sample('Sample')
        library.save()
        sample.save()

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(library)
        self.request.samples.add(sample)
Example #49
0
    def setUp(self):
        user = User.objects.create_user(email='*****@*****.**', password='******')
        pool = Pool(name='_Foo', user=user)
        pool.save()

        library_1 = Library.get_test_library('Library1')
        library_2 = Library.get_test_library('Library2')
        library_1.save()
        library_2.save()

        sample_1 = Sample.get_test_sample('Sample1')
        sample_2 = Sample.get_test_sample('Sample2')
        sample_1.save()
        sample_2.save()

        pool.libraries.add(library_1)
        pool.samples.add(sample_1)

        self.request = Request(user=user)
        self.request.save()
        self.request.libraries.add(*[library_1, library_2])
        self.request.samples.add(*[sample_1, sample_2])
Example #50
0
def services(request, lang):
    contact_info = ContactInfo.objects.all()
    comments = Comment.objects.filter(deleted=False).order_by('-date')
    data = {'lang': lang, 'comments': comments}
    if contact_info:
        data['contact_info'] = contact_info[0]
    if lang not in LANGUAGES:
        return render_to_response('client/404.html', {'data': data}, RequestContext(request))
    order = ''
    if lang == 'es':
        order = 'spanish_name'
    elif lang == 'en':
        order = 'english_name'
    elif lang == 'de':
        order = 'german_name'
    elif lang == 'pt':
        order = 'portuguese_name'
    elif lang == 'fr':
        order = 'french_name'
    if 'service' in request.GET:
        id = request.GET['service']
        error = False
        for x in range(0, len(str(id))):
            if not str(id)[x].isdigit():
                error = True
                break
        if not error:
            services_list = Service.objects.filter(deleted=False, id=int(id)).order_by(order)
            if not services_list:
                return render_to_response('client/404.html', {'data': data}, RequestContext(request))
            images = Image.objects.filter(deleted=False, service=services_list[0])
            if images:
                position = random.randrange(0, images.count())
                data['image'] = images[position]
            data['selected'] = True
            data['service'] = id
        else:
            return render_to_response('client/404.html', {'data': data}, RequestContext(request))
    else:
        services_list = Service.objects.filter(deleted=False).order_by(order)
        images = Image.objects.filter(deleted=False)
        if images:
                position = random.randrange(0, images.count())
                data['image'] = images[position]
    data['services'] = services_list
    data['images'] = images
    if request.method == 'POST':
        if 'btn_comment' in request.POST:
            content = request.POST['text_comment']
            comment = Comment(content=content)
            comment.save()
            return HttpResponseRedirect('/services/' + lang)
        elif 'btn_suggestion' in request.POST:
            content = request.POST['text_suggestion']
            suggestion = Suggestion(content=content)
            suggestion.save()
            return HttpResponseRedirect('/services/' + lang)
        elif 'btn_request' in request.POST:
            content = request.POST['request']
            contact_info = request.POST['contact_info']
            req = Request(content=content, contact_info=contact_info)
            req.save()
            return HttpResponseRedirect('/services/' + lang)
    return render_to_response('client/services/index.html', {'data': data}, RequestContext(request))
Example #51
0
 def test_unicode(self):
     request = Request(method='PATCH', path='/', response=204)
     request.time = datetime.now()
     self.assertEqual(unicode(request), '[{}] PATCH / 204'.format(request.time))
 def test_save(self):
     request = Request(ip='1.2.3.4')
     request.save()
 def test_str_conversion(self):
     request = Request(method='PATCH', path='/', response=204)
     request.time = datetime.now()
     self.assertEqual(str(request), '[{}] PATCH / 204'.format(request.time))
Example #54
0
def tool_detail(request, id):
    if not is_user_logged_in(session=request.session):
        return redirect(reverse('sign_in'))
    if 'is_shared_zone' not in request.session:
        return redirect(reverse('shared_zone:index'))

    if request.method == 'GET':
        try:
            tool = Tool.objects.get(id=id, enabled=1)
            pickup_times = User.objects.filter(pk=tool.owner.id).values_list('pickup_days', 'pickup_times')
            pickup_times = list(pickup_times)[0]
            if pickup_times[0] is None or pickup_times[1] is None:
                pickup_times = None
            if tool.is_shared_from_home():
                pickup_address = tool.owner.get_address()
            else:
                pickup_address = SharedZone.objects.get(zipcode=tool.owner.zipcode).address
            may_leave_comment = False
            if Request.objects.filter(borrower=request.session["cool_user"], tool=id, status=Request.RETURNED, may_leave_comment=True).count() > 0:
                may_leave_comment = True
            context = {
                'pickup_address': pickup_address,
                'tool': tool,
                'borrow': True,
                'pickup_times': pickup_times,
                'id': id,
                'may_leave_comment': may_leave_comment
            }
            if "format" in request.GET and request.GET["format"] == "json":
                data = serializers.serialize("json", [tool])
                if pickup_times:
                    pu_times = {
                        'days': pickup_times[0],
                        'hours': pickup_times[1],
                    }
                else:
                    pu_times = None
                response = {'statusCode': 200, 'message': 'OK', 'data': data, 'media': settings.MEDIA_URL, 'pickup_times': pu_times, 'pickup_address': pickup_address}
                return JsonResponse(response)
        except Tool.DoesNotExist:
            context = {
                "not_found": 'The item you requested does not exist',
                'borrow': True,
                'id': id
            }
            if "format" in request.GET and request.GET["format"] == "json":
                response = {'statusCode': 404, 'message': 'The item you requested does not exist'}
                return JsonResponse(response)
        except Exception as e:
            print(e)
    if request.method == 'POST':
        try:
            tool = Tool.objects.get(pk=id, enabled=1)
            borrower = User.objects.get(pk=request.session["cool_user"], enabled=1)
            tool_request = Request(tool=tool, lender=tool.owner, borrower=borrower, zipcode=borrower.zipcode, shared_from=tool.shared_from)
            success_message = "The tool has been requested successfully! Please wait for owner's approval."
            if tool.shared_from == Tool.SHED:
                tool_request.comment = "Borrowing request approved!"
                success_message = "Borrowing request approved!"
                tool_request.status = Request.APPROVED
                tool.status = Tool.BORROWED
                tool.save()
                try:
                    request.session['notification_s'] += 1
                except KeyError:
                    request.session['notification_s'] = 1
                try:
                    optional = "Please return the tool as soon as you finish using it. Remind the shed coordinator to mark the tool as returned."
                    send_email('request_action.txt', 'request_action.html', {'tool_name': tool_request.tool.name, 'request_status': tool_request.get_status_choices(), 'message': tool_request.comment, 'optional': optional}, "Borrowing Request Information", tool_request.borrower.email)
                except Exception as e:
                    print(e)
            tool_request.save()
            if tool_request.tool.shared_from == Tool.HOME:
                try:
                    notification = Notification.objects.get(user=tool.owner)
                except Notification.DoesNotExist:
                    notification = Notification(user=tool.owner)
                    notification.save()
                notification.increment_received()
                notification.save()
                try:
                    send_email('borrowing_request.txt', 'borrowing_request.html', {'borrower': tool_request.borrower.__str__(), 'tool': tool_request.tool.name}, "Borrowing Request Information", tool_request.lender.email)
                except Exception as e:
                    print(e)
            context = {
                'tool': tool,
                'borrow': True,
                'message': success_message,
                'id': id
            }
            if "format" in request.POST and request.POST["format"] == "json":
                response = {'statusCode': 200, 'message': success_message}
                return JsonResponse(response)
        except Tool.DoesNotExist:
            context = {
                "not_found": 'The item you requested does not exist',
                'borrow': True,
                'id': id
            }
            if "format" in request.POST and request.POST["format"] == "json":
                response = {'statusCode': 404, 'message': 'The item you requested does not exist'}
                return JsonResponse(response)
        except Exception as e:
            print(e)
            context = {
                'tool': tool,
                'borrow': True,
                'id': id
            }
    return render(request, 'tool_listing/tool_detail.html', context)
 def test_save_not_log_ip(self):
     request = Request(ip='1.2.3.4')
     request.save()
     self.assertEqual(settings.IP_DUMMY, request.ip)
 def test_save_anonymous_ip(self):
     request = Request(ip='1.2.3.4')
     request.save()
     self.assertTrue(request.ip.endswith('.1'))
 def test_save_not_log_user(self):
     user = get_user_model().objects.create(username='******')
     request = Request(ip='1.2.3.4', user=user)
     request.save()
     self.assertIsNone(request.user)