Beispiel #1
0
    def testValidSig(self):
        # Construct login request server side
        domain = 'http://testserver/'
        settings.AUTOLOGIN_SERVICES = {'test': domain}
        now = datetime(2011, 1, 1, 1, 12, 00, 100000)
        request_server = LoginRequestServer(self.user.username, 'test', now, KEY)
        redirect = request_server.generate_redirect()
        querystring = urlparse.urlsplit(redirect['location']).query  # pylint: disable=E1103

        # Verify login request client side
        query = QueryDict(querystring)
        request = self.request.copy()
        request.GET = {
            USER_KEY: query.get(USER_KEY),
            DATETIME_KEY: query.get(DATETIME_KEY),
            SIG_KEY: query.get(SIG_KEY),
        }
        request.user = self.user
        session = MagicMock()
        session.flush = lambda: None
        request.session = session
        logout(request)
        self.assertFalse(request.user.is_authenticated())
        login_request = LoginRequestClient(request, now, KEY)
        redirect = login_request.verify()

        # Assert
        self.assertTrue(isinstance(redirect, HttpResponseRedirect))
        self.assertEqual(redirect['location'], settings.LOGIN_REDIRECT_URL)
        self.assertTrue(request.user.is_authenticated())
Beispiel #2
0
def survey_useful_save(request, token):
    vote = db.Query(UsefulVote).filter("token =", token).get()
    querydict = QueryDict(request.POST['ser'])
    #if vote:
    #    raise Exception("Already voted")
    seat_code = querydict.get('seat_code', '')
    seat = db.Query(Seat).filter("code =", seat_code).get()
    ip_address = str(request.META.get('REMOTE_ADDR', 'na'))
    useful = querydict.get('useful', '')
    user_email = querydict.get('email', '')
    if vote:
        if useful:
            vote.ip_address = ip_address
            vote.useful = useful
            vote.seat = seat
        elif user_email:
            vote.email = user_email
    else:
        vote = UsefulVote(
            token = querydict['token'],
            ip_address = ip_address,
            useful = useful,
            seat = seat
            )
    vote.put()
    return render_to_response('survey_autosave_ok.html')
Beispiel #3
0
    def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict(str('vote=yes&vote=no'))

        self.assertEqual(q['vote'], 'no')
        self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')

        self.assertEqual(q.get('vote', 'default'), 'no')
        self.assertEqual(q.get('foo', 'default'), 'default')
        self.assertEqual(q.getlist('vote'), ['yes', 'no'])
        self.assertEqual(q.getlist('foo'), [])

        self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
        self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
        self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])

        if not six.PY3:
            self.assertEqual(q.has_key('vote'), True)
        self.assertEqual('vote' in q, True)
        if not six.PY3:
            self.assertEqual(q.has_key('foo'), False)
        self.assertEqual('foo' in q, False)
        self.assertEqual(list(six.iteritems(q)), [('vote', 'no')])
        self.assertEqual(list(six.iterlists(q)), [('vote', ['yes', 'no'])])
        self.assertEqual(list(six.iterkeys(q)), ['vote'])
        self.assertEqual(list(six.itervalues(q)), ['no'])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
        self.assertRaises(AttributeError, q.pop, 'foo')
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
        self.assertRaises(AttributeError, q.__delitem__, 'vote')
Beispiel #4
0
    def test_multiple_keys(self):
        """Test QueryDict with two key/value pairs with same keys."""

        q = QueryDict(str("vote=yes&vote=no"))

        self.assertEqual(q["vote"], "no")
        self.assertRaises(AttributeError, q.__setitem__, "something", "bar")

        self.assertEqual(q.get("vote", "default"), "no")
        self.assertEqual(q.get("foo", "default"), "default")
        self.assertEqual(q.getlist("vote"), ["yes", "no"])
        self.assertEqual(q.getlist("foo"), [])

        self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
        self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
        self.assertRaises(AttributeError, q.appendlist, "foo", ["bar"])

        if six.PY2:
            self.assertEqual(q.has_key("vote"), True)
        self.assertEqual("vote" in q, True)
        if six.PY2:
            self.assertEqual(q.has_key("foo"), False)
        self.assertEqual("foo" in q, False)
        self.assertEqual(list(six.iteritems(q)), [("vote", "no")])
        self.assertEqual(list(six.iterlists(q)), [("vote", ["yes", "no"])])
        self.assertEqual(list(six.iterkeys(q)), ["vote"])
        self.assertEqual(list(six.itervalues(q)), ["no"])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {"foo": "bar"})
        self.assertRaises(AttributeError, q.pop, "foo")
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, "foo", "bar")
        self.assertRaises(AttributeError, q.__delitem__, "vote")
Beispiel #5
0
def labelize(text, args):
    """
    Create the label and put it in the cache.
    Return an img-tag to retrieve it with a a view.
    """
    qs = QueryDict(args)

    text_size = qs.get('size')
    text_color = qs.get('color')
    text_font = qs.get('font')

    text_class = qs.get('class', "default")


    # resolve transation
    text = unicode(text)

    #if (not text_size and not text_color and not text_font) or (not text_class):
    #    raise Exception("configuration error in labelconfig, cannot labelize '%s'" % text)

    labelconfig = getattr(settings, "XCORE_LABELCONFIG")

    if not text_size:
        text_size = labelconfig[text_class]['size']
    if not text_font:
        text_font = labelconfig[text_class]['font']
    if not text_color:
        text_color = labelconfig[text_class]['color']

    tag, cached, key = handle_rendering(text, text_size, text_font, text_color)
    logger.debug("handling "+_debug_key(key, text) +" cached: "+str(cached))
    return tag
Beispiel #6
0
def shares_root(request):
    # Create a new sharing link
    if request.method == 'PUT':
        # Grab the requested file and check permissions
        put = QueryDict(request.body)
        filename = put.get('path', '')
        artifact = get_object_or_404(Artifact, path=filename.lstrip('/'))

        # Get the current user
        user = get_current_user(request,
                                put.get('token', ''))

        # Anonymous users are not allowed to create shares
        if user.is_anonymous:
            return HttpResponseForbidden()

        # The user should have the right to read the artifact
        if not artifact.is_visible_to(user):
            return HttpResponseForbidden()

        # Create the link
        share = Share(artifact=artifact, user=user)
        share.save()
        return HttpResponse(request.build_absolute_uri(reverse('shares', args=[share.token])),
                            content_type='text/plain')
    else:
        return HttpResponseNotAllowed(['PUT'])
Beispiel #7
0
    def delete(self, *args, **kwargs):
        address = self.kwargs['address']
        params = QueryDict(self.request.body)

        msg = u"The value for '{}' parameter should be 'true' or 'false'"

        destroy = params.get("destroy", "false")
        if destroy not in ["true", "false"]:
            return HttpResponse(msg.format("destroy"), status=400)

        rebalance = params.get("rebalance", "false")
        if rebalance not in ["true", "false"]:
            return HttpResponse(msg.format("rebalance"), status=400)

        no_rebalance = "false" if rebalance == "true" else "true"

        response = requests.delete(
            '{}/docker/node/{}?remove-iaas={}&no-rebalance={}'.format(
                settings.TSURU_HOST, address, destroy, no_rebalance
            ),
            headers=self.authorization
        )

        if response.status_code > 399:
            return HttpResponse(response.text, status=response.status_code)

        return HttpResponse('Node was successfully removed', status=200)
Beispiel #8
0
def detail(request, vulnerability_id):
    #vuln = get_object_or_404(Vulnerability, pk=vulnerability_id)
    #vuln = { "id": '123'}
    #return render(request, 'composer/detail.html', {'vulnerability', vuln})
    if request.method == 'GET':
        try:
            vuln = Vulnerability.objects.get(pk=vulnerability_id)
        except Vulnerability.DoesNotExist:
            raise Http404
        return render(request, 'composer/detail.html', {'vulnerability': vuln})
    elif request.method == 'PUT':
        try:
            vuln = Vulnerability.objects.get(pk=vulnerability_id)
            from django.http import QueryDict
            put = QueryDict(request.body)
            description = put.get('description')

            vuln.description = put.get('description')
            vuln.package = put.get('package')
            vuln.version = put.get('version')
            vuln.save()
            return render(request, 'composer/detail.html', {'vulnerability': vuln})
        except Vulnerability.DoesNotExist:
            raise Http404
    elif request.method == 'DELETE':
        try:
            vuln = Vulnerability.objects.get(pk=vulnerability_id)
            vulnCopy = vuln
            vuln.delete()
            return render(request, 'composer/detail.html', {'vulnerability': vulnCopy})
        except Vulnerability.DoesNotExist:
            raise Http404
Beispiel #9
0
def _get_filter_clauses_from_querydict(qdict: QueryDict):
    filters = {}
    for field in qdict:
        if "__" in field:
            field_name, qualifier = field.split("__", 1)

            if qualifier == "in":
                # If user specifies multiply ins, take intersection
                value = [v.strip() for v in qdict.get(field).split(",")]
                if len(qdict.getlist(field)) > 1:
                    for values in qdict.getlist(field):
                        value = set(value) & {v.strip() for v in values.split(",")}
                    value = list(value)
            elif len(qdict.getlist(field)) > 1:
                raise ValueError("Is does not make sense to have more than 1 value for filter: {}".format(field))
            else:
                value = qdict.get(field)
        else:
            value = list(qdict.getlist(field))
            field += "__in"

        if field in filters:
            # Field has already been filtered with a different qualifier
            filters[field] = list(set(filters[field]) & set(value))
        else:
            filters[field] = value
    return filters
Beispiel #10
0
 def delete(self, *args, **kwargs):
     body = QueryDict(self.request.body)
     province_id = body.get('province_id')
     tag = body.get('tag')
     date = body.get('date')
     ProvinceTag.objects.filter(date=date, tag=tag,
                                province_id=province_id).delete()
     return JsonResponse({'ok': 'ok'})
Beispiel #11
0
def menu(request, cat="0"):
    template = loader.get_template('bshop/in_catalog.html')
    for_cat_menu = Category.objects.all()
    name_ = ''
    for_content = {}

    for i in for_cat_menu:
        # str = i.get_absolute_url()
        if int(cat) == int(i.id):
            name_ = i.name
            for_content = Product.objects.filter(product__category=i.id)
    if not name_:
        return HttpResponseRedirect(reverse_lazy('index'))

    if request.method == 'GET':
        params_ = request.GET
        p = QueryDict('')
        if params_:
            p = params_.copy()
        if 'q' in p:
            # print("Search", request.GET['q'])
            query_string = p.get('q')
            entry_query = get_query(query_string, ['product__name', 'product__description', ])
            for_content = for_content.filter(entry_query)
            query_string = 'Результат поиска - ' + str(p.get('q'))
        else:
            query_string = name_

        f_ispreorder = p.get('ispreorder')
        if f_ispreorder == 'True' or f_ispreorder == 'False':
            for_content = for_content.filter(is_preorder=f_ispreorder)

        if 'sort' in p:
            sort_ = p.get('sort')
            if sort_ == 'PRICEUP':
                for_content = for_content.order_by('cost')
            if sort_ == 'PRICEDOWN':
                for_content = for_content.order_by('-cost')
            if sort_ == 'AVIALABLE':
                for_content = for_content.order_by('is_preorder')

    if not request.user.is_authenticated():
        if 'key' not in request.session:
            request.session['last_date'] = str(datetime.datetime.now())
            request.session.save()
            request.session['key'] = request.session.session_key
        for_cart = CartElement.objects.filter(cart__key=request.session['key'], cart__status=True)
    else:
        for_cart = CartElement.objects.filter(cart__owner__user__username=request.user.username, cart__status=True)
    l = len(for_cart)
    category_ = get_object_or_404(Category, id=cat)
    photos_ = get_list_or_404(Photo, product_in_time__category=category_.id, is_alpha=True)[0:4]

    # photos_ = Photo.objects.all()[0:4]
    context = {'menu': for_cat_menu, 'path': request.path, 'content': for_content, 'name': name_, 'catalog_id': cat,
               'session': request.session, 'cart_length': l, 'summ_in_cart': summ_in_cart(for_cart),
               'query_string': query_string,'photos': photos_, 'p': p, 'sort': Product.by_sort}
    return HttpResponse(template.render(context, request))
Beispiel #12
0
 def test_build_querystring(self):
     item = DiscoveryItem.objects.create(addon=addon_factory(
         type=amo.ADDON_DICT))
     # We do not use `urlencode()` and a string comparison because QueryDict
     # does not preserve ordering.
     q = QueryDict(item.build_querystring())
     assert q.get('utm_source') == 'discovery.addons.mozilla.org'
     assert q.get('utm_medium') == 'firefox-browser'
     assert q.get('utm_content') == 'discopane-entry-link'
     assert q.get('src') == 'api'
def edit_by_id(request, pk):

    if request.user.id:

        if request.method == "UPDATE" or request.method == "PUT":

            put = QueryDict(request.body)
            entry_name = str(put.get('entry_name'))
            city_name = str(put.get('city_name'))
            offset = str(put.get('offset'))

            if entry_name is not "" and city_name is not "" and offset is not "":

                try:
                    entry = UserEntry.objects.get(pk=pk)
                    entry.entry_name = entry_name
                    entry.city_name = city_name
                    entry.gmt_offset_display = put.get('offset')

                    try:
                        entry.full_clean()


                    except ValidationError as e:

                        line = ""
                        for key, value in e.message_dict.items():
                            row = ":".join([key, str(value[0])])
                            if line == "":
                                line = row
                            else:
                                line = "\n".join([line, row])

                        response = {'success': False, 'errors': line}

                        return HttpResponse(simplejson.dumps(response), content_type='application/json', status=400)


                    entry.save()
                    response = {'success': True}
                    return HttpResponse(simplejson.dumps(response), content_type='application/json', status=200)

                except UserEntry.DoesNotExist:

                    response = {'success': False}
                    return HttpResponse(simplejson.dumps(response), content_type='application/json', status=404)


        else:
            response = {'note': "method not allowed"}
            return HttpResponse(simplejson.dumps(response), content_type='application/json', status=405)

    else:
        response = {'note': "unauthorised"}
        return HttpResponse(simplejson.dumps(response), content_type='application/json', status=401)
Beispiel #14
0
    def post(self, request, *args, **kwargs):

        auth_token_1c = request.META.get('HTTP_AUTHORIZATION', False)
        auth_token_server = 'Basic ' + base64.b64encode('User123:password123')

        if auth_token_1c == auth_token_server:

            request_COOKIES = request.COOKIES.get('sessionid', False, )

            if not request_COOKIES == request.session.session_key:
                return HttpResponse('failure', )

        else:
            return HttpResponse('failure', )

        query_string = request.META.get('QUERY_STRING', False, )

        query_string = QueryDict(query_string=query_string, )

        if query_string.get('type', False, ) == 'catalog'\
                and query_string.get('mode', False, ) == 'file'\
                and request.META.get('CONTENT_TYPE', False, ) == 'application/octet-stream':

            filename = query_string.get('filename', False, )

            path = 'storage/{app}/{year}/{month:02d}/{day:02d}/'\
                .format(
                    app='bitrix',
                    year=date.today().year,
                    month=date.today().month,
                    day=date.today().day,
                )

            path_split = path.split('/', )
            path = ''
            for dir in path_split:

                path += '{dir}/'.format(dir=dir, )
                try:
                    os.stat(path, )
                except Exception as e:
                    print e
                    os.mkdir(path, )

            filename = '{filename}.{hour:02d}.{minute:02d}.{ext}'\
                .format(
                    filename=filename.split('.')[0],
                    hour=datetime.now().hour,
                    minute=datetime.now().minute,
                    ext=filename.split('.')[1],
                )
            with open('{path}{filename}'.format(path=path, filename=filename, ), 'w') as outfile:
                outfile.write(request.body)

        return HttpResponse('success', )
Beispiel #15
0
 def delete(self, request, **kwargs):
     if 'wishlist' not in request.session:
         request.session['wishlist'] = {}
     delete = QueryDict(request.body)
     product_id = str(delete.get('product',''))
     product_qnt = int(delete.get('qnt',1))
     if product_id and product_qnt:
         if product_id in request.session['wishlist']:
             del(request.session['wishlist'][product_id])
             request.session.modfied = True
     return self.get(request, **kwargs)
Beispiel #16
0
    def extend_token(self, access_token):
        url = "https://graph.facebook.com/oauth/access_token?client_id=%s&client_secret=%s&grant_type=fb_exchange_token&fb_exchange_token=%s" % (constants.client_id, constants.client_secret, access_token)
        response = requests.get(url)
        qd = QueryDict(response.text)
        access_token = qd.get('access_token')
        expiry_date = qd.get('expires')

        if access_token is not None:
            self.access_token = access_token
            self.save()

        return access_token, expiry_date
def show_external_video(instance,kwargs):
    parsed_url = urlparse(instance.external_url)
    if parsed_url.hostname.count('youtube'):
        BASE_URL = "http://www.youtube.com/embed/"
        query = QueryDict(parsed_url.query).copy()
        if query.get('v',None):
            kwargs.update({'video_url': BASE_URL + query['v'] })
        elif query.get('list',None):
            kwargs.update({'video_url': BASE_URL + "videoseries?list=" + query['list'] })
    elif parsed_url.hostname.count('vimeo'):
        video_id = parsed_url.path.split('/')[-1]
        kwargs.update({'video_url': 'http://player.vimeo.com/video/' + video_id + '?badge=0'})
Beispiel #18
0
	def delete(self, request, *args, **kwargs):

		q = QueryDict(request.body)

		graph_name = q.get('graphname')
		node_name = q.get('nodename')
		parents = q.get('parents')
		parent_rel = json.loads(parents)

		session_id = request.session.session_key

		spec_server.delete_node_specs(session_id, graph_name, node_name, parent_rel)

		return self.render_response({"node":node_name})
Beispiel #19
0
def edit(request, id):
	resto = Resto.objects.get(pk=id)

	if resto is None:
		return HttpResponse(status=404)

	data = QueryDict(request.body)

	longitude = data.get('longitude', resto.location.x)
	lattitude = data.get('lattitude', resto.location.y)

	Resto.objects.filter(pk=id).update(
		name=data.get('name', resto.name),
		type=data.get('type', resto.type),
		kitchen=data.get('kitchen', resto.kitchen),
		location='POINT(%s %s)' % (longitude, lattitude),
		customers=data.get('customers', resto.customers),
		wages=data.get('wages', resto.wages),
		rent=data.get('rent', resto.rent),
		income=data.get('income', resto.income),
		area=data.get('area', resto.area),
		updated=timezone.now()
	)

	return HttpResponse(status=200)
Beispiel #20
0
	def put(self, request):
		"""
		Update password
		"""
		put = QueryDict(request.body)
		
		user = request.user
		
		if user.check_password(put.get('old_password')):
			user.set_password(put.get('new_password'))
			user.save()			
			return Response(status=200)
		else:
			return Response(status=401)
Beispiel #21
0
 def put(request):
     from django.http import QueryDict
     put = QueryDict(request.body)
     response = HttpResponse()
     try:
         updated_task = put.get('task')
         status = put.get('status')
         current_task = Task.objects.get(name=updated_task)
         current_task.status = Status.objects.get(name=status)
         current_task.save()
         response.status_code = 204
     except:
         response.status_code = 500
     return response
Beispiel #22
0
def ws_family(request):
    family_id = request.GET.get('family_id', '')

    # Special case for PUT
    req = None
    if request.method == 'PUT':
        req = QueryDict(request.body)

    if req:
        husband_name = req.get('husband_name', '')
        husband_id = req.get('husband_id', '')
        wife_name = req.get('wife_name', '')
        wife_id = req.get('wife_id', '')
        datecreated = req.get('datecreated', '')
        datecompleted = req.get('datecompleted', '')
        notes = req.get('notes', '')

        # Load tags
        tag_list = req.get('tags', '')
        tags = []
        for tag in tag_list.split(', '):
            if tag != '':
                obj, created = Tag.objects.get_or_create(name=tag)
                tags.append(obj)

    if family_id:
        family = Family.objects.get(id=family_id)

    if request.method == 'PUT':
        # Update family
        if husband_name == '' and wife_name == '':
            response = { 'status': 501, 'message': "Missing husband or wife name" }
        else:
            try:
                family.husband_name = husband_name
                family.husband_id = husband_id
                family.wife_name = wife_name
                family.wife_id = wife_id
                family.notes = notes

                family.tags.clear()
                for tag in tags:
                    family.tags.add(tag)

                family.date_created = datecreated

                family.save()

                response = { 'status': 200 }
            except e:
                response = { 'status': 500, 'message': "Couldn't update family" }

    elif request.method == 'DELETE':
        try:
            family.delete()
            response = { 'status': 200 }
        except e:
            response = { 'status': 500, 'message': "Couldn't delete family" }

    return JsonResponse(response)
Beispiel #23
0
def search_lbl(request):
    if request.POST:
        # translate the query string into a dictionary:
        # e.g. 'numin=0.&numax=100.&...' -> {'numin': 0., 'numax': 100., ...}
        q = QueryDict(request.POST['post_data'])
        numin = q.get('numin')
        if numin: numin=float(numin)
        numax = q.get('numax')
        if numax: numax=float(numax)
        Smin = q.get('Smin')
        if Smin: Smin=float(Smin)

        # The form returns molecule=<molecID> for any checked
        # <molec_name> boxes:
        selected_molecids = q.getlist('molecule')
        selected_molecules = Molecules.objects.filter(
            molecid__in=selected_molecids).values(
                    'molec_name','molec_name_html')

        # here's where the real work is done:
        start = time.time()
        req = make_request(numin, numax, Smin, selected_molecids,
                           output_params = None,
                           output_formats = 'par',
                           compression = None)
        HITRAN.read_db_from_mysql(req,'christian','whatever')
        finish = time.time()
        
        return HttpResponse('Hello Sir!')

    # make the HTML for the molecule checkboxes:
    molec_cb_html_soup = ['<table>\n']
    i = 0
    for molecule in molecules:
        if not i % 4: molec_cb_html_soup.append('<tr>')
        molec_cb_html_soup.append('<td><input type="checkbox"' \
            ' name="molecule" value="%d"/>&nbsp;%s</td>'
            % (molecule['molecid'], molecule['molec_name_html']))
        if i%4 == 3: molec_cb_html_soup.append('</tr>\n')
        i += 1
    molec_cb_html_soup.append('</table>\n')
    molec_cb_html = ''.join(molec_cb_html_soup)

    selected_output_fields = ['nu','S']
    available_output_fields = ['A','g_air','g_self','n_air',
        'delta_air','QN-upper','QN-lower']
    return render_to_response('search_lbl.html',
        {'molec_cb_html': molec_cb_html,
        'available_output_fields': available_output_fields,
        'selected_output_fields': selected_output_fields})
Beispiel #24
0
	def delete(self, request, *args, **kwargs):

		q = QueryDict(request.body)
		graph_name = q.get('graphname')
		node_name = q.get('nodename')
		parent_relations = json.loads(q.get('parents'))
		session_id = request.session.session_key
		if parent_relations:
			parent_nodes = parent_relations.pop(graph_name)
			spec_server.delete_parent_relations(session_id, graph_name, node_name, parent_nodes)
			spec_server.delete_external_relations(session_id, [graph_name, node_name])
		spec_server.delete_child_relations(session_id, graph_name, node_name)
		spec_server.delete_node_specs(session_id, graph_name, node_name)

		return self.render_response({"node":node_name})
Beispiel #25
0
def keyboard_field(value, args=None):
    """
    Format keyboard /command field. 
    """
    qs = QueryDict(args)
    per_line = qs.get('per_line', 1)
    field = qs.get("field", "slug")
    command = qs.get("command")
    convert = lambda element: "/" + command + " " + str(getattr(element, field))
    group = lambda flat, size: [flat[i:i+size] for i in range(0, len(flat), size)]
    grouped = group(value, int(per_line))
    new_list = []
    for line in grouped:
        new_list.append([convert(e) for e in line])     
    return str(new_list).encode('utf-8')
        def receive(self, data):
            """Return IncomingSMS instance from parsed data."""

            data = QueryDict(data).copy()

            sms = mobile.models.IncomingSMS(
                message_id=data.get('MessageSid'),
                country=data.get('FromCountry', None),
                sender=data.get('From'),
                recipient=data.get('To'),
                message=data.get('Body'),
                source=data
            )

            return sms.save()
Beispiel #27
0
	def delete(self, request, *args, **kwargs):

		q = QueryDict(request.body)
		parent_node = q.get('parentnode')
		child_node = q.get('childnode')
		parent_graph = q.get('parentgraph')
		child_graph = q.get('childgraph')
		session_id = request.session.session_key

		if parent_graph != child_graph:
			spec_server.delete_external_relations(session_id, [parent_graph, parent_node])
		else:
			spec_server.delete_parent_relations(session_id, parent_graph, child_node, [parent_node])

		return self.render_response({"child":"child_node"})
Beispiel #28
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict('foo=bar')
        self.assertEqual(q['foo'], 'bar')
        self.assertRaises(KeyError, q.__getitem__, 'bar')
        self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')

        self.assertEqual(q.get('foo', 'default'), 'bar')
        self.assertEqual(q.get('bar', 'default'), 'default')
        self.assertEqual(q.getlist('foo'), ['bar'])
        self.assertEqual(q.getlist('bar'), [])

        self.assertRaises(AttributeError, q.setlist, 'foo', ['bar'])
        self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])

        self.assertTrue(q.has_key('foo'))
        self.assertTrue('foo' in q)
        self.assertFalse(q.has_key('bar'))
        self.assertFalse('bar' in q)

        self.assertEqual(q.items(), [(u'foo', u'bar')])
        self.assertEqual(q.lists(), [(u'foo', [u'bar'])])
        self.assertEqual(q.keys(), ['foo'])
        self.assertEqual(q.values(), ['bar'])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
        self.assertRaises(AttributeError, q.pop, 'foo')
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')

        self.assertEqual(q.urlencode(), 'foo=bar')
Beispiel #29
0
 def delete(self, request, slug):
     params = QueryDict(request.body)
     venue = get_object_or_404(Venue, pk=params.get("venueId"))
     _admin_or_deny(request.user, venue.conference)
     venue.delete()
     messages.success(request, "Venue deleted")
     return HttpResponse()
Beispiel #30
0
    def test_single_key_value(self):
        """Test QueryDict with one key/value pair"""

        q = QueryDict("foo=bar")
        self.assertEqual(q["foo"], "bar")
        self.assertRaises(KeyError, q.__getitem__, "bar")
        self.assertRaises(AttributeError, q.__setitem__, "something", "bar")

        self.assertEqual(q.get("foo", "default"), "bar")
        self.assertEqual(q.get("bar", "default"), "default")
        self.assertEqual(q.getlist("foo"), ["bar"])
        self.assertEqual(q.getlist("bar"), [])

        self.assertRaises(AttributeError, q.setlist, "foo", ["bar"])
        self.assertRaises(AttributeError, q.appendlist, "foo", ["bar"])

        self.assertTrue(q.has_key("foo"))
        self.assertTrue("foo" in q)
        self.assertFalse(q.has_key("bar"))
        self.assertFalse("bar" in q)

        self.assertEqual(q.items(), [(u"foo", u"bar")])
        self.assertEqual(q.lists(), [(u"foo", [u"bar"])])
        self.assertEqual(q.keys(), ["foo"])
        self.assertEqual(q.values(), ["bar"])
        self.assertEqual(len(q), 1)

        self.assertRaises(AttributeError, q.update, {"foo": "bar"})
        self.assertRaises(AttributeError, q.pop, "foo")
        self.assertRaises(AttributeError, q.popitem)
        self.assertRaises(AttributeError, q.clear)
        self.assertRaises(AttributeError, q.setdefault, "foo", "bar")

        self.assertEqual(q.urlencode(), "foo=bar")
Beispiel #31
0
def ipn(request):
    """
    PayPal IPN endpoint (notify_url).
    Used by both PayPal Payments Pro and Payments Standard to confirm transactions.
    http://tinyurl.com/d9vu9d

    PayPal IPN Simulator:
    https://developer.paypal.com/cgi-bin/devscr?cmd=_ipn-link-session
    """
    # TODO: Clean up code so that we don't need to set None here and have a lot
    #       of if checks just to determine if flag is set.
    flag = None
    ipn_obj = None

    # Avoid the RawPostDataException. See original issue for details:
    # https://github.com/spookylukey/django-paypal/issues/79
    if not request.META.get(
            'CONTENT_TYPE',
            '').startswith('application/x-www-form-urlencoded'):
        raise AssertionError(CONTENT_TYPE_ERROR)

    logger.debug("PayPal incoming POST data: %s", request.body)

    # Clean up the data as PayPal sends some weird values such as "N/A"
    # Also, need to cope with custom encoding, which is stored in the body (!).
    # Assuming the tolerant parsing of QueryDict and an ASCII-like encoding,
    # such as windows-1252, latin1 or UTF8, the following will work:
    encoding = request.POST.get('charset', None)

    encoding_missing = encoding is None
    if encoding_missing:
        encoding = DEFAULT_ENCODING

    try:
        data = QueryDict(request.body, encoding=encoding).copy()
    except LookupError:
        warn_untested()
        data = None
        flag = "Invalid form - invalid charset"

    if data is not None:
        if hasattr(PayPalIPN._meta, 'get_fields'):
            date_fields = [
                f.attname for f in PayPalIPN._meta.get_fields()
                if f.__class__.__name__ == 'DateTimeField'
            ]
        else:
            date_fields = [
                f.attname for f, m in PayPalIPN._meta.get_fields_with_model()
                if f.__class__.__name__ == 'DateTimeField'
            ]

        for date_field in date_fields:
            if data.get(date_field) == 'N/A':
                del data[date_field]

        form = PayPalIPNForm(data)
        if form.is_valid():
            try:
                # When commit = False, object is returned without saving to DB.
                ipn_obj = form.save(commit=False)
            except Exception as e:
                flag = "Exception while processing. (%s)" % e
        else:
            formatted_form_errors = [
                "{0}: {1}".format(k, ", ".join(v))
                for k, v in form.errors.items()
            ]
            flag = "Invalid form. ({0})".format(
                ", ".join(formatted_form_errors))

    if ipn_obj is None:
        ipn_obj = PayPalIPN()

    # Set query params and sender's IP address
    ipn_obj.initialize(request)

    if flag is not None:
        # We save errors in the flag field
        ipn_obj.set_flag(flag)
    else:
        # Secrets should only be used over SSL.
        if request.is_secure() and 'secret' in request.GET:
            warn_untested()
            ipn_obj.verify_secret(form, request.GET['secret'])
        else:
            ipn_obj.verify()

    ipn_obj.save()
    ipn_obj.send_signals()

    if encoding_missing:
        # Wait until we have an ID to log warning
        logger.warning("No charset passed with PayPalIPN: %s. Guessing %s",
                       ipn_obj.id, encoding)

    return HttpResponse("OKAY")
Beispiel #32
0
class PhotoListView(FormMixin, ListView):
    template_name = 'photo/list.html'
    form_class = PhotoSearchForm

    def get(self, request, *args, **kwargs):
        # From ProcessFormMixin
        querystr = request.META['QUERY_STRING']
        page_num = 0
        if len(querystr) > 0:
            self.querydict = QueryDict(querystr)
            if 'q' in self.querydict:
                self.form = self.get_form_class()({
                    'search':
                    self.querydict['q'],
                    'page':
                    self.querydict['page'],
                })
            if 'page' in self.querydict:
                page_num = self.querydict['page']
        if not hasattr(self, 'form'):
            self.form = self.get_form(self.get_form_class())

        # From BaseListView
        self.object_list = self.get_queryset()
        context = self.get_context_data(object_list=self.object_list,
                                        form=self.form)
        if 'page_id' in kwargs:
            page_num = kwargs['page_id']
        context['page_num'] = page_num
        return self.render_to_response(context)

    def post(self, request):
        # From ProcessFormMixin
        self.form = self.get_form_class()(request.POST)
        if self.form.is_valid():
            d = self.form.cleaned_data
            if 'search' in d and len(d['search']) > 0:
                url = reverse('photo_search') + '?' + urllib.urlencode(
                    {
                        'q': d['search'],
                        'page': d['page'] if d['page'] else 0,
                    })
            else:
                url = reverse('photo_list', kwargs={'page_id': d['page']})
            return HttpResponseRedirect(url)

        # From BaseListView
        self.object_list = self.get_queryset()
        context = self.get_context_data(object_list=self.object_list,
                                        form=self.form)
        return self.render_to_response(context)

    def get_queryset(self):
        if hasattr(self, 'querydict'):
            search = self.querydict.get('q') if 'q' in self.querydict else ''
            page = int(
                self.querydict.get('page')) if 'page' in self.querydict else 0
            return Photo.search(search, page)
        return Photo.page(
            int(self.kwargs['page_id']
                ) if len(self.kwargs['page_id']) > 0 else 0)
Beispiel #33
0
def buy_stock(request):
    if not request.user.is_authenticated:
        return render(request, 'register.html', {'page_title': 'Register'})
    user = request.user
    user_stock_info = UserStock.objects.get(user_id=user.id)
    user_stock_history = UserStockHistory.objects.get(user_id=user.id)

    request_body = QueryDict(request.body)
    if not request_body.get('symbol') or not request_body.get('stock_number'):
        return JsonResponse({"error": "wrong data"})

    stock_symbol = request_body.get('symbol')
    stock_number = float(request_body.get('stock_number'))
    stock = Stock.objects.get(symbol=stock_symbol)
    stock_cost = stock_number * float(stock.price)
    if request.method == 'POST':
        if (user_stock_info.budget < stock_cost):
            return JsonResponse({"error": "no enough budget"})
        if not user_stock_info.stock_buyied:
            user_stock_info.user_stock_info = []
            user_stock_info.save()
        user_stock = user_stock_info.stock_buyied.all().filter(
            stock_id=stock_symbol)
        if user_stock:
            old_stock_cost = float(user_stock[0].stock_number) * float(
                user_stock[0].stock_price)
            new_stock_cost = stock_number * stock.price
            total_stock_cost = old_stock_cost + new_stock_cost
            total_number = float(user_stock[0].stock_number) + stock_number
            user_stock[0].stock_number = total_number
            user_stock[0].stock_price = total_stock_cost / total_number
            user_stock[0].save()
        else:
            new_stock = StockOperation.objects.create(
                stock=stock,
                stock_number=stock_number,
                stock_price=float(stock.price))
            new_stock.save()
            user_stock_info.stock_buyied.add(new_stock)

        user_stock_info.budget = float(user_stock_info.budget) - stock_cost
        user_stock_info.save()
        # add to history
        stock_history = StockOperationHistory.objects.create(
            stock=stock,
            stock_number=stock_number,
            stock_price=float(stock.price),
            stock_operation=True)
        stock_history.save()
        user_stock_history.stock_operation_history.add(stock_history)
        user_stock_history.save()
        return JsonResponse({'user_budget': user_stock_info.budget})

    if request.method == 'DELETE':
        user_stock = user_stock_info.stock_buyied.all().get(
            stock_id=stock_symbol)
        if float(user_stock.stock_number) < stock_number:
            return JsonResponse({"error": "no enough stock to buy"})
        user_stock.stock_number = float(user_stock.stock_number) - stock_number
        if user_stock.stock_number == 0:
            user_stock_info.stock_buyied.remove(user_stock)
            user_stock.delete()
        else:
            user_stock.save()

        user_stock_info.budget = float(user_stock_info.budget) + stock_cost
        user_stock_info.save()
        # add to history
        stock_history = StockOperationHistory.objects.create(
            stock=stock,
            stock_number=stock_number,
            stock_price=float(stock.price),
            stock_operation=False)
        stock_history.save()
        user_stock_history.stock_operation_history.add(stock_history)
        user_stock_history.save()
        return JsonResponse({'user_budget': user_stock_info.budget})
    def handle(self, *args, **options):
        t0 = time.time()
        raw_trackers = RawTracker.objects.filter(processed=False)
        logger.info('Going to process {} raw tracks'.format(
            raw_trackers.count()))
        for raw_tracker in raw_trackers:
            # Let's verify account:
            try:
                profile = Profile.objects.get(
                    account_id=raw_tracker.account_id)
            except Profile.DoesNotExist:
                # raw_tracker.ip = None
                raw_tracker.wrong_account_id = True
                raw_tracker.processed = True
                raw_tracker.save()
                continue
            parsed_url = urlparse(raw_tracker.url)
            queries = QueryDict(parsed_url.query, mutable=False)
            url = parsed_url.hostname
            page = parsed_url.path
            utm_source = queries.get('utm_source')
            website_url = url.lower()
            website_url = website_url.replace('http://', '').replace(
                'https://', '').replace('www.', '')
            try:
                website = Website.objects.get(website_url=website_url)
            except Website.DoesNotExist:
                # raw_tracker.ip = None
                raw_tracker.website_does_not_exist = True
                raw_tracker.processed = True
                raw_tracker.save()
                continue

            if website.owner != profile.user:
                # raw_tracker.ip = None
                raw_tracker.wrong_owner = True
                raw_tracker.processed = True
                raw_tracker.save()

            referrer_url = None
            referrer_page = None
            if raw_tracker.referrer:
                parsed_referrer = urlparse(raw_tracker.referrer)
                referrer_url = parsed_referrer.hostname
                referrer_page = parsed_referrer.path

            tracker = Tracker.objects.create(
                url=url,
                page=page,
                website=website,
                referrer_url=referrer_url,
                referrer_page=referrer_page,
                timestamp=raw_tracker.timestamp,
                utm_source=utm_source,
            )

            if not raw_tracker.dnt:
                user_agent = parse(raw_tracker.user_agent)
                operating_system = user_agent.os.family
                device_family = user_agent.device.family
                browser = user_agent.browser.family

                if user_agent.is_mobile:
                    type_device = Tracker.MOBILE
                elif user_agent.is_tablet:
                    type_device = Tracker.TABLET
                elif user_agent.is_pc:
                    type_device = Tracker.PC
                elif user_agent.is_bot:
                    type_device = Tracker.BOT
                else:
                    type_device = Tracker.UNKNOWN

                tracker.screen_height = raw_tracker.screen_height
                tracker.screen_width = raw_tracker.screen_width

                tracker.operating_system = operating_system
                tracker.device_family = device_family
                tracker.browser = browser
                tracker.type_device = type_device

                tracker.save()

                if profile.can_geolocation and not user_agent.is_bot:
                    if raw_tracker.ip:
                        geo = GeoIP2()
                        try:
                            location_data = geo.city(raw_tracker.ip)
                            tracker.country = location_data.get(
                                'country_code', '') or ''
                            tracker.region = location_data.get('region',
                                                               '') or ''

                        except:
                            pass
                    # raw_tracker.ip = None

                tracker.save()
            raw_tracker.processed = True
            raw_tracker.save()

        t1 = time.time()
        logger.info('Processed {} logs in {}ms'.format(raw_trackers.count(),
                                                       (t1 - t0) * 1000))
Beispiel #35
0
    def create_from_json(cls, request, data):
        """ This is aimed at data originating from a POST request.

        :param data: Json-formatted information, originating from a javascript installed on
        someone's website.
        """

        # Get the IP address and so the geographical info, if available.
        ip_address = get_client_ip(request) or ''
        user_agent = get_user_agent(request)

        location_data = {}
        # Get location only for non-bots:
        if not user_agent.is_bot:
            if ip_address:
                geo = GeoIP2()
                try:
                    location_data = geo.city(ip_address)
                except GeoIP2Exception:
                    pass

        operating_system = user_agent.os.family
        device_family = user_agent.device.family
        browser = user_agent.browser.family

        if user_agent.is_mobile:
            type_device = cls.MOBILE
        elif user_agent.is_tablet:
            type_device = cls.TABLET
        elif user_agent.is_pc:
            type_device = cls.PC
        elif user_agent.is_bot:
            type_device = cls.BOT
        else:
            type_device = cls.UNKNOWN

        parsed_url = urlparse(data['url']['href'])
        queries = QueryDict(parsed_url.query, mutable=False)

        url = parsed_url.hostname
        page = parsed_url.path
        utm_source = queries.get('utm_source')

        website = None
        website_url = url.lower()
        website_url = website_url.replace('http://', '').replace('https://', '').replace('www.', '')
        if Website.objects.filter(website_url=website_url).exists():
            website = Website.objects.get(website_url=website_url)

        referrer_url = None
        referrer_page = None
        if data.get('referrer'):
            parsed_referrer = urlparse(data['referrer'])
            referrer_url = parsed_referrer.hostname
            referrer_page = parsed_referrer.path

        tracker = cls(
            country=location_data.get('country_code', '') or '',
            region=location_data.get('region', '') or '',
            city=location_data.get('city', '') or '',

            type_device=type_device,

            operating_system=operating_system,
            device_family=device_family,
            browser=browser,

            url=url or '',
            page=page or '',
            utm_source=utm_source,

            website=website,

            screen_width=int(data.get('width', 0)),
            screen_height=int(data.get('height', 0)),
            referrer_url=referrer_url,
            referrer_page=referrer_page,
        )

        return tracker
Beispiel #36
0
def ipn(request, item_check_callable=None):
    """
    PayPal IPN endpoint (notify_url).
    Used by both PayPal Payments Pro and Payments Standard to confirm transactions.
    http://tinyurl.com/d9vu9d
    
    PayPal IPN Simulator:
    https://developer.paypal.com/cgi-bin/devscr?cmd=_ipn-link-session
    """
    #TODO: Clean up code so that we don't need to set None here and have a lot
    #      of if checks just to determine if flag is set.
    flag = None
    ipn_obj = None

    # Clean up the data as PayPal sends some weird values such as "N/A"
    # Also, need to cope with custom encoding, which is stored in the body (!).
    # Assuming the tolerate parsing of QueryDict and an ASCII-like encoding,
    # such as windows-1252, latin1 or UTF8, the following will work:

    encoding = request.POST.get('charset', None)

    if encoding is None:
        flag = "Invalid form - no charset passed, can't decode"
        data = None
    else:
        try:
            data = QueryDict(request.body, encoding=encoding).copy()
        except LookupError:
            data = None
            flag = "Invalid form - invalid charset"

    if data is not None:
        date_fields = ('time_created', 'payment_date', 'next_payment_date',
                       'subscr_date', 'subscr_effective')
        for date_field in date_fields:
            if data.get(date_field) == 'N/A':
                del data[date_field]

        form = PayPalIPNForm(data)
        if form.is_valid():
            try:
                #When commit = False, object is returned without saving to DB.
                ipn_obj = form.save(commit=False)
            except Exception as e:
                flag = "Exception while processing. (%s)" % e
        else:
            flag = "Invalid form. (%s)" % form.errors

    if ipn_obj is None:
        ipn_obj = PayPalIPN()

    #Set query params and sender's IP address
    ipn_obj.initialize(request)

    if flag is not None:
        #We save errors in the flag field
        ipn_obj.set_flag(flag)
    else:
        # Secrets should only be used over SSL.
        if request.is_secure() and 'secret' in request.GET:
            ipn_obj.verify_secret(form, request.GET['secret'])
        else:
            ipn_obj.verify(item_check_callable)

    ipn_obj.save()
    return HttpResponse("OKAY")
Beispiel #37
0
    def _request(cls,
                 url,
                 post_data=None,
                 timeout=REQUEST_TIMEOUT,
                 attempts=REQUEST_ATTEMPTS):
        # change fb__explicitly_shared to fb:explicitly_shared
        if post_data:
            post_data = dict(
                (k.replace('__', ':'), v) for k, v in post_data.items())

        logger.info('requesting url %s with post data %s', url, post_data)
        post_request = (post_data is not None or 'method=post' in url)

        if post_request and facebook_settings.FACEBOOK_READ_ONLY:
            logger.info('running in readonly mode')
            response = dict(id=123456789, setting_read_only=True)
            return response

        # nicely identify ourselves before sending the request
        opener = build_opener()
        opener.addheaders = [('User-agent', 'Open Facebook Python')]

        # get the statsd path to track response times with
        path = urlparse(url).path
        statsd_path = path.replace('.', '_')

        # give it a few shots, connection is buggy at times
        timeout_mp = 0
        while attempts:
            # gradually increase the timeout upon failure
            timeout_mp += 1
            extended_timeout = timeout * timeout_mp
            response_file = None
            encoded_params = encode_params(post_data) if post_data else None
            post_string = (urlencode(encoded_params) if post_data else None)
            try:
                start_statsd('facebook.%s' % statsd_path)

                try:
                    response_file = opener.open(url,
                                                post_string,
                                                timeout=extended_timeout)
                    response = response_file.read().decode('utf8')
                except (HTTPError, ) as e:
                    response_file = e
                    response = response_file.read().decode('utf8')
                    # Facebook sents error codes for many of their flows
                    # we still want the json to allow for proper handling
                    msg_format = 'FB request, error type %s, code %s'
                    logger.warn(msg_format, type(e), getattr(e, 'code', None))
                    # detect if its a server or application error
                    server_error = cls.is_server_error(e, response)
                    if server_error:
                        # trigger a retry
                        raise URLError('Facebook is down %s' % response)
                break
            except (HTTPError, URLError, ssl.SSLError) as e:
                # These are often temporary errors, so we will retry before
                # failing
                error_format = 'Facebook encountered a timeout (%ss) or error %s'
                logger.warn(error_format, extended_timeout, unicode(e))
                attempts -= 1
                if not attempts:
                    # if we have no more attempts actually raise the error
                    error_instance = facebook_exceptions.convert_unreachable_exception(
                        e)
                    error_msg = 'Facebook request failed after several retries, raising error %s'
                    logger.warn(error_msg, error_instance)
                    raise error_instance
            finally:
                if response_file:
                    response_file.close()
                stop_statsd('facebook.%s' % statsd_path)

        # Faceboook response is either
        # Valid json
        # A string which is a querydict (a=b&c=d...etc)
        # A html page stating FB is having trouble (but that shouldnt reach
        # this part of the code)
        try:
            parsed_response = json.loads(response)
            logger.info('facebook send response %s' % parsed_response)
        except Exception as e:
            # using exception because we need to support multiple json libs :S
            parsed_response = QueryDict(response, True)
            logger.info('facebook send response %s' % parsed_response)

        if parsed_response and isinstance(parsed_response, dict):
            # of course we have two different syntaxes
            if parsed_response.get('error'):
                cls.raise_error(parsed_response['error']['type'],
                                parsed_response['error']['message'],
                                parsed_response['error'].get('code'))
            elif parsed_response.get('error_code'):
                cls.raise_error(parsed_response['error_code'],
                                parsed_response['error_msg'])

        return parsed_response
Beispiel #38
0
 def test_immutable_get_with_default(self):
     q = QueryDict()
     self.assertEqual(q.get("foo", "default"), "default")
Beispiel #39
0
    def handle(self, *args, **options):
        logger.info('Starting the processing of raw tracks')
        t0 = time.time()
        total_raw_trackers_analysed = 0
        total_beat_trackers_analysed = 0
        admins_warned = False
        running_time = 0
        while True:
            t1 = time.time()
            raw_trackers = RawTracker.objects.filter(processed=False)
            total_raw_trackers_analysed += raw_trackers.count()
            for raw_tracker in raw_trackers:
                # Let's verify account:
                try:
                    profile = Profile.objects.get(
                        account_id=raw_tracker.account_id)
                except Profile.DoesNotExist:
                    raw_tracker.ip = None
                    raw_tracker.wrong_account_id = True
                    raw_tracker.processed = True
                    raw_tracker.save()
                    continue
                parsed_url = urlparse(raw_tracker.url)
                queries = QueryDict(parsed_url.query, mutable=False)
                website_url = normalize_website(parsed_url.hostname)
                page = parsed_url.path
                if not page:
                    page = '/'

                utm_source = queries.get('utm_source')
                try:
                    website = Website.objects.get(website_url=website_url)
                except Website.DoesNotExist:
                    raw_tracker.ip = None
                    raw_tracker.website_does_not_exist = True
                    raw_tracker.processed = True
                    raw_tracker.save()
                    continue

                if website.owner != profile.user:
                    raw_tracker.ip = None
                    raw_tracker.wrong_owner = True
                    raw_tracker.processed = True
                    raw_tracker.save()

                referrer_url = None
                referrer_page = '/'
                if raw_tracker.referrer:
                    parsed_referrer = urlparse(raw_tracker.referrer)
                    referrer_url = normalize_referrer(
                        normalize_website(parsed_referrer.hostname))
                    if 'google' in referrer_url:
                        referrer_url = 'Google'
                    if 'bing' in referrer_url:
                        referrer_url = 'Bing'
                    referrer_page = parsed_referrer.path

                tracker = Tracker.objects.create(
                    url=website_url,
                    page=page,
                    website=website,
                    referrer_url=referrer_url,
                    referrer_page=referrer_page,
                    timestamp=raw_tracker.timestamp,
                    utm_source=utm_source,
                    raw_tracker=raw_tracker,
                )
                type_device = None

                if not raw_tracker.dnt:
                    try:
                        user_agent = parse(raw_tracker.user_agent)
                    except:
                        logger.error(
                            'Problem parsing user agent Raw Tracker {}'.format(
                                raw_tracker.id))
                        user_agent = None
                        type_device = Tracker.UNKNOWN
                    if user_agent:
                        operating_system = user_agent.os.family
                        device_family = user_agent.device.family
                        browser = user_agent.browser.family

                        if user_agent.is_mobile:
                            type_device = Tracker.MOBILE
                        elif user_agent.is_tablet:
                            type_device = Tracker.TABLET
                        elif user_agent.is_pc:
                            type_device = Tracker.PC
                        elif user_agent.is_bot:
                            type_device = Tracker.BOT
                        else:
                            type_device = Tracker.UNKNOWN

                        tracker.operating_system = operating_system
                        tracker.device_family = device_family
                        tracker.browser = browser
                        tracker.type_device = type_device

                    tracker.screen_height = raw_tracker.screen_height
                    tracker.screen_width = raw_tracker.screen_width
                    tracker.save()

                    if profile.can_geolocation and not type_device == Tracker.BOT:
                        if raw_tracker.ip:
                            geo = GeoIP2()
                            try:
                                location_data = geo.city(raw_tracker.ip)
                                tracker.country = location_data.get(
                                    'country_code', '') or ''
                                tracker.region = location_data.get(
                                    'region', '') or ''
                            except:
                                pass
                    raw_tracker.ip = None

                    tracker.save()
                raw_tracker.processed = True
                raw_tracker.save()

            beats = BeatTracker.objects.filter(processed=False)
            qs = beats.values('raw_tracker').annotate(Count('pk'))
            for beat_tracker in qs:
                try:
                    tracker = Tracker.objects.get(
                        raw_tracker__id=beat_tracker['raw_tracker'])
                    tracker.session_length += 20 * beat_tracker['pk__count']
                    tracker.save()
                    total_beat_trackers_analysed += beat_tracker['pk__count']
                except Tracker.DoesNotExist:
                    logger.warning(
                        f"Processing beat for a non existing tracker: (id: {beat_tracker['raw_tracker']}) "
                    )
            beats.delete()

            t2 = time.time()
            running_time += t2 - t1
            # When it finishes one loop, check for the already available Raw Trackers
            # If there are already more than when it started, it is a problem, we are lagging behind

            new_raw_trackers = RawTracker.objects.filter(
                processed=False).count()

            if new_raw_trackers > raw_trackers.count():
                logger.warning("The raw tracker is lagging behind")
                if not admins_warned:
                    message = """ Dear admin,
                    The raw tracker process task has just analysed {} Raw Tracks in {} seconds but there are already
                    {} new tracks to analyse. The taks is running behind and something has to be done.
                    """.format(raw_trackers.count(), t2 - t1, new_raw_trackers)
                    subject = "[WARNING] Raw tracks processing lagging behind"
                    try:
                        mail_admins(subject, message, fail_silently=False)
                        admins_warned = True
                    except:
                        logger.error('Failed sending warning e-mail to admins')

            if t2 - t0 > 12 * 60 * 60:  # Log the statistics every 12 hours
                logger.info('Processed {} tracks in {}s at a rate of {}tracks/s'\
                        .format(total_raw_trackers_analysed, running_time, total_raw_trackers_analysed/running_time))
                running_time = 0
                total_raw_trackers_analysed = 0
                t0 = time.time()

            if t2 - t1 < 30:
                time.sleep(
                    60 * 30 -
                    (t2 - t1))  # It sleeps for what is left of the 30 minutes
            else:
                logger.error(
                    'Processing the batch takes longer than 30 minutes')
                time.sleep(
                    5
                )  # Only sleep 5 seconds and continue. This is done just to release the CPU.
Beispiel #40
0
def change_tag(tag_name, get_params):
    get_dict = QueryDict(get_params).dict()
    tag_val = get_dict.get(tag_name, DEFAULT_TAG_VALUE)
    tag_val = 1 - int(tag_val)
    get_dict[tag_name] = tag_val
    return urlencode(get_dict)
Beispiel #41
0
def movies(request):
	if request.method == 'GET':	
		queryset = list(MoviesInfo.objects.all().annotate(genre=F('genres__genre'),genre_id=F('genres__id')).\
			extra(select={'release_on':"CONVERT(DATE_FORMAT(CONVERT_TZ(movies_info.release_on,'+00:00','+05:30'),'%%Y-%%m-%%d %%r'), CHAR)"}).\
			values('id','genre_id','popularity','director','imdb_score','name','genre','release_on'))
		return HttpResponse(json.dumps(queryset))
	if request.method == 'POST':
		if has_admin_permission(request.POST.get('user_id')):
			mv_id = request.POST.get('id')
			genre_id = request.POST.get('genre_id')
			
			if mv_id and genre_id:

				mvs = MoviesInfo.objects.get(id = mv_id)
				if request.POST.get('popularity') :
					mvs.popularity = request.POST.get('popularity')
				if request.POST.get('director'):
					mvs.director = request.POST.get('director')
				if request.POST.get('imdb_score'):
					mvs.imdb_score = request.POST.get('imdb_score')
				if request.POST.get('name'):
					mvs.name = request.POST.get('name')
				if request.POST.get('release_on'):
					mvs.release_on = request.POST.get('release_on')
				mvs.admin_id = request.POST.get('user_id')
				
				genre_obj = GenreInfo.objects.get(id = genre_id)
				if request.POST.get('genre'):
					genre_obj.genre = request.POST.get('genre')
				
				mvs.save()
				genre_obj.save()
				return HttpResponse("Details Updated successfully")
			else:
				return HttpResponse("No id and genre_id found")
		else:
			return HttpResponseServerError("Not Authorised")

	if request.method == 'PUT':
		req = QueryDict(request.body)
		if has_admin_permission(req.get('user_id')):
			mv_id = req.get('id')
			genre_id = req.get('genre_id')

			if mv_id and genre_id:

				mvs = MoviesInfo()
				mvs.popularity = req.get('popularity')
				mvs.director = req.get('director')
				mvs.imdb_score = req.get('imdb_score')
				mvs.name = req.get('name')
				mvs.release_on = req.get('release_on')
				mvs.admin_id = req.get('user_id')
				mvs.save()
				
				genre_obj = GenreInfo()
				genre_obj.movie = mvs
				genre_obj.genre = req.get('genre')
				genre_obj.save()
				
				return HttpResponse("Details saved successfully")
			else:
				return HttpResponse("No id and genre_id found")
		else:
			return HttpResponseServerError("Not Authorised")

	if request.method == 'DELETE':
		req = QueryDict(request.body)
		if has_admin_permission(req.get('user_id')):
			mv_id = req.get('id')

			if mv_id :
				mvs = MoviesInfo.objects.get(id = mv_id)
				mvs.delete()
				
				return HttpResponse("Details Deleted successfully")
			else:
				return HttpResponse("No id and genre_id found")
		else:
			return HttpResponseServerError("Not Authorised")
Beispiel #42
0
def get_tag(tag_name, get_params):
    get_dict = QueryDict(get_params).dict()
    return int(get_dict.get(tag_name, DEFAULT_TAG_VALUE))
Beispiel #43
0
def user(request, uid):
    if request.method == "GET":
        try:
            user = User.objects.get(id=uid)
        except Exception as e:
            return render(request, 'users/user_info.html', {
                "user": request.user,
                "errorInfo": "用户不存在,可能已经被删除."
            })
        # 获取用户权限列表
        userGroupList = []
        permList = Permission.objects.filter(codename__startswith="views_")
        userPermList = [u.get('id') for u in user.user_permissions.values()]
        for ds in permList:
            if ds.id in userPermList:
                ds.status = 1
            else:
                ds.status = 0
        # 获取用户组列表
        groupList = Group.objects.all()
        userGroupList = [g.get('id') for g in user.groups.values()]
        for gs in groupList:
            if gs.id in userGroupList:
                gs.status = 1
            else:
                gs.status = 0

        return render(
            request, 'users/user_info.html', {
                "user": request.user,
                "user_info": user,
                "permList": permList,
                "groupList": groupList,
            })

    elif request.method == "POST":
        try:
            user = User.objects.get(id=uid)
            User.objects.filter(id=uid).update(
                is_active=request.POST.get('is_active'),
                is_superuser=int(request.POST.get('is_superuser')),
                email=request.POST.get('email'),
                username=request.POST.get('username'))
            # 如果权限key不存在就单做清除权限
            if request.POST.getlist('perms') is None:
                user.user_permissions.clear()
            else:
                userPermList = []
                for perm in user.user_permissions.values():
                    userPermList.append(perm.get('id'))
                permList = [int(i) for i in request.POST.getlist('perms')]
                addPermList = list(set(permList).difference(set(userPermList)))
                delPermList = list(set(userPermList).difference(set(permList)))
                # 添加新增的权限
                for permId in addPermList:
                    perm = Permission.objects.get(id=permId)
                    User.objects.get(id=uid).user_permissions.add(perm)
                # 删除去掉的权限
                for permId in delPermList:
                    perm = Permission.objects.get(id=permId)
                    User.objects.get(id=uid).user_permissions.remove(perm)
                # 如果用户组key不存在就单做清除用户组
            if request.POST.getlist('groups') is None:
                user.groups.clear()
            else:
                userGroupList = []
                for group in user.groups.values():
                    userGroupList.append(group.get('id'))
                groupList = [int(i) for i in request.POST.getlist('groups')]
                addGroupList = list(
                    set(groupList).difference(set(userGroupList)))
                delGroupList = list(
                    set(userGroupList).difference(set(groupList)))
                # 添加新增的用户组
                for groupId in addGroupList:
                    group = Group.objects.get(id=groupId)
                    user.groups.add(group)
                # 删除去掉的用户组
                for groupId in delGroupList:
                    group = Group.objects.get(id=groupId)
                    user.groups.remove(group)
            return HttpResponseRedirect('/user/{uid}/'.format(uid=uid))
        except Exception as e:
            return render(request, 'users/user_info.html', {
                "user": request.user,
                "errorInfo": "用户资料修改错误:%s" % str(e)
            })

    elif request.method == "PUT" and request.user.is_superuser:
        data = QueryDict(request.body)
        password = data.get('password')
        c_password = data.get('c_password')
        if password == c_password:
            try:
                user = User.objects.get(id=uid)
                user.set_password(password)
                user.save()
                return JsonResponse({
                    "code": 200,
                    "data": None,
                    "msg": "密码修改成功"
                })
            except Exception as e:
                return JsonResponse({
                    "code": 500,
                    "data": None,
                    "msg": "密码修改失败:%s" % str(e)
                })
        else:
            return JsonResponse({
                "code": 500,
                "data": None,
                "msg": "密码不一致,密码修改失败。"
            })
Beispiel #44
0
 def put(self, request, *args, **kwargs):
     put = QueryDict(request.body)
     print(put.get("name"))
     return JsonResponse({"message": "PUT方法"})
Beispiel #45
0
 def put():
     params = QueryDict(request.body)
     sid = int(params.get('sid'))
     num = int(params.get('num'))
     models.SubStockTaking.objects.filter(id=sid).update(num=num)
     return {'data': 'ok'}
Beispiel #46
0
def history(request):

    # Обработка запросов с фронта
    if request.is_ajax():

        # Добавление нового результата
        if request.method == 'POST':
            try:
                # Считывание массива из request
                req_dict = dict(request.POST)
                matrix = []
                for key, value in req_dict.items():
                    arr = re.findall('(.*)\[(\d+)\]\[\]', key)
                    if arr:
                        name = arr[0][0]
                        if name == 'matrix':
                            matrix.append(
                                np.array(value).astype(np.float).tolist())

                # Формирование JSON объекта
                data = {
                    "matrix": matrix,
                    "result": req_dict['result'][0],
                    "created": datetime.now().strftime("%d-%m-%Y %H:%M:%S.%f")
                }

                if 'coeff_history' in request.session:
                    sessionHistory = request.session['coeff_history']
                    sessionHistory.append(data)
                    request.session['coeff_history'] = sessionHistory
                else:
                    request.session['coeff_history'] = [data]

                return JsonResponse({"res": "OK"}, status=200)

            except Exception as e:
                return JsonResponse({"message": str(e)}, status=400)

        # Удаление результата из истории
        elif request.method == 'DELETE':
            try:
                delete = QueryDict(request.body)
                index = int(delete.get('index'))
                sessionHistory = request.session['coeff_history']
                del sessionHistory[index]
                request.session['coeff_history'] = sessionHistory
            except Exception as e:
                return JsonResponse({"message": str(e)}, status=400)

            return JsonResponse({"res": "OK"}, status=200)

    # Вывод текущего списка результатов
    elif request.method == 'GET':

        context = {}

        if 'coeff_history' in request.session:
            context['results'] = request.session['coeff_history']
        else:
            context['results'] = []

        # Обратная сортировка записей по дате создания
        createdReverse = sorted(context['results'],
                                key=lambda x: datetime.strptime(
                                    x['created'], '%d-%m-%Y %H:%M:%S.%f'),
                                reverse=True)

        # Вывод прошедшего времени
        now = datetime.now()
        for i, res in enumerate(createdReverse):
            created = datetime.strptime(res['created'], '%d-%m-%Y %H:%M:%S.%f')
            createdReverse[i]['created'] = timeago.format(created, now, 'ru')

        context['results'] = createdReverse

        return render(request, 'history.html', context)
Beispiel #47
0
 def post(self, request, *args, **kwargs):
     get_data = QueryDict(request.body).dict()
     hostname = get_data.get('hostname')
     cpu = get_data.get('server_cpu')
     memory = get_data.get('server_mem')
     disk = get_data.get('server_disk').split('\"')[1]
     ip = eval(get_data.get('ipinfo'))[0].get('ip')
     mac = eval(get_data.get('ipinfo'))[0].get('mac')
     uuid = get_data.get('uuid')
     server_type = get_data.get('server_type')
     daq = {
         'mac': mac,
         'manufacturers': mac + get_data.get('manufacturers'),
         'st': get_data.get('st'),
         'manufacture_date': get_data.get('manufacture_date'),
         'os': get_data.get('os'),
         'vm_status': get_data.get('vm_status')
     }
     data = {
         'name': hostname,
         'cpu': cpu,
         'memory': memory,
         'disk': disk,
         'ip': ip,
         'uuid': uuid,
         'server_type': server_type,
         'daq': daq
     }
     if Server.objects.filter(uuid=uuid, server_type=server_type):
         Server.objects.filter(uuid=uuid,
                               server_type=server_type).update(**data)
     else:
         Server.objects.create(**data)
     return JsonResponse({})
Beispiel #48
0
def datacenter(request):
    context = {}
    if request.method == 'GET':
        datacenter_name = request.GET.get('datacenter_name', None)
        ops_handler = opsHandler.OpsHandler(request, logger)
        if not datacenter_name:
            context = ops_handler.all_datacenters()
            resp_json = {
                'context': context, 
                'current_permission': json.dumps(request.session.get('current_permissions', {})),
                'user_name': request.session.get('user_name', None),
                'account': request.session.get('user_account', None)
            }
            return render_to_response('sengladmin/datacenter.html', resp_json)
        else:
            context = ops_handler.get_datacenter(datacenter_name)
            return HttpResponse(json.dumps(context), content_type="application/json")
    elif request.method == 'DELETE':
        request_delete = QueryDict(request.body)
        authorize_code = request_delete.get('authorize', None)
        datacenter_name = request_delete.get('datacenter_name', None)
        ops_handler = opsHandler.OpsHandler(request, logger)
        context = ops_handler.remove_datacenter(authorize_code, datacenter_name)
        return HttpResponse(json.dumps(context), content_type="application/json")
    elif request.method == 'PUT':
        request_put = QueryDict(request.body)
        ops_handler = opsHandler.OpsHandler(request, logger)
        context = ops_handler.create_datacenter(
            request_put.get('name', None),
            request_put.get('location', None),
            request_put.get('env', None),
            request_put.get('type', None),
            request_put.get('region', None),
            request_put.get('deploy_region', None),
            request_put.get('deploy_bucket', None),
            request_put.get('qurom_domain', None),
            request_put.get('qurom_port', None),
            request_put.get('qurom_cacert', None),
            request_put.get('qurom_cakey', None),
            request_put.get('agent_version', None),
            request_put.get('agent_file_path', None),
            request_put.get('agent_access_key', None),
            request_put.get('agent_secret_access', None) 
        )
        return HttpResponse(json.dumps(context), content_type="application/json")
    elif request.method == 'POST':
        ops_handler = opsHandler.OpsHandler(request, logger)
        context = ops_handler.modify_datacenter(
            request.POST.get('name', None),
            request.POST.get('location', None),
            request.POST.get('env', None),
            request.POST.get('type', None),
            request.POST.get('region', None),
            request.POST.get('deploy_region', None),
            request.POST.get('deploy_bucket', None),
            request.POST.get('qurom_domain', None),
            request.POST.get('qurom_port', None),
            request.POST.get('qurom_cacert', None),
            request.POST.get('qurom_cakey', None),
            request.POST.get('agent_version', None),
            request.POST.get('agent_file_path', None),
            request.POST.get('agent_access_key', None),
            request.POST.get('agent_secret_access', None)
        )
        return HttpResponse(json.dumps(context), content_type="application/json")
Beispiel #49
0
from django.contrib.auth import authenticate, login, logout
Beispiel #50
0
def schedule_edit(request):
    user = user_get(request)
    request_data = QueryDict(request.body)
    did = request_data.get("id", None)
    if request.method == "GET":
        did = request.GET.get("id")
        if did:
            data = Schedule.objects.get(id=did)
            data.targets = ','.join(eval(data.targets))
            data.rst_notify = eval(data.rst_notify)
        else:
            data = ""
        return render(request, "exec/schedule_edit.html", {"data": data})
    elif request.method == "POST":
        data = {
            'name': request.POST.get("name"),
            'types': request.POST.get("types"),
            'command': request.POST.get("command"),
            'targets': request.POST.get("targets").split(","),
            'desc': request.POST.get("desc"),
            'rst_notify': {
                "mode": request_data.get('rst_notify.mode'),
                'value': request_data.get('rst_notify.value')
            }
        }
        trigger = request.POST.get("trigger")
        if did:
            if trigger == "interval":
                interval = request.POST.get("interval")
                Schedule.objects.filter(id=did).update(trigger=trigger,
                                                       trigger_args=interval,
                                                       **data)
            elif trigger == "date":
                date = request.POST.get("date")
                Schedule.objects.filter(id=did).update(trigger=trigger,
                                                       trigger_args=date,
                                                       **data)
            elif trigger == "cron":
                cron = request.POST.get("cron")
                Schedule.objects.filter(id=did).update(trigger=trigger,
                                                       trigger_args=cron,
                                                       **data)
            obj = Schedule.objects.filter(id=did).first()
            if obj and obj.is_active:
                message = {'id': obj.id, 'action': 'modify'}
                message.update({
                    'trigger': obj.trigger,
                    'trigger_args': obj.trigger_args,
                    'command': obj.command,
                    'targets': obj.targets
                })
                rds_cli = get_redis_connection()
                rds_cli.lpush(settings.SCHEDULE_KEY, json.dumps(message))
            data = {"code": 0, "msg": "类别修改成功~"}
        else:
            if trigger == "interval":
                interval = request.POST.get("interval")
                Schedule.objects.create(created_by=user,
                                        trigger=trigger,
                                        trigger_args=interval,
                                        **data)
            elif trigger == "date":
                date = request.POST.get("date")
                Schedule.objects.create(created_by=user,
                                        trigger=trigger,
                                        trigger_args=date,
                                        **data)
            elif trigger == "cron":
                cron = request.POST.get("cron")
                Schedule.objects.create(created_by=user,
                                        trigger=trigger,
                                        trigger_args=cron,
                                        **data)
            data = {"code": 0, "msg": "任务添加成功~"}
        return JsonResponse(data)

    elif request.method == "DELETE":
        obj = Schedule.objects.filter(id=did).first()
        if obj:
            if obj.is_active:
                data = {"code": 1, "msg": "该任务在运行中,请先停止任务再尝试删除"}
            else:
                Schedule.objects.filter(id=did).update(
                    deleted_at=human_datetime(), deleted_by=user)
                data = {"code": 0, "msg": "任务删除成功"}
            return JsonResponse(data)
    elif request.method == "PUT":
        obj = Schedule.objects.filter(id=did).first()
        if obj:
            if obj.is_active:
                obj.is_active = 0
                obj.save()
                message = {'id': did, 'action': 'remove'}
                data = {"code": 1, "msg": "任务已停止"}
            else:
                message = {'id': did, 'action': 'add'}
                message.update({
                    'trigger': obj.trigger,
                    'trigger_args': obj.trigger_args,
                    'command': obj.command,
                    'targets': obj.targets
                })
                obj.is_active = 1
                obj.save()
                data = {"code": 0, "msg": "任务启动成功"}
            rds_cli = get_redis_connection()
            rds_cli.lpush(settings.SCHEDULE_KEY, json.dumps(message))
            return JsonResponse(data)
Beispiel #51
0
 def delete(self, request):
     data = QueryDict(request.body)
     custom_domain = data.get("custom_domain")
     CustomDomain.objects.filter(domain=custom_domain).delete()
     log.info(F"delete custom domain: {custom_domain} success")
     return JsonResponse({"status": "success"})
Beispiel #52
0
 def subscr_id(self, obj):
     data = QueryDict(obj.query)
     return data.get('subscr_id', None) or data.get('recurring_payment_id',
                                                    None)
Beispiel #53
0
 def test_immutable_get_with_default(self):
     q = QueryDict('')
     self.assertEqual(q.get('foo', 'default'), 'default')
Beispiel #54
0
def paypal_signal(sender, **kwargs):
    if sender.txn_type in ["web_accept", "send_money"]:
        return  # payment from front page
    params = QueryDict(sender.query)
    subscr_id = params.get('subscr_id', None) or params.get(
        'recurring_payment_id', None)
    if sender.txn_type in ['', 'cart', 'subscr_signup']:
        return  # refunds and classes and signups
    if sender.txn_id and Status.objects.filter(transaction_id=sender.txn_id):
        return  # This has already been processed
    subscription = get_subscription(params, sender)
    kwargs['subscription'] = subscription
    user, new_user = get_or_create_student(params)
    urls = "https://txrxlabs.org/admin/ipn/paypalipn/%s/" % sender.pk
    urls += "\n\n%s http://txrxlabs.org/admin/user/user/%s/" % (new_user,
                                                                user.pk)
    if subscription:
        urls += "\n\nhttps://txrxlabs.org/admin/membership/subscription/%s/" % subscription.pk

    if sender.txn_type in ['subscr_cancel']:
        subscription.force_canceled()
        paypal_flag(sender, **kwargs)
        mail_admins("Flagged %s and canceled" % sender.txn_type, urls)
        return

    elif sender.txn_type != "subscr_payment":
        return  # rest of function handles successful membership payment

    if not 'mc_gross' in params:
        mail_admins("Bad IPN", "no mc_gross in txn %s" % sender.txn_id)
        return
    amt = float(params['mc_gross'])
    if not subscription and params.get("item_number", None):
        try:
            subscription = Subscription.objects.get(pk=params['item_number'],
                                                    amount=amt)
        except Subscription.DoesNotExist:
            b = "Could not find subscription #%s for $%s and txn %s" % (
                params['item_number'], amt, sender.txn_id)
            mail_admins("Bad IPN: no subscription", b)
            return
    if not subscription:
        try:
            level = Level.objects.get(name=params.get('option_name1', ''))
        except Level.DoesNotExist:
            b = "Could not find level \"%s\" for txn %s" % (params.get(
                'option_name1', ''), sender.txn_id)
            mail_admins("Bad IPN: no level", b)
            return
        try:
            product = Product.objects.get(unit_price=amt, level=level)
        except Product.DoesNotExist:
            b = "Could not find level product \"%s\" (cost $%s) for txn %s"
            mail_admins("Bad IPN: no product", b % (level, amt, sender.txn_id))
            return
        subscription = Subscription.objects.create(user=user,
                                                   subscr_id=subscr_id,
                                                   level=product.level,
                                                   months=product.months,
                                                   amount=amt)
        Flag.objects.filter(
            subscription__user=subscription.user,
            status__in=Flag.PAYMENT_ACTIONS).update(status="paid")
        if not user.usercriterion_set.filter(
                criterion_id=settings.ORIENTATION_CRITERION_ID):
            # user has never been oriented, send welcome email and create fake safety
            user.send_welcome_email()

    status = Status.objects.create(
        transaction_id=sender.txn_id,
        subscription=subscription,
        paypalipn=sender,
        payment_method='paypal',
        amount=amt,
    )
    if not subscription.subscr_id:
        subscription.subscr_id = subscr_id
        subscription.save()
    # need to get subscription again because status forced it to recalculate
    subscription = status.subscription
    # clear out any subscription flags
    if subscription.owed <= 0:
        Flag.objects.filter(
            subscription=subscription,
            status__in=Flag.PAYMENT_ACTIONS).update(status="paid")
Beispiel #55
0
def email_change_request_handler(request):
    """Handle a request to change the user's email address.

    Args:
        request (HttpRequest)

    Returns:
        HttpResponse: 204 if the confirmation email was sent successfully
        HttpResponse: 302 if not logged in (redirect to login page)
        HttpResponse: 400 if the format of the new email is incorrect
        HttpResponse: 401 if the provided password (in the form) is incorrect
        HttpResponse: 405 if using an unsupported HTTP method
        HttpResponse: 409 if the provided email is already in use
        HttpResponse: 500 if the user to which the email change will be applied
                          does not exist

    Example usage:

        PUT /account/email_change_request

    """
    put = QueryDict(request.body)
    user = request.user
    password = put.get('password')

    username = user.username
    old_email = profile_api.profile_info(username)['email']
    new_email = put.get('new_email')

    if new_email is None:
        return HttpResponseBadRequest("Missing param 'new_email'")
    if password is None:
        return HttpResponseBadRequest("Missing param 'password'")

    try:
        key = account_api.request_email_change(username, new_email, password)
    except account_api.AccountUserNotFound:
        return HttpResponseServerError()
    except account_api.AccountEmailAlreadyExists:
        return HttpResponse(status=409)
    except account_api.AccountEmailInvalid:
        return HttpResponseBadRequest()
    except account_api.AccountNotAuthorized:
        return HttpResponse(status=401)

    context = {
        'key': key,
        'old_email': old_email,
        'new_email': new_email,
    }

    subject = render_to_string(
        'student_account/emails/email_change_request/subject_line.txt',
        context)
    subject = ''.join(subject.splitlines())
    message = render_to_string(
        'student_account/emails/email_change_request/message_body.txt',
        context)

    from_address = microsite.get_value('email_from_address',
                                       settings.DEFAULT_FROM_EMAIL)

    # Email new address
    send_mail(subject, message, from_address, [new_email])

    # A 204 is intended to allow input for actions to take place
    # without causing a change to the user agent's active document view.
    return HttpResponse(status=204)
Beispiel #56
0
def image(request, path, token, autogen=False):

    is_admin = False
    if ("is_admin=true" in token and request
            and request.user.has_perm('admin')) or autogen:
        parameters = token
        is_admin = True
        if autogen:
            token = image_create_token(parameters)
    else:
        parameters = request.session.get(token, token)

    cached_image_file = os.path.join(path, token)

    now = timezone.now()
    expire_offset = timezone.timedelta(seconds=IMAGE_CACHE_HTTP_EXPIRATION)

    response = HttpResponse()
    response['Content-type'] = 'image/jpeg'
    response['Expires'] = (now + expire_offset).strftime("%a, %d %b %Y %T GMT")
    response['Last-Modified'] = now.strftime("%a, %d %b %Y %T GMT")
    response['Cache-Control'] = 'max-age=3600, must-revalidate'
    response.status_code = 200

    # If we already have the cache we send it instead of recreating it
    if IMAGE_CACHE_STORAGE.exists(cached_image_file):

        if autogen:
            return 'Already generated'

        try:
            f = IMAGE_CACHE_STORAGE.open(cached_image_file, "r")
        except IOError:
            raise Http404()
        response.write(f.read())
        f.close()

        response['Last-Modified'] = IMAGE_CACHE_STORAGE.modified_time(
            cached_image_file).strftime("%a, %d %b %Y %T GMT")
        return response

    if parameters == token and not is_admin:
        return HttpResponse("Forbidden", status=403)

    qs = QueryDict(parameters)

    file_storage = MEDIA_STORAGE
    if qs.get('static', '') == "true":
        file_storage = STATIC_STORAGE

    format = qs.get('format', IMAGE_DEFAULT_FORMAT)
    quality = int(qs.get('quality', IMAGE_DEFAULT_QUALITY))
    mask = qs.get('mask', None)
    mask_source = qs.get('mask_source', None)

    if mask is not None:
        format = "PNG"

    fill = qs.get('fill', None)
    background = qs.get('background', None)
    tint = qs.get('tint', None)

    center = qs.get('center', ".5,.5")
    mode = qs.get('mode', "crop")

    overlays = qs.getlist('overlay')
    overlay_sources = qs.getlist('overlay_source')
    overlay_tints = qs.getlist('overlay_tint')
    overlay_sizes = qs.getlist('overlay_size')
    overlay_positions = qs.getlist('overlay_position')

    width = int(qs.get('width', None))
    height = int(qs.get('height', None))
    try:
        padding = float(qs.get('padding', None))
    except TypeError:
        padding = 0.0

    if "video" in qs:
        data, http_response = generate_thumb(file_storage,
                                             smart_unicode(path),
                                             width=width,
                                             height=height)
        response.status_code = http_response
    else:
        try:
            try:
                f = urllib.urlopen(qs['url'])
                data = f.read()
                f.close()
            except KeyError:
                f = file_storage.open(path)
                data = f.read()
                f.close()
        except IOError:
            response.status_code = 404
            data = ""

    if data:
        try:
            if mode == "scale":
                output_data = scale(data,
                                    width,
                                    height,
                                    path,
                                    padding=padding,
                                    overlays=overlays,
                                    overlay_sources=overlay_sources,
                                    overlay_tints=overlay_tints,
                                    overlay_positions=overlay_positions,
                                    overlay_sizes=overlay_sizes,
                                    mask=mask,
                                    mask_source=mask_source,
                                    format=format,
                                    quality=quality,
                                    fill=fill,
                                    background=background,
                                    tint=tint)
            else:
                output_data = scaleAndCrop(data,
                                           width,
                                           height,
                                           path,
                                           True,
                                           padding=padding,
                                           overlays=overlays,
                                           overlay_sources=overlay_sources,
                                           overlay_tints=overlay_tints,
                                           overlay_positions=overlay_positions,
                                           overlay_sizes=overlay_sizes,
                                           mask=mask,
                                           mask_source=mask_source,
                                           center=center,
                                           format=format,
                                           quality=quality,
                                           fill=fill,
                                           background=background,
                                           tint=tint)
        except IOError:
            traceback.print_exc()
            response.status_code = 500
            output_data = ""
    else:
        output_data = data

    if response.status_code == 200:
        IMAGE_CACHE_STORAGE.save(cached_image_file, ContentFile(output_data))
        if autogen:
            return 'Generated ' + str(response.status_code)
    else:
        if autogen:
            return 'Failed ' + cached_image_file

    response.write(output_data)

    return response
Beispiel #57
0
 def post(self, request):
     params = QueryDict(request.body)
     if request.META.get('HTTP_X_FORWARDED_FOR'):
         ip = request.META.get('HTTP_X_FORWARDED_FOR')
     else:
         ip = request.META.get('REMOTE_ADDR')
     if ip in getattr(settings, 'BLOCKED_IPS', []):
         return HttpResponseForbidden('<h1>Forbbidden</h1>')
     user = ShangmiUser.objects.get(
         pk=int(user_cache.get(params.get("token"))))
     order_id = params.get('order_id')
     amount = params.get("need")
     log = UserPayLog.objects.get(id=order_id)
     randuuid = uuid.uuid4()
     nonce_str = str(randuuid).replace('-', '')
     out_trade_no = log.wx_pay_num
     # log.wx_pay_num = out_trade_no
     # log.save()
     url = 'https://api.mch.weixin.qq.com/pay/unifiedorder'
     data = {}
     data['body'] = 'ShangMi'.encode('utf-8')
     data['mch_id'] = settings.MCHID
     data['nonce_str'] = nonce_str
     # data['device_info'] = 'WEB'
     data['total_fee'] = str(int(amount))
     data['spbill_create_ip'] = ip
     # data['fee_type'] = 'CNY'
     data['openid'] = user.openid
     data['out_trade_no'] = out_trade_no
     # data['notify_url'] = 'http://sharemsg.cn:12348/shangmi/api/v1/pay/notify'
     data['notify_url'] = 'https://sharemsg.cn/shangmi/api/v1/pay/notify'
     data['appid'] = settings.PAY_APPID
     data['trade_type'] = 'JSAPI'
     data['sign'] = sign(data, settings.PAY_KEY)
     template = """
                 <xml>
                 <appid>{appid}</appid>
                 <body>{body}</body>
                 <mch_id>{mch_id}</mch_id>
                 <nonce_str>{nonce_str}</nonce_str>
                 <notify_url>{notify_url}</notify_url>
                 <openid>{openid}</openid>
                 <out_trade_no>{out_trade_no}</out_trade_no>
                 <spbill_create_ip>{spbill_create_ip}</spbill_create_ip>
                 <total_fee>{total_fee}</total_fee>
                 <trade_type>{trade_type}</trade_type>
                 <sign>{sign}</sign>
                 </xml>
             """
     content = template.format(**data)
     headers = {'Content-Type': 'application/xml'}
     raw = requests.post(url, data=content, headers=headers)
     rdict = xml_response_to_dict(raw)
     # print('=------',rdict, '--------------')
     return_data = {}
     if rdict['return_code'] == 'SUCCESS' and rdict[
             'result_code'] == 'SUCCESS':
         randuuid = uuid.uuid4()
         nonce_str = str(randuuid).replace('-', '')
         time_stamp = str(int(time.time()))
         sign_data = {}
         sign_data['appId'] = rdict['appid']
         sign_data['nonceStr'] = nonce_str
         sign_data['package'] = 'prepay_id=%s' % rdict['prepay_id']
         sign_data['signType'] = 'MD5'
         sign_data['timeStamp'] = time_stamp
         paySign = sign(sign_data, settings.PAY_KEY)
         return_data['appId'] = rdict['appid']
         return_data['paySign'] = paySign
         return_data['nonceStr'] = nonce_str
         return_data['timeStamp'] = time_stamp
         return_data['package'] = 'prepay_id=%s' % rdict['prepay_id']
         return_data['signType'] = 'MD5'
         return JsonResponse({'data': return_data, "code": 0})
     else:
         return JsonResponse({'code': 1, 'data': u'支付失败'})
Beispiel #58
0
 def put(self, request, *args, **kwargs):
     result = {}
     config = QueryDict(request.body)
     logger.debug("plugin.relation", "in PluginServiceRelation put method params is {}".format(config))
     plugin_id = config.get("plugin_id", None)
     build_version = config.get("build_version", "newest")
     switch = config.get("switch", True)
     switch = plugin_svc.chargeSwtich(switch)
     if not plugin_id or not build_version:
         logger.error("plugin.relation", u'参数错误,plugin_id and version_id')
         data = {"success":False, "code":400, 'msg':u'参数错误'}
         result = oldResultSuitGeneralMessage(data, "params error", "")
         return JsonResponse(result, status=200)
     try:
         body_relation = {}
         body_relation["plugin_id"] = plugin_id
         body_relation["switch"] = switch
         versionList = plugin_svc.get_tenant_plugin_newest_versions(self.response_region, self.tenant, plugin_id)
         if versionList > 0:
             body_relation["version_id"] = versionList[0].build_version
             build_version = versionList[0].build_version
             logger.debug("plugin.relation", "body_relation is {0}, build_version is {1}".format(body_relation, build_version))
         else:
             result["success"] = False
             result["code"] = 404
             result["msg"] = u"未找到插件的最新版本"
             result = oldResultSuitGeneralMessage(result, "cant find newest plugin", "")
             return JsonResponse(result, status=200)
         res, resultBody = region_api.delPluginServiceRelation(
                 self.response_region, self.tenant.tenant_name, plugin_id, self.serviceAlias)
         if res.status == 200:
             pass
         else:
             result["success"] = False
             result["code"] = res.status
             result['msg'] = resultBody
             result = oldResultSuitGeneralMessage(result, "update plugin relation error", "")
             return JsonResponse(result, status=res.status)
         res, resultBody = region_api.pluginServiceRelation(
                 self.response_region, self.tenant.tenant_name, self.serviceAlias, body_relation)
         if res.status == 200:
             plugin_svc.update_service_plugin_relation(self.service.service_id, plugin_id, build_version, switch)
             pass
         else:
             result["success"] = False
             result["code"] = res.status
             result['msg'] = resultBody
             result = oldResultSuitGeneralMessage(result, "update plugin relation error", "")
             return JsonResponse(result, status=res.status)
         complex, normal = plugin_svc.createAttrsJsonForRegion(self.service.service_id, self.serviceAlias, plugin_id)
         config_envs = {}
         config_envs["normal_envs"] = normal
         config_envs["complex_envs"] = complex
         body = {}
         body["tenant_id"] = self.tenant.tenant_id
         body["service_id"] = self.service.service_id
         body["config_envs"] = config_envs
         res, resultBody = region_api.postPluginAttr(self.response_region, self.tenant.tenant_name, self.serviceAlias, plugin_id, body)
         if res.status == 200:
             result["config_group"] = self.useDefaultAttr(plugin_id, build_version, "post")
             result["success"] = True
             result["code"] = 200
             result["msg"] = u"操作成功"
             result["bean"] = {"build_version": model_to_dict(versionList[0])}
             result = general_message(200, "success", u"操作成功", result["bean"], result["config_group"])
             return JsonResponse(result, status=200)
         else:
             result["success"] = False
             result["code"] = res.status
             result['msg'] = resultBody
             result = oldResultSuitGeneralMessage(result, "update plugin relation error",  "")
             return JsonResponse(result, status=200)
     except Exception, e:
         result["success"] = False
         result['code']=500
         result['msg']=u'更新插件关联失败'
         logger.error("plugin.relation", u'更新插件关联失败')
         logger.exception("plugin.relation", e)
         result = oldResultSuitGeneralMessage(result, "update plugin relation error", "")
         return JsonResponse(result, status=200)
Beispiel #59
0
    def post(self, request):
        params = QueryDict(request.body)
        user = util.request_user(request)
        store_id = params.get('store_id')
        config = models.CVSConfig.objects.get(store_id=store_id)
        item_id = int(params.get('item_id'))
        num = int(params.get('num'))
        item = models.Item.objects.get(id=item_id)
        if num <= 0:
            return {'code': 1, 'data': u'请选购商品'}
        amount = num * item.price
        randuuid = uuid.uuid4()
        nonce_str = str(randuuid).replace('-', '')
        if request.META.has_key('HTTP_X_FORWARDED_FOR'):
            ip = request.META.get('HTTP_X_FORWARDED_FOR')
        else:
            ip = request.META.get('REMOTE_ADDR')
        if ip in getattr(settings, 'BLOCKED_IPS', []):
            return HttpResponseForbidden('<h1>Forbbidden</h1>')
        # 创建订单
        url = 'https://api.mch.weixin.qq.com/pay/unifiedorder'
        # random_num = random.randint(100, 999)
        # write_off_code = str(user.id) + str(random_num)
        order = models.Order.objects.create(store_id=store_id,
                                            user=user,
                                            order_time=timezone.now())
        order.save()
        models.OrderItem.objects.create(order=order,
                                        item_id=item_id,
                                        subtotal=amount,
                                        num=num)
        out_trade_no = pay_util.create_mch_billno(str(order.id))
        order.out_trade_no = out_trade_no
        order.save()
        data = {}
        data['body'] = u'便利购'
        data['mch_id'] = config.mch_id
        data['nonce_str'] = nonce_str
        # data['device_info'] = 'WEB'
        data['total_fee'] = str(int(amount * 100))
        data['spbill_create_ip'] = ip
        # data['fee_type'] = 'CNY'
        data['openid'] = user.openid
        data['out_trade_no'] = out_trade_no
        data['notify_url'] = 'http://%s/api/v1/shopplus/notify' % (
            request.get_host())
        data['appid'] = config.appid
        data['trade_type'] = 'JSAPI'
        data['sign'] = pay_util.sign(data, config.pay_api_key)
        template = """
                    <xml>
                    <appid>{appid}</appid>
                    <body>{body}</body>
                    <mch_id>{mch_id}</mch_id>
                    <nonce_str>{nonce_str}</nonce_str>
                    <notify_url>{notify_url}</notify_url>
                    <openid>{openid}</openid>
                    <out_trade_no>{out_trade_no}</out_trade_no>
                    <spbill_create_ip>{spbill_create_ip}</spbill_create_ip>
                    <total_fee>{total_fee}</total_fee>
                    <trade_type>{trade_type}</trade_type>
                    <sign>{sign}</sign>
                    </xml>
                """
        content = template.format(**data)
        headers = {'Content-Type': 'application/xml'}
        raw = requests.post(url, data=content, headers=headers)
        rdict = pay_util.xml_response_to_dict(raw)

        return_data = {}
        if rdict['return_code'] == 'SUCCESS' and rdict[
                'result_code'] == 'SUCCESS':
            randuuid = uuid.uuid4()
            nonce_str = str(randuuid).replace('-', '')
            time_stamp = str(int(time.time()))
            sign_data = {}
            sign_data['appId'] = rdict['appid']
            sign_data['nonceStr'] = nonce_str
            sign_data['package'] = 'prepay_id=%s' % rdict['prepay_id']
            sign_data['signType'] = 'MD5'
            sign_data['timeStamp'] = time_stamp
            paySign = pay_util.sign(sign_data, config.pay_api_key)
            return_data['appId'] = rdict['appid']
            return_data['paySign'] = paySign
            return_data['nonceStr'] = nonce_str
            return_data['timeStamp'] = time_stamp
            return_data['package'] = 'prepay_id=%s' % rdict['prepay_id']
            return_data['signType'] = 'MD5'
            return {'data': return_data}
        else:
            return JsonResponse({'code': 1, 'data': u'支付失败'})
Beispiel #60
0
    def post(self, request, *args, **kwargs):

        auth_token_1c = request.META.get('HTTP_AUTHORIZATION', False)
        auth_token_server = 'Basic '\
                            + base64.b64encode('User123:password123'.encode('ascii')).decode('ascii')

        if auth_token_1c == auth_token_server:

            request_COOKIES = request.COOKIES.get(
                'sessionid',
                False,
            )

            if not request_COOKIES == request.session.session_key:
                return HttpResponse('failure', )

        else:
            return HttpResponse('failure', )

        query_string = request.META.get(
            'QUERY_STRING',
            False,
        )

        query_string = QueryDict(query_string=query_string, )

        if query_string.get('type', False, ) == 'catalog'\
                and query_string.get('mode', False, ) == 'file'\
                and request.META.get('CONTENT_TYPE', False, ) == 'application/octet-stream':

            filename = query_string.get(
                'filename',
                False,
            )

            path = 'storage/{app}/{year}/{month:02d}/{day:02d}/'\
                .format(
                    app='bitrix',
                    year=date.today().year, month=date.today().month, day=date.today().day, )

            path_split = path.split('/', )
            path = ''
            for dir in path_split:

                path += '{dir}/'.format(dir=dir, )
                try:
                    os.stat(path, )
                except Exception as e:
                    print(
                        'bitrix/views.py: 113:',
                        e,
                    )
                    os.mkdir(path, )

            filename = '{filename}.{hour:02d}.{minute:02d}.{ext}'\
                .format(
                    filename=filename.split('.')[0],
                    hour=datetime.now().hour,
                    minute=datetime.now().minute,
                    ext=filename.split('.')[1],
                )
            with open(
                    '{path}{filename}'.format(
                        path=path,
                        filename=filename,
                    ), 'w') as outfile:
                outfile.write(request.body.decode('utf-8'))

        return HttpResponse('success', )