Beispiel #1
0
    def getValues(self, UID):
        """
		Function enables to get values from attributes fields and
		changes.set fields, return the new values (changes.set > attributes)
        """
        try:
            self._backend()
            valuesUser = self.backend.getUserForObject(self.template, UID)
            # Get all attributes from objects:
            attributes = LBEAttributeInstance.objects.filter(lbeObjectTemplate=self.template)
            d = dict()
            for attribute in attributes:
                # Only FINAL Attributes:
                if attribute.attributeType == 0:
                    try:
                        if valuesUser['changes']['set'].has_key(attribute.lbeAttribute.name):
                            q = QueryDict(attribute.lbeAttribute.name + '=' +
                                          valuesUser['changes']['set'][attribute.lbeAttribute.name][0])
                            q = q.copy()
                            for value in valuesUser['changes']['set'][attribute.lbeAttribute.name][1:]:
                                q.update({attribute.lbeAttribute.name: value})
                            d[attribute.lbeAttribute.name] = self._compress_data(q)[attribute.lbeAttribute.name]
                        else:
                            q = QueryDict(attribute.lbeAttribute.name + '=' +
                                          valuesUser['attributes'][attribute.lbeAttribute.name][0])
                            q = q.copy()
                            for value in valuesUser['attributes'][attribute.lbeAttribute.name][1:]:
                                q.update({attribute.lbeAttribute.name: value})
                            d[attribute.lbeAttribute.name] = self._compress_data(q)[attribute.lbeAttribute.name]
                    except BaseException:
                        d[attribute.lbeAttribute.name] = attribute.defaultValue
            return d
        except BaseException:
            # Create part:
            return None
Beispiel #2
0
def _backup_list_context(request, node, context, vm_hostname=None):
    """Helper of returning list of backups including filters"""
    context['filters'] = filter_form = BackupFilterForm(
        request, node, request.GET)
    bkps = node.backup_set.select_related('vm', 'dc')
    qs = QueryDict('', mutable=True)

    if filter_form.is_valid() and filter_form.has_changed():
        q = filter_form.get_filters()

        if q:
            qs = request.GET
            bkps = bkps.filter(q)

            if filter_form.vm:
                dc_switch(request, filter_form.vm.dc.name)

    if filter_form.all_vm:
        qs_novm = qs.copy()
        qs_novm.pop('hostname', None)
        context['node_vm_backup_url'] = reverse('node_backups',
                                                node.hostname,
                                                query_string=qs_novm)
    else:
        qs_nopage = qs.copy()
        qs_nopage.pop('page', None)
        context['qs_nopage'] = qs_nopage.urlencode()

    context['qs'] = qs
    context['vm'] = filter_form.vm
    context['no_vm'] = filter_form.no_vm
    context.update(get_node_backups(request, bkps))

    return context
Beispiel #3
0
def tournament_edit(request, tournament_id):
    tournament = Tournament.objects.get(id=tournament_id)

    # Совершаем проверку на то, пришёл ли запрос после изменения формы
    if request.method == "POST":
        # Если да, то надо передать информацию в БД
        formData = QueryDict.copy(request.POST)

        tournament.tournament_name = formData.get(key="tournament_name")
        tournament.year_held = formData.get(key="year_held")
        tournament.teams_participant.set(
            formData.getlist(key="teams_participant"))
        tournament.country_name = formData.get(key="country_name")
        tournament.is_regular = True if formData.get(
            key="is_regular") == "on" else False

        tournament.save()
        return redirect("tournament_detail", tournament_id)
    else:
        # Если нет, то просто генерируем форму и отправляем для отображения
        # При этом сразу заполним данными, поскольку эта строка точно уже существует
        form = TournamentForm(
            initial={
                "tournament_name": tournament.tournament_name,
                "year_held": tournament.year_held,
                "teams_participant": tournament.teams_participant.all(),
                "country_name": tournament.country_name,
                "is_regular": tournament.is_regular
            })
        return render(request, "sportstats/tournaments/tournament_edit.html", {
            "tournament": tournament,
            "form": form,
            "button_text": "Изменить"
        })
Beispiel #4
0
def add_ssh_user(request):
    request_copy = QueryDict.copy(request.POST)
    host_list = request_copy.popitem()[1]
    add_ssh_user = request.POST.get('add_username')
    add_ssh_password = request.POST.get('add_password')
    print(add_ssh_user, add_ssh_password, host_list)
    host_list_str = ''
    for host in host_list:
        if host_list_str:
            host_list_str = host_list_str + ',' + host
        else:
            host_list_str = host
    ansible = Ansible()
    # 添加ssh账号
    ansible.add_user(host_list_str,
                     username=add_ssh_user,
                     password=add_ssh_password)
    shell_cmd = Shell()
    add_password = '******'%s\'|passwd --stdin %s \" ' % (
        host_list_str, add_ssh_password, add_ssh_user)
    shell_cmd.cmd(add_password)
    create_time = time.strftime('%Y-%m-%d %X', time.localtime())
    models.Ssh_user.objects.create(user=add_ssh_user,
                                   password=add_ssh_password,
                                   host=host_list_str,
                                   create_time=create_time)

    return HttpResponse(json.dumps({'msg': 'success'}))
Beispiel #5
0
def parse_query_string(queryDict: QueryDict, model_name: str) -> NamedTuple(
        'query', pagination=dict, order_by=list, filters=dict, defer=list, search=Q):
    """从请求中解析查询参数

    Args:
        queryDict ([django.http.QueryDict]): 接受request.GET作为参数,
             官方链接:https://docs.djangoproject.com/en/2.2/ref/request-response/#django.http.QueryDict

    Returns:
        NamedTuple: NamedTuple('query', pagination=dict, order_by=list, filters=dict, defer=list)
    """

    _clone = queryDict.copy()

    Query = namedtuple('Query', 'pagination, order_by, filters, defer, search')

    order_by = _clone.pop('order_by', [])
    search_text = _clone.pop('search', [''])[-1]
    search = get_model_search(search_text, model_name)
    pagination = {
        'limit': int(_clone.pop('limit', [10])[-1]),
        'offset': int(_clone.pop('offset', [0])[-1]),
    }

    defer = []
    defer_query = _clone.pop('defer', [])
    for i in defer_query:
        defer.extend(i.split(','))

    filters = _clone.dict()

    query = Query(pagination, order_by, filters, defer, search)
    return query
Beispiel #6
0
 def __init__(self, data: QueryDict, profile: Profile, *args, **kwargs):
     data = data.copy()
     if not data.get("time_range"):
         data["time_range"] = "week"
     if not data.get("sport"):
         data["sport"] = profile.default_sport or Track.SportChoices.BIKING
     super().__init__(data, *args, **kwargs)
 def _get_initial_query_dict(self, qdict):
     if not qdict:
         qdict = QueryDict(None, mutable=True)
     elif isinstance(qdict, QueryDict):
         qdict = qdict.copy()
     elif isinstance(qdict, basestring):
         if qdict.startswith('?'):
             qdict = qdict[1:]
         qdict = QueryDict(qdict, mutable=True)
     else:
         # Accept any old dict or list of pairs.
         try:
             pairs = qdict.items()
         except:
             pairs = qdict
         qdict = QueryDict(None, mutable=True)
         # Enter each pair into QueryDict object:
         try:
             for k, v in pairs:
                 # Convert values to unicode so that detecting
                 # membership works for numbers.
                 if isinstance(v, (list, tuple)):
                     for e in v:
                         qdict.appendlist(k,unicode(e))
                 else:
                     qdict.appendlist(k, unicode(v))
         except:
             # Wrong data structure, qdict remains empty.
             pass
     return qdict
Beispiel #8
0
def create_selection_pack(i_request, i_blank=0):
    a = 4
    a = a * a

    con = get_mdatabase_connection()

    return_pack = Selection_Pack(con)

    if ('POST' == i_request.method):
        return_pack.initialize_data(i_request.POST, i_blank)
    else:
        default_post = QueryDict('')
        default_post = default_post.copy()
        default_post.update({'controller_names': ALL_CONTROLLERS_STRING})
        default_post.update({'access_points': ALL_ACCESS_POINTS_STRING})
        default_post.update({'buildings': ALL_BUILDINGS_STRING})
        default_post.update({'entry_begin': '0'})
        default_post.update({'num_entries': '10000'})

        default_post.update({'loss_low': '0'})
        default_post.update({'loss_high': '100'})
        default_post.update({'retry_low': '0'})
        default_post.update({'retry_high': '100'})
        default_post.update({'thru_low': '0'})
        default_post.update({'thru_high': '100'})
        default_post.update({'beacon_low': '0'})
        default_post.update({'beacon_high': '100'})
        default_post.update({'probe_low': '0'})
        default_post.update({'probe_high': '100'})
        default_post.update({'date_range_low': DEFAULT_BEGINING_TIME})
        default_post.update(
            {'date_range_high': time.strftime('%Y-%m-%d %H:%M:%S')})
        return_pack.initialize_data(default_post, i_blank)

    return return_pack
 def _get_initial_query_dict(self, qdict):
     if not qdict:
         qdict = QueryDict(None, mutable=True)
     elif isinstance(qdict, QueryDict):
         qdict = qdict.copy()
     elif isinstance(qdict, basestring):
         if qdict.startswith('?'):
             qdict = qdict[1:]
         qdict = QueryDict(qdict, mutable=True)
     else:
         # Accept any old dict or list of pairs.
         try:
             pairs = qdict.items()
         except:
             pairs = qdict
         qdict = QueryDict(None, mutable=True)
         # Enter each pair into QueryDict object:
         try:
             for k, v in pairs:
                 # Convert values to unicode so that detecting
                 # membership works for numbers.
                 if isinstance(v, (list, tuple)):
                     for e in v:
                         qdict.appendlist(k, unicode(e))
                 else:
                     qdict.appendlist(k, unicode(v))
         except:
             # Wrong data structure, qdict remains empty.
             pass
     return qdict
Beispiel #10
0
def team_edit(request, team_id):
    team = Team.objects.get(id=team_id)
    if request.method == "POST":
        # Обновляем данные
        formData = QueryDict.copy(request.POST)
        team.team_name = formData.get(key="team_name")
        team.country = formData.get(key="country")
        team.city = formData.get(key="city")

        # Отдельно обрабатываем список с турнирами
        tournaments = formData.getlist(key="tournaments")
        team.tournament_set.set(tournaments)

        # Сохраняем и выходим
        team.save()
        return redirect("team_detail", team_id)
    else:
        form = TeamForm(
            initial={
                "team_name": team.team_name,
                "country": team.country,
                "city": team.city,
            })
        return render(request, "sportstats/teams/team_edit.html", {
            "team": team,
            "form": form,
            "tournaments": Tournament.objects.all()
        })
 def checkPicture(self, request):
     data = QueryDict.copy(request.data)
     if isinstance(data.get("picture"), str):
         if data.get("picture") == 'null':
             data.update({'picture': None})
         else:
             data.pop("picture")
     return data
Beispiel #12
0
def get_form2_dict(request):
    new_dict = {
        "amount": int(round((float(str(request.POST['amount'])) * 100.0)))
    }
    qdict = QueryDict('')
    qdict = qdict.copy()
    qdict.update(new_dict)
    return qdict
Beispiel #13
0
def _change_record_state(query_dict: QueryDict, state: str) -> QueryDict:
    if not state:
        return query_dict
    if 'record_state' in query_dict:
        query_dict = query_dict.copy()  # Don't cause side effects. Also,
        # request.GET is immutable and will raise AttributeError.
        query_dict['record_state'] = state
    return query_dict
Beispiel #14
0
 def put(self, request, pk, format=None):
     user = self.get_object(pk)
     data = QueryDict.copy(request.data)
     serializer = UserFinalSerializerDetailsTeste(user, data=data)
     if serializer.is_valid():
         serializer.save()
         return Response(status=status.HTTP_200_OK)
     return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
Beispiel #15
0
 def is_valid(self):
     if not self.instance.pk:
         self.data = QueryDict.copy(self.data)
         number = self.data.get('number')
         date_fa = self.data.get('date_fa')
         year = date_fa.split('-')[0][2:]
         new_number = int(year) * 10000 + int(number)
         self.data['number'] = new_number
     return super(RequestFrom, self).is_valid()
Beispiel #16
0
def products_dbid(request, dbid):
    """
    Return object with specific ID
    """



    # Get object
    try:
        item = Item.objects.get(dbid = dbid)
    except ObjectDoesNotExist:
        return HttpResponseNotFound("Item not found.")


    # Dealing with PUT
    if request.method == 'PUT':
        if '&' in request.body and '=' in request.body:
            # QueryDict from body directly 
            PUT_DATA = QueryDict(request.body, request.encoding)
        else:
            # QueryDict from Dict, must copy to make mutable    
            PUT_DATA = QueryDict('')
            PUT_DATA = PUT_DATA.copy()
            PUT_DATA.update(ast.literal_eval(request.body))
        
        for field in Item._meta.fields:
            if field.name in PUT_DATA:
                val = PUT_DATA[field.name]
                
                # Convert to Bool for Boolean fields
                if isinstance(field, BooleanField):
                    val = bool(int(val))

                #Convert to Int for Integer fields
                if isinstance(field, IntegerField):
                    val = int(val)

                setattr(item, field.name, val)


        item.save()
    

    # Dealing with DELETE
    if request.method == 'DELETE':
        item = Item.objects.get(dbid = dbid)
        item.delete()
        return HttpResponse("Item deleted.", status=200)


    data = {}
    for field in Item._meta.fields:
        data[field.name] = getattr(item, field.name)

    return HttpResponse(json.dumps(data), content_type='application/json')
Beispiel #17
0
def activitystream(request):
    """OrderedCollectionPage endpoint for a feed stream

    http://www.w3.org/TR/activitystreams-core/#dfn-orderedcollectionpage

    """

    objects = SubscriptionHit.objects.filter(
        notified_users=request.jwt.user
    )

    objs_total = objects.count()

    ret = {
        "@context": "http://www.w3.org/ns/activitystreams",
        "type": "OrderedCollectionPage",
        "totalItems": objs_total
    }

    try:
        after = arrow.get(request.GET.get("after"))
    except arrow.ParserError:
        return JsonResponseBadRequest({
            "error": {"text": "Bad datetime for 'after'",
                      "code": "BAD_DATE"}
        })

    if after:
        paged_objects = objects.filter(created__gte=after.datetime)
    else:
        paged_objects = objects

    page = list(paged_objects[:ACTIVITIES_PER_PAGE+1])

    if len(page) == ACTIVITIES_PER_PAGE+1:
        # there will be at least one object on the page that follows,
        # show pagination
        next_object = page.pop()
        first_params = QueryDict({"jwt": unicode(request.jwt)})
        if request.GET["after"]:
            ret["first"] = request.make_absolute_uri(
                reverse('api-activitystream') + "?" + first_params.urlencode()
            )

        next_params = first_params.copy()
        next_params.update({
            "after": next_object.created.isoformat()
        })
        ret["next"] = request.make_absolute_uri(
            reverse('api-activitystream') + "?" + next_params.urlencode()
        )

    ret["orderedItems"] = [i.hit.get_activitystream() for i in page]

    return JsonResponse(ret)
def get_signin_request(post_dic):
    signin_request = HttpRequest()

    query_dict = QueryDict("")
    query_dict_post = query_dict.copy()  # Make it mutable
    query_dict_get = query_dict.copy()  # Make it mutable

    query_dict_post.update(post_dic)

    signin_request.POST = query_dict_post
    signin_request.GET = query_dict_get

    # Set session (fails without)
    # http://stackoverflow.com/questions/16865947/django-httprequest-object-has-no-attribute-session
    engine = import_module(settings.SESSION_ENGINE)
    session_key = None
    signin_request.session = engine.SessionStore(session_key)

    signin_request.SERVER_NAME = ""

    return signin_request
Beispiel #19
0
 def __init__(self, data=None, *args, **kwargs):
     current_term = Term.objects.get_current()
     # Filter for current term initially or with query parameter term=current
     if current_term is not None:
         if data is None:
             data = QueryDict(mutable=True)
             data["term"] = current_term.slug
         elif data.get("term") == "current":
             data = data.copy()
             data["term"] = current_term.slug
     super().__init__(*args, data=data, **kwargs)
     self.form.fields["term"].initial = current_term
def get_signin_request(post_dic):
    signin_request = HttpRequest()

    query_dict = QueryDict("")
    query_dict_post = query_dict.copy() # Make it mutable
    query_dict_get = query_dict.copy()  # Make it mutable

    query_dict_post.update(post_dic)

    signin_request.POST = query_dict_post
    signin_request.GET = query_dict_get

    # Set session (fails without)
    # http://stackoverflow.com/questions/16865947/django-httprequest-object-has-no-attribute-session
    engine = import_module(settings.SESSION_ENGINE)
    session_key = None
    signin_request.session = engine.SessionStore(session_key)

    signin_request.SERVER_NAME = ""

    return signin_request
Beispiel #21
0
 def test_non_default_encoding(self):
     """#13572 - QueryDict with a non-default encoding"""
     q = QueryDict('cur=%A4', encoding='iso-8859-15')
     self.assertEqual(q.encoding, 'iso-8859-15')
     self.assertEqual(list(q.items()), [('cur', '€')])
     self.assertEqual(q.urlencode(), 'cur=%A4')
     q = q.copy()
     self.assertEqual(q.encoding, 'iso-8859-15')
     self.assertEqual(list(q.items()), [('cur', '€')])
     self.assertEqual(q.urlencode(), 'cur=%A4')
     self.assertEqual(copy.copy(q).encoding, 'iso-8859-15')
     self.assertEqual(copy.deepcopy(q).encoding, 'iso-8859-15')
 def test_valid_form(self):
     query = QueryDict('')
     query = query.copy()
     in_data = copy.deepcopy(self.valid_data)
     select_multi = in_data.pop('select_multi')
     check_multi = in_data.pop('check_multi')
     query.update(in_data)
     query.setlist('select_multi', select_multi)
     query.setlist('check_multi', check_multi)
     bound_form = DummyForm(data=query)
     self.assertTrue(bound_form.is_bound)
     self.assertTrue(bound_form.is_valid())
Beispiel #23
0
 def test_non_default_encoding(self):
     """#13572 - QueryDict with a non-default encoding"""
     q = QueryDict("sbb=one", encoding="rot_13")
     self.assertEqual(q.encoding, "rot_13")
     self.assertEqual(q.items(), [(u"foo", u"bar")])
     self.assertEqual(q.urlencode(), "sbb=one")
     q = q.copy()
     self.assertEqual(q.encoding, "rot_13")
     self.assertEqual(q.items(), [(u"foo", u"bar")])
     self.assertEqual(q.urlencode(), "sbb=one")
     self.assertEqual(copy.copy(q).encoding, "rot_13")
     self.assertEqual(copy.deepcopy(q).encoding, "rot_13")
Beispiel #24
0
 def test_non_default_encoding(self):
     """#13572 - QueryDict with a non-default encoding"""
     q = QueryDict("cur=%A4", encoding="iso-8859-15")
     self.assertEqual(q.encoding, "iso-8859-15")
     self.assertEqual(list(q.items()), [("cur", "€")])
     self.assertEqual(q.urlencode(), "cur=%A4")
     q = q.copy()
     self.assertEqual(q.encoding, "iso-8859-15")
     self.assertEqual(list(q.items()), [("cur", "€")])
     self.assertEqual(q.urlencode(), "cur=%A4")
     self.assertEqual(copy.copy(q).encoding, "iso-8859-15")
     self.assertEqual(copy.deepcopy(q).encoding, "iso-8859-15")
Beispiel #25
0
 def test_non_default_encoding(self):
     """#13572 - QueryDict with a non-default encoding"""
     q = QueryDict(str("cur=%A4"), encoding="iso-8859-15")
     self.assertEqual(q.encoding, "iso-8859-15")
     self.assertEqual(list(six.iteritems(q)), [("cur", "€")])
     self.assertEqual(q.urlencode(), "cur=%A4")
     q = q.copy()
     self.assertEqual(q.encoding, "iso-8859-15")
     self.assertEqual(list(six.iteritems(q)), [("cur", "€")])
     self.assertEqual(q.urlencode(), "cur=%A4")
     self.assertEqual(copy.copy(q).encoding, "iso-8859-15")
     self.assertEqual(copy.deepcopy(q).encoding, "iso-8859-15")
Beispiel #26
0
 def test_non_default_encoding(self):
     """#13572 - QueryDict with a non-default encoding"""
     q = QueryDict('sbb=one', encoding='rot_13')
     self.assertEqual(q.encoding , 'rot_13' )
     self.assertEqual(q.items() , [(u'foo', u'bar')] )
     self.assertEqual(q.urlencode() , 'sbb=one' )
     q = q.copy()
     self.assertEqual(q.encoding , 'rot_13' )
     self.assertEqual(q.items() , [(u'foo', u'bar')] )
     self.assertEqual(q.urlencode() , 'sbb=one' )
     self.assertEqual(copy.copy(q).encoding , 'rot_13' )
     self.assertEqual(copy.deepcopy(q).encoding , 'rot_13')
Beispiel #27
0
 def test_non_default_encoding(self):
     """#13572 - QueryDict with a non-default encoding"""
     q = QueryDict('sbb=one', encoding='rot_13')
     self.assertEqual(q.encoding , 'rot_13' )
     self.assertEqual(q.items() , [(u'foo', u'bar')] )
     self.assertEqual(q.urlencode() , 'sbb=one' )
     q = q.copy()
     self.assertEqual(q.encoding , 'rot_13' )
     self.assertEqual(q.items() , [(u'foo', u'bar')] )
     self.assertEqual(q.urlencode() , 'sbb=one' )
     self.assertEqual(copy.copy(q).encoding , 'rot_13' )
     self.assertEqual(copy.deepcopy(q).encoding , 'rot_13')
Beispiel #28
0
def user_details_complete(strategy, details, user=None, *args, **kwargs):
    """Update user details using data from provider."""
    if user:
        profile = strategy.session_get('profile')
        if profile:
            qdict = QueryDict('')
            qdict = qdict.copy()
            qdict.update(profile)
            form = SocialExtraDataForm(qdict,instance=user)
            if form.is_valid():
                #print form
                form.save()
Beispiel #29
0
 def test_non_default_encoding(self):
     """#13572 - QueryDict with a non-default encoding"""
     q = QueryDict(str('cur=%A4'), encoding='iso-8859-15')
     self.assertEqual(q.encoding, 'iso-8859-15')
     self.assertEqual(list(six.iteritems(q)), [('cur', '€')])
     self.assertEqual(q.urlencode(), 'cur=%A4')
     q = q.copy()
     self.assertEqual(q.encoding, 'iso-8859-15')
     self.assertEqual(list(six.iteritems(q)), [('cur', '€')])
     self.assertEqual(q.urlencode(), 'cur=%A4')
     self.assertEqual(copy.copy(q).encoding, 'iso-8859-15')
     self.assertEqual(copy.deepcopy(q).encoding, 'iso-8859-15')
Beispiel #30
0
 def test_valid_form(self):
     query = QueryDict('')
     query = query.copy()
     in_data = copy.deepcopy(self.valid_data)
     select_multi = in_data.pop('select_multi')
     check_multi = in_data.pop('check_multi')
     query.update(in_data)
     query.setlist('select_multi', select_multi)
     query.setlist('check_multi', check_multi)
     bound_form = DummyForm(data=query)
     self.assertTrue(bound_form.is_bound)
     self.assertTrue(bound_form.is_valid())
Beispiel #31
0
def post_add(request, kwargs):
    assert isinstance(request, HttpRequest)
    result = ResultModel()
    parentid = request.POST.get('parentid', '')
    postdic = QueryDict.copy(request.POST)
    if not parentid:
        postdic['parentid'] = '0'
    type = get_menu_type(parentid)  #根据父菜单设置此子菜单的类型
    postdic['type'] = type
    modelform = SysMenuForm(postdic).save()
    result.msg = '操作成功'
    result.flag = True
    return JsonResponse(result.tojson())
Beispiel #32
0
def render_ordering_arrows(context, column, base_qs):
    qs = QueryDict(base_qs).copy()
    active = False

    if qs.get('order_col') == column:
        if qs.get('order_mode') == 'asc':
            active = 'asc'
        else:
            active = 'desc'

    print active
    qs['order_col'] = column
    qs_asc = qs.copy()
    qs_asc['order_mode'] = 'asc'
    qs_desc = qs.copy()
    qs_desc['order_mode'] = 'desc'

    context.update({'column': column,
                    'active': active,
                    'qs_asc': qs_asc.urlencode(),
                    'qs_desc': qs_desc.urlencode()})
    return context
Beispiel #33
0
def activitystream(request):
    """OrderedCollectionPage endpoint for a feed stream

    http://www.w3.org/TR/activitystreams-core/#dfn-orderedcollectionpage

    """

    objects = SubscriptionHit.objects.filter(notified_users=request.jwt.user)

    objs_total = objects.count()

    ret = {
        "@context": "http://www.w3.org/ns/activitystreams",
        "type": "OrderedCollectionPage",
        "totalItems": objs_total
    }

    try:
        after = arrow.get(request.GET.get("after"))
    except arrow.ParserError:
        return JsonResponseBadRequest({
            "error": {
                "text": "Bad datetime for 'after'",
                "code": "BAD_DATE"
            }
        })

    if after:
        paged_objects = objects.filter(created__gte=after.datetime)
    else:
        paged_objects = objects

    page = list(paged_objects[:ACTIVITIES_PER_PAGE + 1])

    if len(page) == ACTIVITIES_PER_PAGE + 1:
        # there will be at least one object on the page that follows,
        # show pagination
        next_object = page.pop()
        first_params = QueryDict({"jwt": unicode(request.jwt)})
        if request.GET["after"]:
            ret["first"] = request.make_absolute_uri(
                reverse('api-activitystream') + "?" + first_params.urlencode())

        next_params = first_params.copy()
        next_params.update({"after": next_object.created.isoformat()})
        ret["next"] = request.make_absolute_uri(
            reverse('api-activitystream') + "?" + next_params.urlencode())

    ret["orderedItems"] = [i.hit.get_activitystream() for i in page]

    return JsonResponse(ret)
Beispiel #34
0
    def parse_json(self, request):
        """
        Parse request as json data
        :param request: request instance
        :return: processed data
        """
        data = QueryDict('', mutable=True)
        try:
            data.update(json.loads(request.body))
        except json.JSONDecodeError:
            if request.body not in ['', b'', None]:
                data = QueryDict(request.body)

        return data.copy()
Beispiel #35
0
 def __call__(self, request):
     if request.method == 'POST':
         rent_date = request.POST.get('rent_date')
         if rent_date:
             rent_date = datetime.strptime(rent_date,
                                           '%b %d, %Y').strftime('%d.%m.%Y')
             update_dict = QueryDict.copy(request.POST)
             update_dict['rent_date'] = rent_date
             request.POST = update_dict
         response = self._get_response(request)
         return response
     else:
         response = self._get_response(request)
         return response
Beispiel #36
0
    def get_selected_filter_querydict(self):
        """
            Get a querydict with just the selected filters. There may be other
            parameters in self.request.GET, so we want to remove thos
        """

        qd = QueryDict('')
        qd = qd.copy()
        d = {}
        selected_filters = self.get_selected_filter_objects()
        for filter, item in selected_filters:
            d[filter.key] = item
        qd.update(d)
        return qd
Beispiel #37
0
def search_pool_page(request, host_name, page):
    logging.info('Start of search_pool_page()')
    if request.method == 'GET':
        host = get_object_or_404(Host, name=host_name)
        host_settings = get_list_or_404(Setting, hostname=host)
        node_list = parse_node_list(host, host_settings)
        template_dict = {}
        try:
            pg_num = request.GET['pg']
        except:
            pg_num = 1

        # This is quirky, but we don't want to pass the pg=3 parameter back to the search results.
        # It causes, the pager links to append (i.e. ?pg=2&pg=2&pg=2)
        # So we loop through the QueryDict and get rid of the pg=2 parameters.
        fresh = QueryDict('')
        fresh = fresh.copy()
        q = QueryDict(request.META['QUERY_STRING'])
        for key, value in q.iteritems():
            if key != 'pg':
                fresh.update({key: value})
        template_dict['query_string'] = fresh.urlencode()

        # Start the search process
        cat = request.GET['type']
        str = request.GET['search']
        results = Song.objects.filter(title__icontains=str)
        results = results | Song.objects.filter(artist__name__icontains=str)
        results = results | Song.objects.filter(album__name__icontains=str)
        results = results | Song.objects.filter(genre__name__icontains=str)

        #populate the paginator using the search queryset.
        p = get_song_search_pager(results)
        try:
            single_page = p.page(page)
        except EmptyPage, InvalidPage:
            single_page = p.page(p.num_pages)

        #place all the information we gathered into the template dictionary
        template_dict['node_list'] = node_list
        template_dict['active_host'] = host
        template_dict['search'] = True
        template_dict['all_pages'] = p
        template_dict['single_page'] = single_page
        template_dict['pool_page'] = page
        logging.info('End of search_pool_page() with GET')
        return render_to_response('controller/pool_search.html',
                                  template_dict,
                                  context_instance=RequestContext(request))
Beispiel #38
0
def get_dict_from_request(request):
    post_dict = {
        "email": request.POST['id_email'],
        "end_date": datetime.strptime(request.POST['id_end_date'], "%Y-%m-%d"),
        "first_name": request.POST['id_first_name'],
        "last_name": request.POST['id_last_name'],
        "phone": request.POST['id_phone'],
        "start_date": datetime.strptime(request.POST['id_start_date'],
                                        "%Y-%m-%d"),
        "transport_id": request.POST['id_transport_id']
    }
    qdict = QueryDict('')
    qdict = qdict.copy()
    qdict.update(post_dict)
    return qdict
def get_fake_request():
    u = G(User, username='******', password='******')
    setattr(u, 'is_authenticated()', True)
    setattr(u, 'selected_office', False)

    request = RequestFactory().request()
    request.user = u

    querydict = QueryDict('arg2=one')
    querydict = querydict.copy()
    querydict.update({'arg1': 'test', 'arg2': "two"})
    request.GET = querydict
    request.POST = QueryDict('username=random')

    return request
Beispiel #40
0
    def parse_json(self, request):
        """
        Parse request as json data
        :param request: request instance
        :return: processed data
        """
        data = QueryDict('', mutable=True)
        try:
            data.update(json.loads(request.body))
        except Exception as e:  # TODO: NOT THIS, VERY BAD!!!
            # print(f'JSON Parse Error: {e}')
            # print(f'Body: {request.body}')
            if request.body not in ['', b'', None]:
                data = QueryDict(request.body)

        return data.copy()
Beispiel #41
0
        def recreateRequest(self, request):
            reqargs = RequestArgument.objects.filter(request=self)
            onedict = {}
            multidict = QueryDict('', mutable=True)
            for arg in reqargs:
                onedict[arg.name] = arg.value
                multidict.appendlist(arg.name, arg.value)
            if ('format' in getDataFromRequest(request)):
                argname = unicode('format')
                argvalue = getDataFromRequest(request).get('format')
                onedict[argname] = argvalue
                multidict.appendlist(argname, argvalue)
            redata = multidict.copy()
            redata.update(onedict)

            return HttpRequestReplay(request, self.path, onedict)
Beispiel #42
0
        def recreateRequest(self, request):
            reqargs = RequestArgument.objects.filter(request=self)
            onedict = {}
            multidict = QueryDict('', mutable=True)
            for arg in reqargs:
                onedict[arg.name] = arg.value
                multidict.appendlist(arg.name, arg.value)
            if ('format' in getDataFromRequest(request)):
                argname = unicode('format')
                argvalue = getDataFromRequest(request).get('format')
                onedict[argname] = argvalue
                multidict.appendlist(argname, argvalue)
            redata = multidict.copy()
            redata.update(onedict)

            return HttpRequestReplay(request, self.path, onedict)
Beispiel #43
0
def search_pool_page(request, host_name, page):
	logging.info('Start of search_pool_page()')
	if request.method == 'GET':
		host = get_object_or_404(Host, name=host_name)
		host_settings = get_list_or_404(Setting, hostname=host)
		node_list = parse_node_list(host, host_settings)
		template_dict = {}
		try:
			pg_num = request.GET['pg']
		except:
			pg_num=1
		
		# This is quirky, but we don't want to pass the pg=3 parameter back to the search results.
		# It causes, the pager links to append (i.e. ?pg=2&pg=2&pg=2)
		# So we loop through the QueryDict and get rid of the pg=2 parameters.
		fresh = QueryDict('')
		fresh = fresh.copy()
		q = QueryDict(request.META['QUERY_STRING'])
		for key,value in q.iteritems():
			if key != 'pg':
				fresh.update({key : value})
		template_dict['query_string'] = fresh.urlencode()
		
		# Start the search process
		cat = request.GET['type']
		str = request.GET['search']
		results = Song.objects.filter(title__icontains=str)
		results = results | Song.objects.filter(artist__name__icontains=str)
		results = results | Song.objects.filter(album__name__icontains=str)
		results = results | Song.objects.filter(genre__name__icontains=str)

		#populate the paginator using the search queryset.		
		p = get_song_search_pager(results)
		try:
			single_page = p.page(page)
		except EmptyPage, InvalidPage:
			single_page = p.page(p.num_pages)
			
		#place all the information we gathered into the template dictionary
		template_dict['node_list'] = node_list
		template_dict['active_host'] = host
		template_dict['search'] = True
		template_dict['all_pages'] = p
		template_dict['single_page'] = single_page
		template_dict['pool_page'] = page
		logging.info('End of search_pool_page() with GET')
		return render_to_response('controller/pool_search.html', template_dict, context_instance=RequestContext(request))
Beispiel #44
0
class TestReportFilter(WebTest):
    def setUp(self):
        self.request = get_fake_request()
        self.config = G(ReportConfiguration,
                        name='Standard',
                        target_model=ContentType.objects.get_for_model(SimpleDemoModel),
                        report_class='ereports.tests.app.reports.SimpleDemoReport',
                        filtering='',
                        ordering='',
                        groupby='')
        self.querydict = QueryDict('')
        self.querydict = self.querydict.copy()
        self.querydict.update({'_format': 'html',
                               '_report_list_display': 'integer1'})

    def test_get(self):
        response = ReportFilter.as_view()(self.request, pk=self.config.pk)
        self.assertIn('configuration', response.context_data)
        self.assertIn('today', response.context_data)
        self.assertEqual(response.context_data['today'].strftime("%Y-%m-%d"),
                         datetime.datetime.today().strftime("%Y-%m-%d"))

        self.assertIn('user', response.context_data)
        self.assertEqual(response.context_data['user'], self.request.user)

    def test_post_invalid(self):
        self.request.method = 'POST'
        #TODO catch message error value and confirm
        with patch('ereports.views.messages'):
            response = ReportFilter.as_view()(self.request, pk=self.config.pk)
            self.assertIn('form', response.context_data)

    def test_post_valid_no_ds(self):
        self.request.method = 'POST'
        self.request.POST = self.querydict
        #TODO catch message error value and confirm
        with patch('ereports.views.messages'):
            response = ReportFilter.as_view()(self.request, pk=self.config.pk)
            self.assertIn('query', response.context_data)

    def test_post_valid(self):
        self.request.method = 'POST'
        self.request.POST = self.querydict
        G(SimpleDemoModel, char='abc', integer1=10)
        response = ReportFilter.as_view()(self.request, pk=self.config.pk)
        self.assertIn('ereports.engine.report.BaseReport', str(response))
        self.assertIn('Integer #1', str(response))
Beispiel #45
0
def grafico_api(request):
    graph_url = "http://chart.apis.google.com/chart"
    #graph_params = QueryDict("chxt=y&chbh=a&chco=A2C180,3D7930")
    graph_params = QueryDict("")
    graph_params = graph_params.copy() # to make it mutable

    width = request.REQUEST.get('width', '300')
    height = request.REQUEST.get('height', '200')
    graph_params.update({'chs': width + 'x' + height})

    pergunta_slug = request.REQUEST.get('id', None)
    pergunta = get_object_or_404(Pergunta, name=pergunta_slug)

    if pergunta.datatype == 'one':
      total = sum([r[1] for r in pergunta.group_choices()])
      choices = [str(r[1]) for r in pergunta.group_choices()]
      legend = [percentage(r[1],total) + " " + str(r[0]) for r in pergunta.group_choices()]
      graph_params.update({
        'cht': 'p',
        'chd': 't:' + ",".join(choices),
        'chdl': '' + "|".join(legend),
        })
    elif pergunta.datatype == 'many':
      total = sum([r[1] for r in pergunta.group_choices()])
      percent = [str(float(r[1])*100/total) for r in pergunta.group_choices()]
      choices = [str(r[1]) for r in pergunta.group_choices()]
      legend = [str(r[0]) for r in pergunta.group_choices()]
      graph_params.update({
        'cht': 'bvg',
        'chxt': 'y',
        'chd': 't:' + ",".join(percent),
        'chdl': '' + "|".join(legend),
        'chl': '' + "|".join(choices),
        })

    response = {
        "type": "photo",
        "width": width,
        "height": height,
        "title": pergunta.title,
        "url": graph_url + "?" + graph_params.urlencode(),
        "provider_name": "SIGI",
        "provider_url": "https://intranet.interlegis.gov.br/sigi/"
    }

    json = simplejson.dumps(response)
    return HttpResponse(json, mimetype="application/json")
Beispiel #46
0
	def __init__(self, *args, **kwargs):
		"""Accept a 'profile' kwarg that provides default data."""

		profile = kwargs.pop('profile', None)
		if profile:
			today = datetime.date.today()
			post = QueryDict("")
			post = post.copy()
			post.update({
				'location': profile.default_location.pk,
				'lens': profile.default_lens.slug,
				'start': self._parsable_date(today - datetime.timedelta(days=profile.default_recent_days)),
				'end': self._parsable_date(today)
			})
			args = (post,)

		super(SessionFilterForm, self).__init__(*args, **kwargs)
Beispiel #47
0
def mailing_list(request, key=None):    
    if not key:
        raise Http404("Page not found")    
     
    session_key = request.session.pop("key", None) 
    form = request.session.pop("form", None)   
    if  (key and form):       
        qdict = QueryDict('')
        qdict = qdict.copy()
        qdict.update(form)   
        form = MailingListForm(qdict)
        if session_key == key and form.is_valid(): 
          
            object = form.save()
            return render(request, 'mailinglist/mailing_verify.html', {"success":True, "object":object})
        else:
            return render(request, 'mailinglist/mailing_verify.html', {"success":False})       
    return render(request, 'mailinglist/mailing_verify.html', {"success":False})
    def _querydict_from_dict(self, param_dict):
        """ Create a Django QueryDict from a Python dictionary """

        # QueryDict objects are immutable by default, so we make
        # a copy that we can update.
        querydict = QueryDict('')
        copyDict = querydict.copy()

        for (key, val) in param_dict.items():

            # QueryDicts handle lists differently from ordinary values,
            # so we have to specifically tell the QueryDict that
            # this is a list
            if type(val) is list:
                copyDict.setlist(key, val)
            else:
                copyDict[key] = val

        return copyDict
Beispiel #49
0
def create_selection_pack(i_request, i_blank = 0):
	a = 4;
	a = a*a;



	con = get_mdatabase_connection()

	return_pack = Selection_Pack(con)

	if('POST' == i_request.method):
		return_pack.initialize_data(i_request.POST, i_blank)
	else:
		default_post = QueryDict('')
		default_post = default_post.copy()
		default_post.update({'controller_names' : ALL_CONTROLLERS_STRING})
		default_post.update({'access_points' : ALL_ACCESS_POINTS_STRING})
		default_post.update({'buildings' : ALL_BUILDINGS_STRING})
		default_post.update({'entry_begin' : '0'})
		default_post.update({'num_entries' : '10000'})
		
		default_post.update({'loss_low' : '0' })
		default_post.update({'loss_high' : '100' })
		default_post.update({'retry_low' : '0' })
		default_post.update({'retry_high' : '100' })
		default_post.update({'thru_low' : '0' })
		default_post.update({'thru_high' : '100' })
		default_post.update({'beacon_low' : '0' })
		default_post.update({'beacon_high' : '100' })
		default_post.update({'probe_low' : '0' })
		default_post.update({'probe_high' : '100' })
		default_post.update({'date_range_low' : DEFAULT_BEGINING_TIME})
		default_post.update({'date_range_high' : time.strftime('%Y-%m-%d %H:%M:%S')})
		return_pack.initialize_data(default_post, i_blank)
		 
	return return_pack
Beispiel #50
0
 def build_url(self, number, data):
     if number == 1 and data.get('first_page_url'):
         return data['first_page_url']
     url = data.get('url')
     match = url and RE_URL.match(url)
     if match:
         start, end = match.groups()
         return '%s%s%s' % (start, number, end)
     # Add the page as a querystring.
     if 'request' in data:
         querydict = data['request'].GET
     else:
         querydict = QueryDict('')
     qs = querydict.copy()
     if number == 1:
         qs.pop(data['page_var'], None)
     else:
         qs[data['page_var']] = number
     qs = qs.urlencode()
     if qs:
         qs = '?%s' % qs
     if not url and not qs:
         return '.'
     return '%s%s' % (url or '', qs)
Beispiel #51
0
def grafico_api(request):
    colors = [
        "ffff00",
        "cc7900",
        "ff0000",
        "92d050",
        "006600",
        "0097cc",
        "002776",
        "ae78d6",
        "ff00ff",
        "430080",
        "28d75c",
        "0000ff",
        "fff200",
    ]
    graph_url = "http://chart.apis.google.com/chart"
    # graph_params = QueryDict("chxt=y&chbh=a&chco=A2C180,3D7930")
    graph_params = QueryDict("")
    graph_params = graph_params.copy()  # to make it mutable

    width = request.REQUEST.get("width", "800")
    height = request.REQUEST.get("height", "300")
    graph_params.update({"chs": width + "x" + height})

    pergunta_slug = request.REQUEST.get("id", None)
    pergunta = get_object_or_404(Pergunta, name=pergunta_slug)

    if pergunta.datatype == "one":
        total = sum([r[1] for r in pergunta.group_choices()])
        choices = [str(r[1]) for r in pergunta.group_choices()]
        legend = [percentage(r[1], total) + " " + str(r[0]) for r in pergunta.group_choices()]
        colors = ["ff0000", "fff200", "0000ff", "28d75c"] + [
            "%0.6x" % (0x48D1 + (0xDA74 * c)) for c in range(0, len(pergunta.group_choices()))
        ]
        graph_params.update(
            {
                "cht": "p",
                "chd": "t:" + ",".join(choices),
                "chdl": "" + "|".join(legend),
                "chco": "" + "|".join(colors[: len(pergunta.group_choices())]),
            }
        )
    elif pergunta.datatype == "many":
        total = sum([r[1] for r in pergunta.group_choices()])
        percent = [str(float(r[1]) * 100 / total) for r in pergunta.group_choices()]
        choices = [str(r[1]) for r in pergunta.group_choices()]
        legend = [str(r[0]) for r in pergunta.group_choices()]
        colors = [
            "ffff00",
            "cc7900",
            "ff0000",
            "92d050",
            "006600",
            "0097cc",
            "002776",
            "ae78d6",
            "ff00ff",
            "430080",
        ] + ["%0.6x" % (0x48D1 + (0xDA74 * c)) for c in range(0, len(pergunta.group_choices()))]
        graph_params.update(
            {
                "cht": "bvg",
                "chxt": "y",
                "chd": "t:" + ",".join(percent),
                "chdl": "" + "|".join(legend),
                "chl": "" + "|".join(choices),
                "chco": "" + "|".join(colors[: len(pergunta.group_choices())]),
            }
        )

    response = {
        "type": "photo",
        "width": width,
        "height": height,
        "title": pergunta.title,
        "url": graph_url + "?" + graph_params.urlencode(),
        "provider_name": "SIGI",
        "provider_url": "https://intranet.interlegis.gov.br/sigi/",
    }

    json = simplejson.dumps(response)
    return HttpResponse(json, mimetype="application/json")
Beispiel #52
0
def loadnewapps(request):
	countTmpPD = 0
	PostDataTempAll = PostDataTemp.objects.all()
	for pdt in PostDataTempAll:
		countTmpPD = countTmpPD + 1
		postdataT = json.loads(str(pdt.value))
		postdata = QueryDict('')
		postdata = postdata.copy()
		postdata.update(postdataT)
		postdata = postdata
		if postdata:
		    session_key = str(random.randint(0,100000000000000))
		    for key in postdata:
		        """new_record = PostData(key=key, value=postdata[key], session_key=session_key)
		        new_record.save()"""
		    try:
		        email = postdata['EMail'].strip()
		    except:
			email = ""
		    try:
		        first_name = postdata['Imie'].strip()
		    except:
		        first_name = ""
		    try:
		        last_name = postdata['Nazwisko'].strip()
		    except:
		        last_name = ""
		    try:
		        date_from = date(*map(int,reduce(lambda x,y: [y,]+x, postdata['Przyjazd'].split('.'),[])))
		    except:
		        date_from = None
		    try:
		        date_to = date(*map(int,reduce(lambda x,y: [y,]+x, postdata['Odjazd'].split('.'),[])))
		    except:
		        date_to = None
		    users_with_email = User.objects.filter(email=email)
		    username = email if len(email)<30 else email[:30]
		    if users_with_email:
		        username = "******" % (username, users_with_email.count()+1)
		    users=User.objects.filter(first_name=first_name, last_name=last_name)
		    try:
			age = date.today().year - int(postdata['Wiek'])
		    except:
		        age = 0
		    try:
		        city = postdata['Miasto']
		    except:
		        city = ""
		    try:
		        first_time = unicode(postdata['CzyPierwszyRaz'])==unicode('tak')
		    except:
		        first_time = False
		    try:
		        rules_accept = unicode(postdata['AkceptacjaRegulaminu'])==unicode('tak')
		    except:
		        rules_accept = False
		    try:
		        email_accept = unicode(postdata['EmailInformacje'])==unicode('tak')
		    except:
		        email_accept = False
		    try:
		        phone = postdata['Telefon']
		    except:
		        phone=""
		    try:
		        start_time = int(postdata['PrzyjazdGodzina'])
		    except:
		        start_time = None
		    try:
		        end_time = int(postdata['OdjazdGodzina'])
		    except:
		        end_time = None
		    
		    if users:
		        user = users[0]
		    else:
		        user = User(username=username, email=email, first_name=first_name, last_name=last_name)
		        user.save()
		    try:
		        profile = user.get_profile()
		    except:
		        profile = UserProfile(user=user)
		    profile.age = age
		    profile.city = city
		    profile.first_time = first_time
		    profile.phone = phone
		    profile.save()
		    try:
		        sessions = Session.objects.filter(start_date__lte=date_from, end_date__gt=date_from)
		        if not sessions:
		            sessions = Session.objects.filter(start_date__lt=date_to, end_date__gte=date_to)
		        elif len(sessions)>1:
		            sessions.filter(start_date__lt=date_to, end_date__gte=date_to)
		        if sessions:
		            session = sessions[0]
		        else:
		            session = None
		    except:
		        session = None
		    application = UserApplication(user=user, 
		                                  session=session, 
		                                  start_date = date_from, 
		                                  start_time = start_time, 
		                                  end_date = date_to, 
		                                  end_time = end_time, 
		                                  first_time = first_time, 
		                                  rules_accept = rules_accept,
		                                  email_accept = email_accept,
		                                  session_key=session_key)
		    application.save()
		    pdtTemp = PostDataTempArch(value=postdataT)
		    pdtTemp.save()
		    pdt.delete()

	return render_to_response('loadnewapps.html',{'countTmpPD':countTmpPD, 'PostDataTempAll':PostDataTempAll})
Beispiel #53
0
def search_index(request, invalid_subscribe_to_alert_form=None):
    # Make the query string keys lowercase using a redirect.
    if any([k.lower() != k for k in request.GET.keys()]):
        new_GET = {}
        for key in request.GET.keys():
            new_GET[key.lower()] = request.GET[key]
        return HttpResponseRedirect(reverse(search_index) + '?' + mysite.base.unicode_sanity.urlencode(new_GET))

    if request.user.is_authenticated():
        person = request.user.get_profile()
        suggestion_keys = person.get_recommended_search_terms()
    else:
        suggestion_keys = []

    suggestions = [(i, k, False) for i, k in enumerate(suggestion_keys)]

    format = request.GET.get('format', None)
    start = int(request.GET.get('start', 1))
    end = int(request.GET.get('end', 10))

    total_bug_count = 0

    query = mysite.search.view_helpers.Query.create_from_GET_data(request.GET)

    if query:
        bugs = query.get_bugs_unordered()

        # Sort
        bugs = mysite.search.view_helpers.order_bugs(bugs)

        total_bug_count = bugs.count()

        bugs = bugs[start - 1:end]

    else:
        bugs = []

    data = {}
    data['query'] = query

    prev_page_query_str = QueryDict('')
    prev_page_query_str = prev_page_query_str.copy()
    next_page_query_str = QueryDict('')
    next_page_query_str = next_page_query_str.copy()
    if query:
        prev_page_query_str['q'] = query.terms_string
        next_page_query_str['q'] = query.terms_string
    if format:
        prev_page_query_str['format'] = format
        next_page_query_str['format'] = format
    for facet_name, selected_option in query.active_facet_options.items():
        prev_page_query_str[facet_name] = selected_option
        next_page_query_str[facet_name] = selected_option
    for facet_name in query.any_facet_options:
        prev_page_query_str[facet_name] = ''
        next_page_query_str[facet_name] = ''
    diff = end - start
    prev_page_query_str['start'] = start - diff - 1
    prev_page_query_str['end'] = start - 1
    next_page_query_str['start'] = end + 1
    next_page_query_str['end'] = end + diff + 1

    data['start'] = start
    data['end'] = min(end, total_bug_count)
    data['prev_page_url'] = '/search/?' + prev_page_query_str.urlencode()
    data['next_page_url'] = '/search/?' + next_page_query_str.urlencode()
    data['this_page_query_str'] = mysite.base.unicode_sanity.urlencode(
        request.GET)

    is_this_page_1 = (start <= 1)
    is_this_the_last_page = (end >= (total_bug_count - 1))
    data['show_prev_page_link'] = not is_this_page_1
    data['show_next_page_link'] = not is_this_the_last_page

    if request.GET.get('confirm_email_alert_signup', ''):
        data['confirm_email_alert_signup'] = 1

    # If this the last page of results, display a form allowing user to
    # subscribe to a Volunteer Opportunity search alert
    if query and is_this_the_last_page:
        if invalid_subscribe_to_alert_form:
            alert_form = invalid_subscribe_to_alert_form
        else:
            initial = {
                'query_string': request.META['QUERY_STRING'],
                'how_many_bugs_at_time_of_request': len(bugs)
            }
            if request.user.is_authenticated():
                initial['email'] = request.user.email
            alert_form = mysite.search.forms.BugAlertSubscriptionForm(
                initial=initial)
        data['subscribe_to_alert_form'] = alert_form

    # FIXME
    # The template has no way of grabbing what URLs to put in the [x]
    # So we help it out here by hacking around our fruity list-of-dicts
    # data structure.
    facet2any_query_string = {}
    for facet in query.active_facet_options:
        facet2any_query_string[facet] = query.get_facet_options(
            facet, [''])[0]['query_string']

    Bug = mysite.search.models.Bug
    from django.db.models import Q, Count
    data['popular_projects'] = list(Project.objects.filter(
        name__in=['Miro', 'GnuCash', 'brasero', 'Evolution Exchange', 'songbird']).order_by('name').reverse())
    data['all_projects'] = Project.objects.values('pk', 'name').filter(
        bug__looks_closed=False).annotate(Count('bug')).order_by('name')

    Person = mysite.profile.models.Person
    import random
    random_start = int(random.random() * 700)
    data['contributors'] = Person.objects.all()[random_start:random_start + 5]
    data['contributors2'] = Person.objects.all(
    )[random_start + 10:random_start + 15]
    data['languages'] = Project.objects.all().values_list(
        'language', flat=True).order_by('language').exclude(language='').distinct()[:4]

    if format == 'json':
        # FIXME: Why `alert`?
        return bugs_to_json_response(data, bugs, request.GET.get(
            'jsoncallback', 'alert'))
    else:
        data['user'] = request.user
        data['suggestions'] = suggestions
        data['bunch_of_bugs'] = bugs
        data['url'] = 'http://launchpad.net/'
        data['total_bug_count'] = total_bug_count
        data['facet2any_query_string'] = facet2any_query_string
        data['project_count'] = mysite.search.view_helpers.get_project_count()

        return mysite.base.decorators.as_view(request, 'search/search.html', data, slug=None)
    def test_hash_request(self):
        # Requests with the same parameters should hash to the same values,
        # regardless of HTTP method.
        target_qd = QueryDict('&target=randomWalk(%27random%20walk%27)'
                       '&target=randomWalk(%27random%20walk2%27)'
                       '&target=randomWalk(%27random%20walk3%27)')
        empty_qd = QueryDict('')
        post_request = HttpRequest()
        post_request.POST = target_qd.copy()
        post_request.GET = empty_qd.copy()
        get_request = HttpRequest()
        get_request.GET = target_qd.copy()
        get_request.POST = empty_qd.copy()

        self.assertEqual(hashRequest(get_request), hashRequest(post_request))

        # Check that POST parameters are included in cache key calculations
        post_request_with_params = HttpRequest()
        post_request_with_params.GET = empty_qd.copy()
        post_request_with_params.POST = target_qd.copy()
        empty_post_request = HttpRequest()
        empty_post_request.GET = empty_qd.copy()
        empty_post_request.POST = empty_qd.copy()

        self.assertNotEqual(hashRequest(post_request_with_params),
                            hashRequest(empty_post_request))

        # Check that changing the order of the parameters has no impact on the
        # cache key
        request_params = HttpRequest()
        request_qd = QueryDict('&foo=1&bar=2')
        request_params.GET = request_qd.copy()
        request_params.POST = empty_qd.copy()

        reverse_request_params = HttpRequest()
        reverse_request_qd = QueryDict('&bar=2&foo=1')
        reverse_request_params.GET = reverse_request_qd.copy()
        reverse_request_params.POST = empty_qd.copy()

        self.assertEqual(hashRequest(request_params),
                        hashRequest(reverse_request_params))
Beispiel #55
0
    def get_queryset(self):

        # estado Top Buttons
        btn_filter = self.kwargs['estado']
        if btn_filter == 'todos':
            qs = self.model.objects.filter(estado='A')
        elif btn_filter == 'eliminado':
            qs = self.model.objects.filter(estado='E')
        elif btn_filter == 'urgente':
            qs = self.model.objects.filter(estado='A')
            qs = qs.filter(prioridad='U')
            qs = qs.exclude(etapa='COM')
        elif btn_filter == 'retrasado':
            qs = self.model.objects.filter(estado='A')
            qs_ids = [o.id for o in qs if o.is_analisis_retraso()]
            qs = qs.filter(id__in=qs_ids)
            qs = qs.exclude(etapa='COM')
        elif btn_filter == 'trabsoc':
            qs = self.model.objects.filter(estado='A')
            qs_ids = [o.id for o in qs if o.is_analisis_retraso()]
            qs = qs.filter(Q(etapa='NTS') | Q(id__in=qs_ids))
        elif btn_filter == 'notif':
            qs = self.model.objects.filter(estado='A')
            qs_ids = [o.id for o in qs if o.is_analisis_retraso()]
            qs = qs.filter(Q(etapa='NOT') | Q(id__in=qs_ids))
        elif btn_filter == 'completado':
            qs = self.model.objects.filter(estado='A')
            qs = qs.filter(etapa='COM')
        else:
            qs = self.model.objects.all()

        # formFechaIr
        fechaIr = self.get_session('fechaIr')
        dict = {
            'fechaIr': fechaIr,
        }
        qdict = QueryDict('')
        qdict = qdict.copy()
        qdict.update(dict)
        formFechaIr = self.formFechaIr_class(qdict)

        if formFechaIr.is_valid():
            f = fechaIr.split('/')
            month = f[0]
            year = f[1]
            self.set_session(
                'fechaFiltrado',
                datetime.date(int(year), int(month), 1).toordinal()
            )
        else:
            fechaFiltrado_ord = self.get_session('fechaFiltrado') or\
                datetime.date.today().toordinal()
            fechaFiltrado = datetime.date.fromordinal(fechaFiltrado_ord)
            month = fechaFiltrado.month
            year = fechaFiltrado.year
        qs = qs.filter(fecha__year=int(year))
        qs = qs.filter(fecha__month=int(month))

        # formBuscar
        stringBuscar = self.get_session('stringBuscar')
        campoBuscar = self.get_session('campoBuscar')
        dict = {
            'stringBuscar': stringBuscar,
            'campoBuscar': campoBuscar,
        }
        qdict = QueryDict('')
        qdict = qdict.copy()
        qdict.update(dict)
        formBuscar = self.formBuscar_class(qdict)

        if formBuscar.is_valid():
            if campoBuscar == 'id':
                try:
                    isinstance(int(stringBuscar), int)
                    filter_dict = {campoBuscar: stringBuscar}
                    qs = qs.filter(**filter_dict)
                except:
                    pass
            elif campoBuscar in [
                'fecha', 'fecha_nacimiento', 'muestra_fecha_1',
                'muestra_fecha_2', 'fecha_notif_familia'
            ]:
                f = stringBuscar.split('/')
                f_dia = int(f[0])
                f_mes = int(f[1])
                f_ano = int(f[2])
                fecha = datetime.date(f_ano, f_mes, f_dia)
                filter_dict = {campoBuscar: fecha}
                qs = qs.filter(**filter_dict)
            elif campoBuscar in [
                'apellido', 'nombre', 'apellido_madre',
                'nombre_madre', 'notificar_trabsoc'
            ]:
                filter_dict = {
                    campoBuscar + '__contains': stringBuscar
                }
                qs = qs.filter(**filter_dict)
            elif campoBuscar in ['determinaciones']:
                filter_dict = {campoBuscar + '__in': stringBuscar}
                qs = qs.filter(**filter_dict)
            else:
                pass
        return qs
Beispiel #56
0
def register(request, success_url=None,
			 form_class=RegistrationFormUniqueEmail, profile_callback=None,
			 template_name='registration/registration_form.html',
			 extra_context=None):
	"""
	Allow a new user to register an account.
	
	Following successful registration, issue a redirect; by default,
	this will be whatever URL corresponds to the named URL pattern
	``registration_complete``, which will be
	``/accounts/register/complete/`` if using the included URLConf. To
	change this, point that named pattern at another URL, or pass your
	preferred URL as the keyword argument ``success_url``.
	
	By default, ``registration.forms.RegistrationFormUniqueEmail`` will be used
	as the registration form; to change this, pass a different form
	class as the ``form_class`` keyword argument. The form class you
	specify must have a method ``save`` which will create and return
	the new ``User``, and that method must accept the keyword argument
	``profile_callback`` (see below).
	
	To enable creation of a site-specific user profile object for the
	new user, pass a function which will create the profile object as
	the keyword argument ``profile_callback``. See
	``RegistrationManager.create_inactive_user`` in the file
	``models.py`` for details on how to write this function.
	
	By default, use the template
	``registration/registration_form.html``; to change this, pass the
	name of a template as the keyword argument ``template_name``.
	
	**Required arguments**
	
	None.
	
	**Optional arguments**
	
	``form_class``
		The form class to use for registration.
	
	``extra_context``
		A dictionary of variables to add to the template context. Any
		callable object in this dictionary will be called to produce
		the end result which appears in the context.
	
	``profile_callback``
		A function which will be used to create a site-specific
		profile instance for the new ``User``.
	
	``success_url``
		The URL to redirect to on successful registration.
	
	``template_name``
		A custom template to use.
	
	**Context:**
	
	``form``
		The registration form.
	
	Any extra variables supplied in the ``extra_context`` argument
	(see above).
	
	**Template:**
	
	registration/registration_form.html or ``template_name`` keyword
	argument.
	
	"""
	
	request.session['first_time_data'] = '' #clear the first_time cookie based logs
	if request.method == 'POST':
		request_post_copy = request.POST.copy()

		# Usernames will be saved in lowercase - this is because iexact doesn't work properly
		# with a specific collation (utf8_bin)
		formatted_username = request_post_copy.get('username', '')
		request_post_copy['username'] = formatted_username.lower() # Username saved as lowercase

		form = form_class(data=request_post_copy, files=request.FILES)
		data_demog={'username': request_post_copy['username'], 'password':request_post_copy['username'],'password1':request_post_copy['username'],'password2':request_post_copy['username'],'email':request_post_copy['username'],'zipcode':request_post_copy['username']}
		
		demog_qdict = QueryDict('')
		demog_qdict = demog_qdict.copy()
		demog_qdict.update(data_demog)
		
		demog = UserDemographicsForm(data=demog_qdict)
		
		if form.is_valid() and demog.is_valid():
			new_user = form.save(profile_callback=profile_callback)
			
			# Save the original formatting of the username
			username_setting = UserSettings(user = new_user, key = 'username_format', value = formatted_username)
			username_setting.save()
			
			# Extract the URL
			if request_post_copy.has_key('url') and request_post_copy['url'] != '':
				url_setting = UserSettings(user = new_user, key = 'url', value = request_post_copy['url'])
				url_setting.save()

			# Extract answer and question
			if request_post_copy.has_key('question') and request_post_copy.has_key('answer') and request_post_copy['question'] != '' and request_post_copy['answer'] != '':
				q_setting = UserSettings(user = new_user, key = 'question', value = request_post_copy['question'])
				q_setting.save()
				a_setting = UserSettings(user = new_user, key = 'answer', value = request_post_copy['answer'])
				a_setting.save()			
			
			# Save demographics
			request_post_copy_again = request_post_copy.copy()
			request_post_copy_again['user'] = new_user.id
			demog = UserDemographicsForm(data=demog_qdict)
			demog.save()

			# Create a zip code log entry for this user
			z = ZipCode.objects.filter(code=request_post_copy['zipcode'])
			if len(z) > 0:
				c = ZipCodeLog(user=new_user, location=z[0])
				c.save()
			
			#save additional informaiton of this user in UserDate
			#if the user didn't type age or reason, the value will be -1
			if request_post_copy.has_key('country'):
				country=UserData(user=new_user,key='country',value=request_post_copy['country'])
				country.save()

			if request_post_copy.has_key('gender'):
				gender=UserData(user=new_user,key='gender',value=request_post_copy['gender'])
				gender.save()

			if request_post_copy.has_key('age'):
				age=UserData(user=new_user,key='age',value=request_post_copy['age'])
				age.save()
			
			if request_post_copy.has_key('trainingYears'):
				trainingYears=UserData(user=new_user,key='trainingYears',value=request_post_copy['trainingYears'])
				trainingYears.save()
			if request_post_copy.has_key('reason'):
				reason=UserData(user=new_user,key='reason',value=request_post_copy['reason'])
				reason.save()
			# Create EntryCode
			entrycode = hashlib.sha224(request_post_copy['username']).hexdigest()[0:7]
			print entrycode
			ECobject=EntryCode(username=request_post_copy['username'],code=entrycode, first_login=False)
			ECobject.save()
			# Create visit times
			visittimes=UserData(user=new_user,key='visitTimes',value=str(1))
			visittimes.save()
			# If this was a visitor, connect to a user
			connect_visitor_to_user(request, new_user.id)
			
			# Check the username for profanity
			profanity_result = check_bad_words(formatted_username)
			if profanity_result[0]:
				pfu = ProfanityFlaggedUsername(user = new_user, profanity = profanity_result[1])
				pfu.save()
			
			#return json_result({'success':True, 'username': user_name_arg})
			return json_success()
		else:
			# Combine errors from the user form and demographics form and send back as JSON
			form.errors.update(demog.errors)
			return json_result({'form_errors': errors_to_dict(form.errors)})
	else:
		return json_error('Invalid request.')
Beispiel #57
0
def hack_multi_file(request):
    """
    Transform a ``request.FILES`` containing several lists of files into independent single files.

    Goal: Allow users to select multiple files at once, and to perform that action several times.
    Constraint: A single HTTP request containing form data and files. No Ajax calls.
    Problem: <input:file> cannot be modified in JavaScript.
    Solution:
        Use several <input:file multiple> from which user can have removed some files.
        ``request.FILES`` can therefore contain multiple keys that contains each several files.
        Scan ``request.FILES``, extract (only) the files we need and name keys according to ``ReportFileFormSet``.
        Return a ``QueryDict`` equivalent to ``request.FILES``.

    Example:
        request.POST: {
            ...
            'files-0-file_creation_date': [u'2005-4-1 4:32'],
            'files-0-reportattachment_ptr': [u''],
            'files-0-title': [u''],

            // User has removed "files-1"

            'files-2-file_creation_date': [u'2011-8-18 23:34'],
            'files-2-reportattachment_ptr': [u''],
            'files-2-title': [u''],

            'files-3-file_creation_date': [u'2005-4-5 1:46'],
            'files-3-reportattachment_ptr': [u''],
            'files-3-title': [u''],
            ...
        }
        request.FILES: {
            'files-files-0': [
                <InMemoryUploadedFile: filename-0.jpg (image/jpeg)>,
                <InMemoryUploadedFile: filename-1.jpg (image/jpeg)>,  // Removed by user but sent anyway in request, cf. "problem"
                <InMemoryUploadedFile: filename-2.jpg (image/jpeg)>
            ],
            'files-files-1': [
                <InMemoryUploadedFile: filename-3.jpg (image/jpeg)>
            ]
        }
        request_files: {
            'files-0-file': [<InMemoryUploadedFile: filename-0.jpg (image/jpeg)>],
            'files-2-file': [<InMemoryUploadedFile: filename-2.jpg (image/jpeg)>],
            'files-3-file': [<InMemoryUploadedFile: filename-3.jpg (image/jpeg)>]
        }
    """
    qd = {}  # The hacked request.FILES that will be returned.

    # Collect keys related to this hack and copy as-is the others in `qd`.
    files_keys = []
    for k in request.FILES.keys():
        if k.startswith("files-files-"):
            files_keys.append(k)
        else:
            # Copy as-is the keys that are not related to this hack.
            qd[k] = request.FILES[k]  # Or request.FILES.getlist(k) ?
    # Sort the keys to keep the file index coherent with the JS side.
    files_keys.sort()

    # Counter to loop over uploaded files and keep only the ones that have not been removed by the user.
    file_index = 0

    #the following counter is used to create keys in the returned querydict. All the keys  must be contain concecutive numbers
    #  otherwise there is a problem with the "cleaned_data" in the file_formset that will be created and the files
    # are not added correctly. So yes, there must be 2 differents counters. Spaghetti code for the win.
    qd_file_index = 0
    for k in files_keys:
        for f in request.FILES.getlist(k):
            # If there is a "title" field for this file_index, assume the file has not been removed from the form.
            if request.POST.has_key("files-{}-title".format(file_index)):
                qd["files-{}-file".format(qd_file_index)] = f
                qd_file_index += 1
            file_index += 1

    # Convert dict to QueryDict (to be equivalent to request.FILES).
    request_files = QueryDict("")
    request_files = request_files.copy()
    request_files.update(qd)

    return request_files
Beispiel #58
0
def get_mutable_query_dict(params=None):
    params = params or {}
    q = QueryDict('')
    q = q.copy()
    q.update(params)
    return q