Exemple #1
0
    def test_create_article(self):
        url = reverse_lazy('auth_app:api_login')
        data = {
            'email': settings.SUPERUSER_EMAIL,
            'password': settings.SUPERUSER_PASSWORD,
        }
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK,
                         response.data)

        # self.client.force_login()
        if self.user.is_authenticated:
            url = reverse_lazy('blog:post-list')
            data = {
                'title': 'Sport',
                'category': self.category.id,
                'content': 'Test content',
            }

            response = self.client.post(url, data, format='json')
            self.assertEqual(response.status_code, status.HTTP_201_CREATED,
                             response.data)
            print(response.data)

        url = reverse_lazy('blog:post-list')
        data = {
            'title': 'Sport',
            'category': self.category.id,
            'content': 'Test content',
        }
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST,
                         response.data)
        print(response.data)
Exemple #2
0
def basic_upload_view(request):
    if request.method == 'POST':
        form = BasicUploadForm(request.POST, request.FILES)
        if form.is_valid():
            apk = request.FILES['apk']
            if apk.size > settings.MAX_APK_UPLOAD_SIZE:
                messages.warning(request, 'Submitted file is too large.')
                return redirect(reverse_lazy('front:home'))

            with NamedTemporaryFile() as tmp:
                for chunk in apk.chunks():
                    tmp.write(chunk)
                tmp.seek(0)

                if is_android(tmp.name) != 'APK':
                    messages.warning(request,
                                     'Submitted file is not a valid APK.')
                    return redirect(reverse_lazy('front:home'))

                sha256 = get_sha256_of_file(tmp)
                if default_storage.exists(sha256):
                    # analyze(sha256, force=True)
                    return redirect(reverse_lazy('front:report', [sha256]))
                else:
                    default_storage.save(sha256, tmp)
                    analyze(sha256)
                    return redirect(reverse_lazy('front:report', [sha256]))

    return redirect(reverse_lazy('front:home'))
Exemple #3
0
class AllModelFieldsMetadata(MetaData):
    model = wf_models.AllModelFields

    update_fields = {
        'f_file': {
            # ensure upload_url is lazy (premature import case)
            'upload_url':
            format_lazy('{}{}', 'http://localhost:8000',
                        reverse_lazy('all-model-fieldss-accept-file'))
        },
        'f_photo': {
            # ensure upload_url is lazy (premature import case)
            'upload_url':
            format_lazy('{}{}', 'http://localhost:8000',
                        reverse_lazy('all-model-fieldss-accept-file'))
        }
    }

    def get_f_fk_rel_dataset_url(self, field, obj):
        return 'http://localhost:8000%s' % reverse_lazy('books-list')

    def get_f_m2m_rel_dataset_url(self, field, obj):
        return 'http://localhost:8000%s' % reverse_lazy('authors-list')

    def get_title(self, request, view, obj: wf_models.AllModelFields):
        if obj:
            return _('Edit AllModelFields "{0}"').format(obj.printable_name)
        return _('Create AllModelFields')
Exemple #4
0
 def test_password_reset(self):
     url = reverse_lazy('auth_app:api_forgot_password')
     data = {'email': self.user.email}
     response = self.client.post(url, data, format='json')
     self.assertEqual(response.status_code, status.HTTP_200_OK,
                      response.data)
     print(response.data)
     self.assertEqual(len(mail.outbox), 1)
     # print('mail', mail.outbox[0])
     # print(mail.outbox[0].message())
     url_conf = reverse_lazy('auth_app:api_password_reset_confirm')
     string = str(mail.outbox[0].message())
     pattern = r'(http?://[^\"\s]+)'
     result = re.findall(pattern, string)
     activate = result[0]
     activate = activate.split('/')
     # print(activate)
     data = {
         "new_password1": "string1986",
         "new_password2": "string1986",
         "uid": activate[5],
         "token": activate[6],
     }
     # print(activate[5], activate[6])
     response = self.client.post(url_conf, data, format='json')
     self.assertEqual(response.status_code, status.HTTP_200_OK,
                      response.data)
     print(response.data)
Exemple #5
0
    def test_get_profile(self):
        url = reverse_lazy('auth_app:api_login')
        data = {
            'email': settings.SUPERUSER_EMAIL,
            'password': settings.SUPERUSER_PASSWORD,
        }
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK,
                         response.data)
        url = reverse_lazy('profiles:profile_detail')
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        url = reverse_lazy('profiles:profile_detail')

        data = {
            'first_name': 'admin2',
            'last_name': 'AA2',
            'mobile': '+79066669999',
            'location': 'london',
        }
        response = self.client.put(url, data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK,
                         response.data)
        print(response.data)
Exemple #6
0
	def get_links(self, obj):
		request = self.context['request']
		username = obj.get_username()
		return {
			'self': reverse_lazy('user-detail', kwargs = {User.USERNAME_FIELD: username}, request=request),
			'tasks': '{}?assigned={}'.format(reverse_lazy('task-list', request=request), username)
		}
Exemple #7
0
def my_rule_edit_view(request, uuid):
    if not request.user.is_authenticated:
        return redirect(reverse_lazy('front:home'))

    if request.method == 'GET':
        rule = Yara.objects.get(id=uuid)
        new_rule = YaraCreateForm(instance=rule)
        return render(request, 'front/yara_rules/my_rule_edit.html', {
            'form': new_rule,
            'edit': True
        })

    elif request.method == 'POST':
        rule = Yara.objects.get(id=uuid)
        new_rule = YaraCreateForm(request.POST or None, instance=rule)
        try:
            new_rule = new_rule.save(commit=False)
            new_rule.owner = request.user
            new_rule.last_update = timezone.now()
            new_rule.save()
            delete_es_matches(request, rule)
            messages.success(request, 'Your rule has been updated!')
        except Exception:
            return render(request, 'front/yara_rules/my_rule_edit.html',
                          {'form': new_rule})
        return redirect(reverse_lazy('front:my_rules'))
    else:
        return HttpResponseBadRequest()
Exemple #8
0
    def get(self, request, *args, **kwargs):
        if 'sha256' not in kwargs:
            return redirect(reverse_lazy('front:home'))

        sha = kwargs['sha256']
        cache_key = f'html_report_{sha}'

        # First, check if the report is already in cache
        cached_report = cache.get(cache_key)
        if cached_report:
            return cached_report

        # Not cached so, let's compute the report
        es = Elasticsearch([settings.ELASTICSEARCH_HOST])
        try:
            result = es.get(index=settings.ELASTICSEARCH_APK_INDEX,
                            id=sha)['_source']
            if 'analysis_date' not in result:
                messages.info(
                    request,
                    'The analysis is still running, refresh this page in few minutes.'
                )
                return render(request, 'front/report.html', {'result': result})
            else:
                # The analysis is done so put the report into the cache
                html_report = render(request, 'front/report.html',
                                     {'result': result})
                cache.set(cache_key, html_report)
                return html_report
        except Exception:
            return redirect(reverse_lazy('front:home'))
Exemple #9
0
 def get_links(self, obj):
     return {
         "self": utils.get_resource_path(obj),
         "feed": reverse_lazy("user-feed", kwargs={"pk": obj.id, "format": settings.API_FORMAT}),
         "timeline": reverse_lazy("user-timeline", kwargs={"pk": obj.id, "format": settings.API_FORMAT}),
         "following": reverse_lazy("user-following", kwargs={"pk": obj.id, "format": settings.API_FORMAT}),
         "followers": reverse_lazy("user-followers", kwargs={"pk": obj.id, "format": settings.API_FORMAT}),
     }
Exemple #10
0
def api_root(request, format=None):
    return Response({
        'courses':
        reverse_lazy('course:course-list', request=request, format=format),
        #'reviews': reverse('course:review-list', request=request, format=format),
        'users':
        reverse_lazy('course:user-list', request=request, format=format)
    })
Exemple #11
0
def api_root(request, format=None):
    return Response({
        'services':
        reverse_lazy('api:service-list', request=request, format=format),
        'organizations':
        reverse_lazy('api:organization-list', request=request, format=format),
        'testimonials':
        reverse_lazy('api:testimonials_list', request=request, format=format)
    })
Exemple #12
0
 def get(self, request):
     data = {
         'list-comitees':
         reverse_lazy('api-events:com-list', request=request),
         'list-events':
         reverse_lazy('api-events:event-list', request=request),
         'list-athletes':
         reverse_lazy('api-events:athlete-list', request=request),
     }
     return Response(data)
Exemple #13
0
 def get(self, request):
     links = {
         'teams': reverse_lazy('team-list', request=request),
         'users': {
             'all': reverse_lazy('user-list', request=request),
             'organizers': reverse_lazy('user-list-organizers', request=request),
             'attendees': reverse_lazy('user-list-attendees', request=request),
         },
         'event': reverse_lazy('event-detail', request=request),
     }
     return Response(links)
Exemple #14
0
    def _resolve_command_binary(self, request, node_id, command):
        urls = dict()

        cid = command['id']
        on  = command['values']['on']
        off = command['values']['off']

        urls['on']  = reverse_lazy('commands-set', kwargs={ 'pk': node_id, 'cid': cid, 'value': on }, request=request)
        urls['off'] = reverse_lazy('commands-set', kwargs={ 'pk': node_id, 'cid': cid , 'value': off }, request=request)
        urls['current'] = reverse_lazy('commands-get', kwargs={ 'pk': node_id, 'cid': cid }, request=request)

        command['urls'] = urls
Exemple #15
0
    def post(self, request, *args, **kwargs):
        form = self.get_form()
        if form.is_valid():

            if APIClient().add_products(form):
                self.success_url = reverse_lazy('formset_default_success', kwargs={'success': 1})
            else:
                self.success_url = reverse_lazy('formset_default_success', kwargs={'success': 2})
            return self.form_valid(form)
        else:
            return self.form_invalid(form)
        return super(DefaultFormsetView, self).post(request, *args, **kwargs)
Exemple #16
0
 def _get_app_url(self, request, region, app_type):
     routes = {
         US: {
             INDIVIDUAL: reverse_lazy('wfrs-api-apply-us-individual', request=request),
             JOINT: reverse_lazy('wfrs-api-apply-us-join', request=request),
         },
         CA: {
             INDIVIDUAL: reverse_lazy('wfrs-api-apply-ca-individual', request=request),
             JOINT: reverse_lazy('wfrs-api-apply-ca-joint', request=request),
         },
     }
     return routes.get(region, {}).get(app_type)
Exemple #17
0
 def get_links(self, obj):
     request = self.context['request']
     username = obj.get_username()
     return {
         'self':
         reverse_lazy('user-detail',
                      kwargs={User.USERNAME_FIELD: username},
                      request=request),
         'tasks':
         '{}?assigned={}'.format(reverse_lazy('task-list', request=request),
                                 username)
     }
Exemple #18
0
 def test_create_article_forbidden(self):
     url = reverse_lazy('auth_app:logout')
     response = self.client.post(url)
     self.assertEqual(response.status_code, status.HTTP_200_OK)
     url = reverse_lazy('blog:post-list')
     data = {
         'title': 'Sport',
         'category': self.category.id,
         'content': 'Test content',
     }
     response = self.client.post(url, data, format='json')
     self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
     print("Create article forbidden", response.data)
Exemple #19
0
 def get(self, request):
     links = {
         'teams': reverse_lazy('team-list', request=request),
         'users': {
             'all': reverse_lazy('user-list', request=request),
             'organizers': reverse_lazy('user-list-organizers',
                                        request=request),
             'attendees': reverse_lazy('user-list-attendees',
                                       request=request),
         },
         'event': reverse_lazy('event-detail', request=request),
     }
     return Response(links)
Exemple #20
0
    def generate(self, request):

        if request.method == 'GET':
            return Response({}, status=status.HTTP_200_OK)

        if not hasattr(request.user, 'creator'):
            return Response({'detail': 'you are not a creator'}, status=status.HTTP_403_FORBIDDEN)

        creator = request.user.creator

        class_name = request.data['class_name']
        clicker_class = models.ClickerClass.objects.get(class_name=class_name)
        # class_size = clicker_class.get_connected_devices()

        # if class_size == 0:
        #     return Response({'detail': 'class size is zero'}, status=status.HTTP_403_FORBIDDEN)

        interaction_type = models.InteractionType.objects.get(slug_name='regression')

        for m in models.Interaction.objects.filter(clicker_class=clicker_class):
            m.state = models.Interaction.COMPLETE
            m.save()

        # create game of life instance and corresponding interaction
        interaction = models.Interaction.objects.create(clicker_class=clicker_class,
                                                        state=models.Interaction.ACTIVE,
                                                        creator=creator,
                                                        interaction_type=interaction_type)
        interaction.save()

        regression = models.Regression(interaction=interaction,
                                       x_label="Height (cm)",
                                       y_label="Weight (kg)")
        regression.save()

        interaction_data = {
            'assignments': {},
            'urls': {
                'source': str(reverse_lazy('regression-detail', args=[regression.id])),
                'plot_items': str(reverse_lazy('regressionplotitem-list'))
            },
            'interaction': interaction.id,
            'instance_script': '/static/js/:type:/regression.bundle.js',
            'instance_component_name': 'Regression'
        }

        interaction.data_json = json.dumps(interaction_data)
        interaction.save()

        return Response(serializers.RegressionSerializer(regression, context={'request': request}).data,
                        status=status.HTTP_201_CREATED)
Exemple #21
0
	def get_links(self, obj):
		request = self.context['request']
		links = {
			'self': reverse_lazy('task-detail', kwargs={'pk': obj.pk}, request=request),
			'sprint': None,
			'assigned': None
		}
		if obj.sprint_id:
			links['sprint'] = reverse_lazy('sprint-detail', kwargs={'pk':obj.sprint_id}, request=request)
		
		if obj.assigned:
			links['assigned'] = reverse_lazy('user-detail', kwargs={User.USERNAME_FIELD: obj.assigned}, request=request)

		return links
Exemple #22
0
def download_sample_view(request, sha256):
    if not request.user.is_authenticated:
        return redirect(reverse_lazy('front:home'))

    if request.method == 'GET':
        if not default_storage.exists(sha256):
            return redirect(reverse_lazy('front:home'))

        response = HttpResponse(
            default_storage.open(sha256).read(),
            content_type="application/vnd.android.package-archive")
        response[
            'Content-Disposition'] = f'inline; filename=pithus_sample_{sha256}.apk'
        return response
Exemple #23
0
def my_rule_delete_view(request, uuid=None):
    if not request.user.is_authenticated:
        return redirect(reverse_lazy('front:home'))

    if request.method == 'GET':
        rule = Yara.objects.get(id=uuid)
        try:
            delete_es_matches(request, rule)
            rule.delete()
            messages.success(request, 'Your rule has been deleted.')
            return redirect(reverse_lazy('front:my_rules'))
        except Exception as e:
            logging.exception(e)
            return redirect(reverse_lazy('front:my_rules'))
Exemple #24
0
    def get(self, request, *args, **kwargs):
        raw_match_string = self.request.query_params.get('match', '')
        match_string = ultils.translate_raw_match_string(raw_match_string)
        if not match_string:
            job_list = self.job_queryset.get_all_jobs()
        else:
            job_list = self.job_queryset.search(match_string=match_string)

        if not job_list:
            return Response(status=status.HTTP_200_OK,
                            data={
                                'list': None,
                                'count': 0,
                                'next_page': None
                            })

        page = ultils.convert_int_or_set_default(
            self.request.query_params.get('p'), default=1)
        num = ultils.convert_int_or_set_default(
            num=self.request.query_params.get('n'), default=10)
        reviews, next_page = ultils.get_data_and_next_page(data=job_list,
                                                           num=num,
                                                           page=page)
        if next_page:
            if not match_string:
                append_string = urllib.urlencode({'p': next_page, 'n': num})
                next_page = '{0}?{1}'.format(
                    reverse_lazy('jobsite_job_list', request=request),
                    append_string)
            else:
                append_string = urllib.urlencode({
                    'match': raw_match_string,
                    'p': next_page,
                    'n': num
                })
                next_page = '{0}?{1}'.format(
                    reverse_lazy('jobsite_job_search', request=request),
                    append_string)
        reviews = JobListSerializer(reviews, many=True)
        data = {
            'list': reviews.data,
            'count': len(reviews.data),
            'next_page': next_page
        }
        return Response(
            status=status.HTTP_200_OK,
            data=data,
        )
Exemple #25
0
 def test_article_list(self):
     url = reverse_lazy('blog:post-list', )
     response = self.client.get(url)
     self.assertEqual(response.status_code, status.HTTP_200_OK,
                      response.data)
     print(response.data)
     self.assertEqual(response.data.get('count'), 1)
    def test_copy_draft_standard_temporary_application_successful(self):
        """
        Ensure we can copy a standard temporary application that is a draft
        """
        self.original_application = self.create_draft_standard_application(
            self.organisation)
        self.original_application.export_type = ApplicationExportType.TEMPORARY
        self.original_application.temp_export_details = "temporary export details"
        self.original_application.is_temp_direct_control = True
        self.original_application.proposed_return_date = "2025-05-11"
        self.submit_application(self.original_application)

        self.url = reverse_lazy("applications:copy",
                                kwargs={"pk": self.original_application.id})

        self.data = {
            "name": "New application",
            "have_you_been_informed": ApplicationExportLicenceOfficialType.YES,
            "reference_number_on_information_form": "54321-12",
        }

        self.response = self.client.post(self.url, self.data,
                                         **self.exporter_headers)
        self.response_data = self.response.json()["data"]

        self.assertEqual(self.response.status_code, status.HTTP_201_CREATED)
        self.assertNotEqual(self.response_data, self.original_application.id)

        self.copied_application = StandardApplication.objects.get(
            id=self.response_data)

        self._validate_standard_application()
Exemple #27
0
class SignUpApiViewTests(TestCase):

    url = reverse_lazy('register-list')

    def setUp(self):
        self.client = APIClient()

    def test_should_create_user(self):
        FOO_EMAIL = '*****@*****.**'
        payload = {
            'email': FOO_EMAIL,
            'password': '******',
        }

        self.client.post(self.url, payload)

        self.assertTrue(
            get_user_model().objects.filter(email=FOO_EMAIL).exists())

    @skip('send email after API register')
    def test_should_send_email_with_confirmation_link(self):
        payload = {
            'email': '*****@*****.**',
            'password': '******',
        }

        self.client.post(self.url, payload)

        self.assertEqual(len(mail.outbox), 1)
        self.assertEqual(mail.outbox[0].subject, 'Confirm your email')
Exemple #28
0
    def _resolve_url(self, request, wtf, container):
        assert container

        association = container['association']

        for item in container['items']:
            item['url'] = reverse_lazy('mixes-details', kwargs={ 'pk': item['identifier'], 'wtf': wtf, 'entry': association['entry'] }, request=request)
class ListingView(FormMixin, DetailView):
    #template_name = 'listing/listing.html'
    template_name = 'feather/listing_detail.html'
    model = Listing
    form_class = ListingContactForm
    success_url = reverse_lazy('thank-you')

    def get_queryset(self):
        if self.request.user.is_staff:
            return Listing.objects.all()
        return Listing.objects.active()

    def get_context_data(self, **kwargs):
        context = super(ListingView, self).get_context_data(**kwargs)
        form_class = self.get_form_class()
        context['form'] = self.get_form(form_class)
        return context

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()
        form_class = self.get_form_class()
        form = self.get_form(form_class)
        if form.is_valid():
            return self.form_valid(form)
        else:
            return self.form_invalid(form)

    def form_valid(self, form):
        form.send_contact_form(self.object)
        return super(ListingView, self).form_valid(form)
Exemple #30
0
    def test_question_random_list(self):
        """SHOULD get random list of questions with default limit = 5"""
        response = self.client.get(reverse_lazy("questions-random-list"))
        response_count = len(response.data)

        assert response.status_code == status.HTTP_200_OK
        assert response_count == 5
Exemple #31
0
def require_admin_approval(sender, **kwargs):
    # make user inactive by default
    user = kwargs['email_address'].user
    user.is_active = False
    user.save()

    activation_link = reverse_lazy('account-activate',
                                   args=[kwargs['email_address']],
                                   request=kwargs['request'])
    admins = User.objects.filter(is_superuser=True)

    msg = EmailMultiAlternatives(
        'MIQA Account Approval - New User',
        f'A new user with the email {kwargs["email_address"]} has created '
        'an account in MIQA. As an administrative user, it is your responsibility '
        'to activate this account if you believe this user is legitimate. '
        'If you believe this account should not be activated, reach out to this user'
        f'{" and other administrators." if len(admins) > 1 else "."} '
        '\n\n '
        f'To activate this account, visit {activation_link} '
        '\n\n '
        'Thank you for using MIQA! ',
        settings.DEFAULT_FROM_EMAIL,
        [admin.email for admin in admins],
    )
    msg.send()
Exemple #32
0
 def get_context_data(self, **kwargs):
     context = super(ItemDetail, self).get_context_data(**kwargs)
     ts_item = {'ts_api_root': str(reverse_lazy('api-root', request=self.request)),
                'ts_item_uuid': self.get_object().uuid
                }
     context['ts_item'] = json.dumps(ts_item)
     return context
Exemple #33
0
    def create(self, request, *args, **kwargs):
        '''
        Override the create funtion in order to to return to the url list and check url valid
        '''

        url = request.POST["site_link"]
        if not urllib.parse.urlparse(url).scheme:
            url = 'http://' + url

        try:
            urllib.request.urlopen(url)
            super(ListCreateBookmarkViewSet,
                  self).create(request, *args, **kwargs)

        except IntegrityError:
            messages.info(request, 'This URL all ready exist!')

        except ValidationError as error:
            messages.info(request, 'This TITLE all ready exist!')

        except urllib.error.URLError:
            messages.info(
                request, request.POST["site_link"] +
                ' is not a working link NOT ADDED TO THE LIST!')

        return HttpResponseRedirect(
            redirect_to=reverse_lazy('appBookmarks:bookmarks-list'))
Exemple #34
0
    def get(self, request, *args, **kwargs):
        page = ultils.convert_int_or_set_default(
            self.request.query_params.get('p'), default=None)
        if page:
            num = ultils.convert_int_or_set_default(
                num=self.request.query_params.get('n'), default=10)
            job_list = self.job_queryset.get_all_jobs()
            jobs, next_page = ultils.get_data_and_next_page(data=job_list,
                                                            num=num,
                                                            page=page)
            if next_page:
                next_page = '{0}?p={1}&n={2}'.format(
                    reverse_lazy('jobsite_job_list', request=request),
                    next_page, num)
        else:
            jobs = self.job_queryset.get_job_list()
            next_page = None

        if jobs:
            jobs = JobListSerializer(jobs, many=True)
            data = {
                'data': jobs.data,
                'count': len(jobs.data),
                'next_page': next_page
            }
            return Response(
                status=status.HTTP_200_OK,
                data=data,
            )
        return Response(
            status=status.HTTP_404_NOT_FOUND,
            data='Job not found',
        )
    def test_copy_draft_standard_trade_control_application_successful(self):
        """
        Ensure we can copy a standard trade control application that is a draft
        """
        self.original_application = self.create_draft_standard_application(
            self.organisation)
        self.original_application.trade_control_activity = TradeControlActivity.OTHER
        self.original_application.trade_control_activity_other = "other activity"
        self.original_application.trade_control_product_categories = [
            key for key, _ in TradeControlProductCategory.choices
        ]
        self.original_application.save()

        self.url = reverse_lazy("applications:copy",
                                kwargs={"pk": self.original_application.id})

        self.data = {
            "name": "New application",
            "have_you_been_informed": ApplicationExportLicenceOfficialType.YES,
            "reference_number_on_information_form": "54321-12",
        }

        self.response = self.client.post(self.url, self.data,
                                         **self.exporter_headers)
        self.response_data = self.response.json()["data"]

        self.assertEqual(self.response.status_code, status.HTTP_201_CREATED)
        self.assertNotEqual(self.response_data, self.original_application.id)

        self.copied_application = StandardApplication.objects.get(
            id=self.response_data)

        self._validate_standard_application()
Exemple #36
0
 def report(self, request, pk=None):
     user = request.user
     emails = settings.REPORT_MAILS
     url = reverse_lazy('admin:wp_core_question_change',
                        args=([pk]),
                        request=request)
     question = self.get_object()
     reason = request.data.get('reason', 'nichts angegeben')
     params = {
         'question': question.text,
         'link': url,
         'reason': reason,
         'reporter': user,
     }
     plain = render_to_string('wp_core/mails/report_question_email.txt',
                              params)
     html = render_to_string('wp_core/mails/report_question_email.html',
                             params)
     if settings.REPORT_MAILS_ACTIVE:
         send_mail('Eine Frage wurde gemeldet',
                   plain,
                   '*****@*****.**',
                   emails,
                   html_message=html)
     slack_notify_report(question.text, reason, url, user)
     return Response({'success': True})
    def test_copy_draft_standard_application_successful(self):
        """
        Ensure we can copy a standard application that is a draft
        """
        self.original_application = self.create_draft_standard_application(
            self.organisation)

        self.url = reverse_lazy("applications:copy",
                                kwargs={"pk": self.original_application.id})

        self.data = {
            "name": "New application",
            "have_you_been_informed": ApplicationExportLicenceOfficialType.YES,
            "reference_number_on_information_form": "54321-12",
        }

        self.response = self.client.post(self.url, self.data,
                                         **self.exporter_headers)
        self.response_data = self.response.json()["data"]

        self.assertEqual(self.response.status_code, status.HTTP_201_CREATED)
        self.assertNotEqual(self.response_data, self.original_application.id)

        self.copied_application = StandardApplication.objects.get(
            id=self.response_data)

        self._validate_standard_application()
    def test_copy_submitted_open_temporary_application_successful(self):
        """
        Ensure we can copy an open temporary application that is submitted (ongoing or otherwise)
        """
        self.original_application = self.create_draft_open_application(
            self.organisation)
        self.original_application.export_type = ApplicationExportType.TEMPORARY
        self.original_application.temp_export_details = "temporary export details"
        self.original_application.is_temp_direct_control = True
        self.original_application.proposed_return_date = "2025-05-11"
        coa = CountryOnApplication.objects.get(
            application=self.original_application, country_id="FR")
        coa.contract_types = ["navy", "army"]
        coa.save()

        self.submit_application(self.original_application)

        self.url = reverse_lazy("applications:copy",
                                kwargs={"pk": self.original_application.id})

        self.data = {"name": "New application"}

        self.response = self.client.post(self.url, self.data,
                                         **self.exporter_headers)
        self.response_data = self.response.json()["data"]

        self.assertEqual(self.response.status_code, status.HTTP_201_CREATED)
        self.assertNotEqual(self.response_data, self.original_application.id)

        self.copied_application = OpenApplication.objects.get(
            id=self.response_data)

        self._validate_open_application()
    def test_copy_draft_open_trade_control_application_successful(self):
        """
        Ensure we can copy an open application that is a draft
        """
        self.original_application = self.create_draft_open_application(
            self.organisation, case_type_id=CaseTypeEnum.OICL.id)
        self.original_application.trade_control_activity = TradeControlActivity.OTHER
        self.original_application.trade_control_activity_other = "other activity"
        self.original_application.trade_control_product_categories = [
            key for key, _ in TradeControlProductCategory.choices
        ]
        self.original_application.save()

        self.url = reverse_lazy("applications:copy",
                                kwargs={"pk": self.original_application.id})

        self.data = {"name": "New application"}

        self.response = self.client.post(self.url, self.data,
                                         **self.exporter_headers)
        self.response_data = self.response.json()["data"]

        self.assertEqual(self.response.status_code, status.HTTP_201_CREATED)
        self.assertNotEqual(self.response_data, self.original_application.id)

        self.copied_application = OpenApplication.objects.get(
            id=self.response_data)

        self._validate_open_application()
 def get_url_blog(self, instance):
     # Se GUARDA la URL de DETALLE de un BLOG asociada a los DISTINTOS Usuarios.
     url = reverse_lazy('blog_detail_page',
                        kwargs={'user_name': instance.username})
     # Se devuelve un string informando de la URL del Blog y a quien pertenece
     return 'El Blog de %s %s | URL: localhost:8000%s' % (
         instance.first_name, instance.last_name, url)
Exemple #41
0
def cadastrar_funcionario(request):
    if request.method == 'POST':
        funcionario_form = FuncionarioForm(request.POST, request.FILES)
        if funcionario_form.is_valid():
            funcionario_form.save()
            return redirect(reverse_lazy('cadastrar_funcionario'))
    else:
        funcionario_form = FuncionarioForm()
    return render(request, 'funcionarios/cadastrar_funcionario.html', {'funcionario_form': funcionario_form})
Exemple #42
0
def cadastrar_conta_receber(request):
    if request.method == 'POST':
        conta_receber_form = Conta_receberForm(request.POST)
        if conta_receber_form.is_valid():
            conta_receber_form.save()
            return redirect(reverse_lazy('cadastrar_conta_receber'))
    else:
        conta_receber_form = Conta_receberForm()
    return render(request, 'conta_receber/cadastrar_conta_receber.html', {'conta_receber_form': conta_receber_form})
Exemple #43
0
def cadastrar_cliente(request):
    if request.method == 'POST':
        cliente_form = ClienteForm(request.POST, request.FILES)
        if cliente_form.is_valid():
            cliente_form.save()
            return redirect(reverse_lazy('cadastrar_cliente'))
    else:
        cliente_form = ClienteForm()
    return render(request, 'clientes/cadastrar_cliente.html', {'cliente_form': cliente_form})
Exemple #44
0
def cadastrar_fornecedor(request):
    if request.method == 'POST':
        fornecedor_form = FornecedorForm(request.POST)
        if fornecedor_form.is_valid():
            fornecedor_form.save()
            return redirect(reverse_lazy('cadastrar_fornecedor'))
    else:
        fornecedor_form = FornecedorForm()
    return render(request, 'fornecedores/cadastrar_fornecedor.html', {'fornecedor_form': fornecedor_form})
Exemple #45
0
 def get_task_urls(self, obj):
     """
     retuns end point for different operations tasks.
     :param obj: task obj
     :return: dict with url points
     """
     kwargs={'pk': obj.id}
     url_names = ['task-manage-note',
                  'task-move-to-folder',
                  'task-manage-tags',
                  'task-notes',
                  'task-toggle-done']
     urls = {}
     for url_name in url_names:
         urls[url_name.replace('task-', '')]=reverse_lazy(url_name, [obj.id])
     if obj.task_set.count():
         urls['sub-tasks']=reverse_lazy('task-sub-tasks', [obj.id])
     return urls
Exemple #46
0
def cadastrar_mercadoria(request):
    if request.method == 'POST':
        mercadoria_form = MercadoriaForm(request.POST)
        if mercadoria_form.is_valid():
            mercadoria_form.save()
            return redirect(reverse_lazy('cadastrar_mercadoria'))
    else:
        mercadoria_form = MercadoriaForm()
    return render(request, 'mercadorias/cadastrar_mercadoria.html', {'mercadoria_form': mercadoria_form})
Exemple #47
0
def cadastrar_compra(request):
    if request.method == 'POST':
        compra_form = CompraForm(request.POST)
        if compra_form.is_valid():
            compra_form.save()
            return redirect(reverse_lazy('cadastrar_compra'))
    else:
        compra_form = CompraForm()
    return render(request, 'compras/cadastrar_compra.html', {'compra_form': compra_form})
 def get_project_detail(self, obj):
     """Returns URI for object into the project_detail field"""
     request = self.context['request']
     return {
         'self': reverse_lazy(
             'portfolio_project_detail',
             kwargs={'slug': obj.slug},
             request=request,
         )
     }
Exemple #49
0
def new_bubble_sort_swap(sender, instance, **kwargs):
    class_name = instance.bubble_sort.interaction.clicker_class.class_name
    channel = 'bubblesort.{}.client'.format(class_name)
    url = reverse_lazy('bubblesort-detail', args=[instance.bubble_sort_id])

    print "Publishing to redis:{}".format(channel)
    r.publish(channel, json.dumps({
        'lower_index': instance.lower_index,
        'bubble_sort': str(url),
        'event_type': 'swap'
    }))
Exemple #50
0
 def list(self, *args, **kwargs):
     return Response({
         'allowance': reverse_lazy('reports-allowance', request=self.request),
         'export': reverse_lazy('reports-export', request=self.request),
         'rates': reverse_lazy('reports-rates', request=self.request),
         'savings': reverse_lazy('reports-savings', request=self.request),
         'stats': reverse_lazy('reports-stats', request=self.request),
         'summary': reverse_lazy('reports-summary', request=self.request),
         'week': reverse_lazy('reports-week', request=self.request),
     })
Exemple #51
0
    def list(self, request):
        """
        Return a list of all settings.
        """
        result = list()
        for association in models.Association.objects.all():
            result.append({
                'name': association.name,
                'entry': association.entry,
                'url':  reverse_lazy("setting-detail", kwargs={ 'pk': association.id }, request=request)
                })

        return Response(result)
Exemple #52
0
def save_game_of_life(sender, instance, **kwargs):

    if instance.is_async:
        return

    if instance.is_buffer:
        return

    class_name = instance.interaction.clicker_class.class_name
    channel = 'gameoflife.{}.client'.format(class_name)
    url = reverse_lazy('gameoflife-detail', args=[instance.id])

    print "Publishing to redis:{}".format(channel)
    r.publish(channel, json.dumps({
        'game_of_life': str(url),
        'event_type': 'next_state',
        'serialized': unicode(instance)
    }))
Exemple #53
0
    def get(self,request):
        recruitment_info=RecruitmentInformation.objects.filter(department=request.user)
        data={}
        approved_recruitment_info = recruitment_info.filter(is_varified=True)
        pending_recruitment_info = recruitment_info.filter(is_varified=False)
        denied_recruitment_info = recruitment_info.filter(is_denied=True)
        applications = Application.objects.filter_by_department(user=request.user)
        applying = applications.filter(status='w')
        pending = applications.filter(status='s')
        data['approved_recruitment_info']=[list for each in approved_recruitment_info]
        data['approved_recruitment_info']=PostListSerializer(
                approved_recruitment_info,
                many=True,
                context={'request': request}
        ).data

        data['pending_recruitment_info']=PostListSerializer(
                pending_recruitment_info,
                many=True,
                context={'request': request}
        ).data
        data['denied_recruitment_info']=PostListSerializer(
                denied_recruitment_info,
                many=True,
                context={'request': request}
        ).data
        data['applying'] = ApplicationListSerializer(
                applying,
                many=True,
                context={'request': request}
        ).data
        data['pending'] = ApplicationListSerializer(
                pending,
                many=True,
                context={'request': request}
        ).data
        #cause in our serializers, we called anther funcyions so we must have context={'request': request}


        data['revers test']=reverse_lazy('users-api:login',request=request)

        return Response(data)
Exemple #54
0
 def get(self, request):
     #
     # Keyword arguments for the reversion
     #
     kwargs = {"request": request, "format": settings.API_FORMAT}
     #
     # Create HTTP response
     #
     return Response(
         {
             "me": reverse_lazy("me", **kwargs),
             "users": reverse_lazy("user-list", **kwargs),
             "memes": reverse_lazy("meme-list", **kwargs),
             "posts": reverse_lazy("post-list", **kwargs),
             "likes": reverse_lazy("like-list", **kwargs),
             "comments": reverse_lazy("comment-list", **kwargs),
             "friendships": reverse_lazy("friendship-list", **kwargs),
         },
         status=status.HTTP_200_OK,
     )
Exemple #55
0
def save_game_of_life_cell(sender, instance, **kwargs):
    if instance.game_of_life.is_buffer:
        return

    if instance.game_of_life.interaction.state != Interaction.ACTIVE:
        return

    if not instance.changed:
        return

    class_name = instance.game_of_life.interaction.clicker_class.class_name
    channel = '{}gameoflife.{}.client'.format('async' if instance.game_of_life.is_async else '', class_name)
    url = reverse_lazy('gameoflife-detail', args=[instance.game_of_life_id])

    print "Publishing to redis:{}".format(channel)
    r.publish(channel, json.dumps({
        'row': instance.row,
        'col': instance.col,
        'alive': instance.alive,
        'game_of_life': str(url),
        'event_type': 'toggle_cell'
    }))
Exemple #56
0
 def get_parent_url(self, obj):
     return reverse_lazy('api-root', request=self.context.get('request'))
Exemple #57
0
	def get_links(self, obj):
		request = self.context['request']
		return {
			'self': reverse_lazy('sprint-detail', kwargs={'pk': obj.pk}, request=request),
		}
Exemple #58
0
    def generate(self, request, **kwargs):
        """
        :param class_name: the class this interaction will be associated with

        """
        try:
            if request.DATA:
                data = request.DATA
            else:
                data = request.stream.DATA
        except Exception:
            data = request.stream.DATA

        async = data.get('async', False) is True

        if request.method == 'GET':
            return Response({}, status=status.HTTP_200_OK)

        if not hasattr(request.user, 'creator'):
            return Response({'detail': 'you are not a creator'}, status=status.HTTP_403_FORBIDDEN)

        creator = request.user.creator

        class_name = data['class_name']
        clicker_class = models.ClickerClass.objects.get(class_name=class_name)
        class_size = clicker_class.get_connected_devices()

        if class_size == 0:
            return Response({'detail': 'class size is zero'}, status=status.HTTP_403_FORBIDDEN)

        # if 'interaction_slug' not in request.data:
        #     return Response({'detail': 'please specify an interaction type'}, status=status.HTTP_400_BAD_REQUEST)

        activate = data.get('activate', GameOfLifeViewSet.DEFAULT_ACTIVATE)

        # interaction_slug = request.data['interaction_slug']
        interaction_type = models.InteractionType.objects.get(slug_name='gameoflife')

        for m in models.Interaction.objects.all():
            if activate:
                m.state = models.Interaction.COMPLETE
                m.save()

        # create game of life instance and corresponding interaction
        interaction = models.Interaction.objects.create(clicker_class=clicker_class,
                                                        state=models.Interaction.READY,
                                                        creator=creator,
                                                        interaction_type=interaction_type)
        interaction.save()

        rows = max(4, int(math.ceil(math.sqrt(class_size))))
        cols = max(4, int(math.ceil(float(class_size) / rows)))  # more-or-less square
        game = models.GameOfLife(num_rows=rows, num_cols=cols, interaction=interaction, is_async=async)
        game.save()
        if not async:
            gol_buffer = models.GameOfLife(num_rows=rows, num_cols=cols, is_async=False, is_buffer=True)
            gol_buffer.save()
            game.buffer = gol_buffer
            game.save()

        interaction.gameoflife = game
        if activate:
            interaction.state = models.Interaction.ACTIVE
        interaction.save()

        # allocate clients to cells

        def rand_bool():
            return random.randrange(2) == 0

        clients = map(lambda d: d.device_id, clicker_class.registereddevice_set.all())
        ai = [True] * ((rows * cols) - class_size)
        everything = clients + ai
        random.shuffle(everything)

        # assign cell states randomly

        interaction_data = {'assignments': {}}

        patterns = {
            'glider': (
                (0, 0, 1, 0),
                (1, 0, 1, 0),
                (0, 1, 1, 0),
                (0, 0, 0, 0),
            )
        }

        pattern_name = data.get('pattern', GameOfLifeViewSet.DEFAULT_PATTERN)
        if pattern_name in patterns:
            pattern = patterns[pattern_name]
        else:
            pattern = None

        for col in range(cols):
            for row in range(rows):
                cell = game.cells.filter(game_of_life=game, row=row, col=col)[0]
                if pattern:
                    if row < len(pattern) and col < len(pattern[0]):
                        cell.alive = bool(pattern[row][col])
                    else:
                        cell.alive = False  # could use rand_bool() here.
                else:
                    cell.alive = rand_bool()

                if not async:
                    buff_cell = gol_buffer.cells.filter(game_of_life=gol_buffer, row=row, col=col)[0]
                something = everything.pop()
                if isinstance(something, unicode):
                    device_id = something
                    cell.save()
                    cell_data = serializers.GameOfLifeCellSerializer(cell,
                                                                     context={'request': request}).data
                    if async:
                        interaction_data['assignments'][device_id] = cell_data
                    else:
                        buff_cell_data = serializers.GameOfLifeCellSerializer(buff_cell,
                                                                              context={'request': request}).data
                        interaction_data['assignments'][device_id] = {
                            'source': cell_data,
                            'buffer': buff_cell_data
                        }
                else:
                    cell.is_ai = True
                    cell.save()

                if not async:
                    buff_cell.is_ai = cell.is_ai
                    buff_cell.alive = cell.alive
                    buff_cell.save()

        interaction_data['urls'] = {
            'source': str(reverse_lazy('gameoflife-detail', args=[game.id])),
        }
        if not async:
            interaction_data['urls']['buffer'] = str(reverse_lazy('gameoflife-detail', args=[gol_buffer.id]))

        interaction_data['urls']['next_state'] = "{}swap_buffers/".format(interaction_data['urls']['source'])
        interaction_data['interaction'] = interaction.id
        interaction_data['game_of_life'] = game.id
        if async:
            interaction_data['instance_script'] = '/static/js/:type:/asyncgameoflife.bundle.js'
            interaction_data['instance_component_name'] = 'AsyncGameOfLife'
        else:
            # interaction_data['game_of_life_buffer'] = game_buffer.id
            interaction_data['instance_script'] = '/static/js/:type:/gameoflife.bundle.js'
            interaction_data['instance_component_name'] = 'GameOfLife'

        interaction.data_json = json.dumps(interaction_data)
        interaction.save()

        return Response(serializers.GameOfLifeSerializer(game, context={'request': request}).data,
                        status=status.HTTP_201_CREATED)
Exemple #59
0
 def get_url(self, obj, view_name, request, format):
     kwargs = {'slug': obj.slug, 'course_slug': obj.course.slug}
     return reverse_lazy(view_name, kwargs=kwargs, request=request, format=format)
Exemple #60
0
def is_post_request(request, response):
    return request.method == "POST"


@ratelimit("def", periods=["1m"], increment=is_post_request)
def admin_login(request):
    show_captcha = getattr(request, "limits", {"def": [0]})["def"][0] >= block_limit

    authentication_form = (
        create_form_subclass_with_recaptcha(AdminLoginForm, recaptcha_client) if show_captcha else AdminLoginForm
    )

    return auth_views.login(request, authentication_form=authentication_form)


@login_required(login_url=reverse_lazy("admin_login"))
@permission_required("portal.view_aggregated_data", raise_exception=True)
def aggregated_data(request):

    tables = []

    table_head = ["Data description", "Value", "More info"]
    table_data = []

    """
    Overall statistics
    """

    table_data.append(
        [
            "Number of users",