Example #1
0
def context(user_claim: UserClaim, experiment_id: str, org: str,
            workspace: str):
    url = url_for("workspace_experiment_service.index",
                  org=org,
                  workspace=workspace,
                  experiment_id=experiment_id,
                  _external=True)
    experiment_id = shortuuid.decode(experiment_id)
    experiment = Experiment.query.filter(
        Experiment.id == experiment_id).first()
    if not experiment:
        return abort(404)

    w = DashboardService.get_user_workspace(user_claim, org, workspace)
    if not w:
        return abort(404)

    if "view" not in w["context"]["acls"]:
        return abort(404)

    e = experiment.to_public_dict()
    e["workspace"] = w
    e["requested_by"] = None
    e["url"] = url

    if user_claim:
        e["requested_by"] = DashboardService.get_user_details(
            user_claim, shortuuid.decode(w["org"]["id"]),
            shortuuid.decode(w["id"]))

    return jsonify(e)
 def to_python(self, value):
     value = super().to_python(value)
     if value in self.empty_values:
         return None
     try:
         shortuuid.decode(value)
     except ValueError:
         raise ValidationError(self.error_messages['invalid'], code='invalid')
     return value
def store_experiment(user_claim: UserClaim, org: str, workspace: str,
                     payload: Experiment) -> Experiment:
    experiment = Exp(shared_ref=uuid.uuid4(),
                     account_id=user_claim["id"],
                     org_id=shortuuid.decode(org),
                     workspace_id=shortuuid.decode(workspace),
                     payload=payload)
    db.session.add(experiment)
    db.session.commit()

    return experiment.to_public_dict(with_payload=False)
def get_experiment_in_workspace_for_user(user_claim: UserClaim, org: str,
                                         workspace: str, experiment_id: str,
                                         include_payload: bool = False) \
                                         -> Optional[Experiment]:
    experiment = Exp.query.filter(
        Exp.account_id == user_claim["id"],
        Exp.org_id == shortuuid.decode(org),
        Exp.workspace_id == shortuuid.decode(workspace),
        Exp.id == shortuuid.decode(experiment_id)).first()
    if not experiment:
        return None
    return experiment.to_public_dict(with_payload=include_payload)
def store_execution(user_claim: UserClaim, org: str, workspace: str,
                    experiment: str, payload: Experiment) -> Experiment:
    execution = Exec(experiment_id=shortuuid.decode(experiment),
                     account_id=user_claim["id"],
                     org_id=shortuuid.decode(org),
                     workspace_id=shortuuid.decode(workspace),
                     payload=payload,
                     status=payload.get('status', 'unknown'))
    db.session.add(execution)
    db.session.commit()

    return execution.to_dict()
Example #6
0
def activate(request, suuid):
    res = HttpResponse(content_type=CONTENT_TYPE_TEXT)

    logger.error('suuid: %s' % (suuid, ))

    #FIXME: check if the record is clicked
    #code = request.GET['c']
    code = shortuuid.decode(suuid)
    try:
        ur = UserRegistration.objects.get(code=code.hex)
    except UserRegistration.DoesNotExist:
        res.status_code = 401
        return res

    if ur.clicked:
        res.status_code = 203
        res.content = 'Already clicked'
    else:
        try:
            ur.activate()
        except IntegrityError, e:
            res = status = 400
            res.content = e.args[0]
            return res

        content = """<!DOCTYPE html> <html> <head> <title>Congratulations!</title> <script src="//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script> </head> <body> <h3>註冊成功</h3> <p>Welcome to PLATE!</p> <p>leave this page in <span id="remain_seconds">10</span> seconds</p> <script> var count = 9; var countdown = setInterval(function(){ $("#remain_seconds").html(count + ""); if (count == 0) { clearInterval(countdown); window.open('http://plate.tw', "_self"); } count--; }, 1000); </script> </body> </html>"""
        res = HttpResponse(content)
        res.status_code = 200
        return res
Example #7
0
def attendee(request, barcode):
    prefix = request.build_absolute_uri('/register/badges/qrcode/')
    qrcode = shortuuid.decode(barcode)
    ticket = get_object_or_404(Ticket, barcode=qrcode, success=True)

    if request.method == "POST":
        checked_in = request.POST.get('checked_in', None)
        checked_in_bool = checked_in in (True, "true", "True", 1, "1", False, None, "False", "false", "null", 0)
        p_checked_in = None
        if checked_in and type(checked_in) in (str, unicode):
            try:
                p_checked_in = parser.parse(checked_in)
            except (AttributeError as ValueError):
                pass

        if 'checked_in' not in request.POST or (type(checked_in) in (str, unicode) and not p_checked_in and not checked_in_bool):
            return HttpResponseBadRequest(json.dumps({'error': 'checked_in parameter required, and must be a datetime, true, false, or null.'}), content_type="application/json")

        if checked_in in (False, None, "False", "false", "null", 0):
            ticket.checked_in = None
        else:
            if ticket.checked_in is not None:
                return HttpResponse(json.dumps({'error': 'Already checked in.'}), status=409, content_type="application/json")

            if checked_in in (True, "true", "True", 1, "1"):
                ticket.checked_in = timezone.localtime(timezone.now())
            elif p_checked_in:
                if not p_checked_in.tzinfo:
                    p_checked_in = p_checked_in.replace(tzinfo=timezone.get_current_timezone())
                ticket.checked_in = p_checked_in
        ticket.save()

    return HttpResponse(json.dumps(get_badge(ticket, prefix=prefix, compact=False)), content_type="application/json")
Example #8
0
def remove_member_from_org(user_claim: Dict[str, Any], org: Org, user_id: str):
    if request.headers.get('Accept') != 'application/json':
        return render_template('index.html')

    # the user making the request
    account_id = user_claim["id"]
    if not org.is_owner(account_id):
        return abort(400)

    user_id = shortuuid.decode(user_id)
    # the user to remove
    account = UserAccount.query.filter(UserAccount.id == user_id).first()
    if not account:
        return "", 204

    if org.is_owner(account.id) and org.has_single_owner():
        return abort(400)

    org.remove_member(user_id)
    db.session.commit()

    record_activity({
        "title": org.name,
        "account_id": account_id,
        "kind": "organization",
        "info": "collaborator removed",
        "org_id": org.id,
        "visibility": ActivityVisibility.authenticated
    })

    return "", 204
Example #9
0
def remove_collaborator_from_workspace(user_claim: Dict[str, Any], org: Org,
                                       workspace: Workspace, user_id: str):
    if request.headers.get('Accept') != 'application/json':
        return render_template('index.html')

    # the user making the request
    account_id = user_claim["id"]
    if not workspace.is_owner(account_id):
        return abort(400)

    # the user to remove
    account = UserAccount.query.filter(
        UserAccount.id == shortuuid.decode(user_id)).first()
    if not account:
        return "", 204

    if workspace.is_owner(account.id) and workspace.has_single_owner():
        return abort(400)

    workspace.remove_collaborator(user_id)
    db.session.commit()

    record_activity({
        "title": workspace.name,
        "account_id": shortuuid.encode(account.id),
        "type": "workspace",
        "info": "collaborator deleted",
        "org_id": shortuuid.encode(org.id),
        "workspace_id": shortuuid.encode(workspace.id),
        "visibility": ActivityVisibility.authenticated
    })

    return "", 204
Example #10
0
File: models.py Project: kuchin/pen
def generate_short_uuid():
    short = shortuuid.decode(shortuuid.encode(uuid.uuid4())[:12])
    # Check if we already have such uuid, then regenerate
    if Note.objects.filter(read_id=short).count() > 0:
        return generate_short_uuid()
    else:
        return short
Example #11
0
File: mxic.py Project: mlhim/specs
def longid():
    MXICPATH= config.get('Locations', 'MXICPATH')
    files = getfiles(MXICPATH)

    for file in files:
        if file[-4:] == '.xml' and file[:5] == 'suid-':  # only the XML files
            f1 = open(MXICPATH + file,'r')
            lfile = MXICPATH+'lid-'+file
            f2 = open(lfile,'w')
            for line in f1.readlines():
                if '<mlhim2:pcs-' in line:
                    n1 = line.index('-')
                    n2 = line.index('>')
                    s = line[n1+1:n2]
                    if '-' in s and not 'xmlns:' in s: # this element wasn't a shortuuid
                        print(file," has non-standard characters in element names.")
                        f2.close()
                        os.remove(lfile) # delete the incomplete output file
                        break

                    uid = shortuuid.decode(s)
                    lid = str(uid)
                    newline = line.replace(s,lid)
                    f2.write(newline)
                else:
                    f2.write(line)

            f1.close()
            f2.close()
Example #12
0
File: views.py Project: kuchin/pen
def note(request, key):
    read_id = shortuuid.decode(key)
    n = models.Note.objects.get(read_id=read_id)
    return render(request, 'notes/note.html', {
        'note': n,
        'google_analytics_id': settings.GOOGLE_ANALYTICS_ID
    })
Example #13
0
File: mxic.py Project: mlhim/mxic
def longid(files=[]):
    if len(files) == 0:
        files = getfiles('.') # all files in the current directory
    for file in files:
        if file[-4:] == '.xml' and file[:5] == 'suid-':  # only the XML files 
            f1 = open(file,'r')
            lfile = 'lid-'+file
            f2 = open(lfile,'w')
            print(lfile)
            for line in f1.readlines():
                if '<ccd:el-' in line:
                    n1 = line.index('-')
                    n2 = line.index('>')
                    s = line[n1+1:n2]
                    if '-' in s and not 'xmlns:' in s: # this element wasn't a shortuuid
                        print(file," has non-standard characters in element names.")
                        f2.close()
                        os.remove(lfile) # delete the incomplete output file
                        break
                    
                    uid = shortuuid.decode(s)
                    lid = str(uid)
                    newline = line.replace(s,lid)
                    f2.write(newline)
                else:
                    f2.write(line)
                
            f1.close()
            f2.close()
def decode(value):
    """Decode the value from ShortUUID to UUID.

    Raises ValueError when the value is not valid.
    """
    if not isinstance(value, str) or len(value) != 22:
        raise ValueError('badly formed ShortUUID')
    return shortuuid.decode(value)
Example #15
0
 def uuid(self, value):
     if isinstance(value, pyuuid.UUID):
         self._uuid = value
         return
     try:
         self._uuid = shortuuid.decode(str(value))
     except ValueError:
         self._uuid = pyuuid.UUID(str(value))
Example #16
0
 def getByShortId(self, id):
     try:
         tournamentId = shortuuid.decode(id)        
         return self.getById(tournamentId)
     except Exception as exception:
         print(exception)
         transaction.abort()
         return None        
Example #17
0
def get_user_last_experiments(user_claim: UserClaim) -> List[Experiment]:
    """
    Retrieve the last updated experiments.
    """
    experiments = get_last_updated_experiments(user_claim)
    for e in experiments:
        w = Workspace.query.filter(
            Workspace.id == shortuuid.decode(e["workspace"])).first()
        e["workspace"] = w.to_dict()
    return experiments
Example #18
0
    def get_by_id(exp_id: Union[str, uuid.UUID]) -> Optional['Experiment']:
        if not exp_id:
            return None

        if isinstance(exp_id, str):
            try:
                exp_id = shortuuid.decode(exp_id)
            except ValueError:
                return None

        return Experiment.query.filter(Experiment.id == exp_id).first()
Example #19
0
    def get_short_object_id(self):
        if not shortuuid:
            return None

        short_obj_id_name = self.get_short_object_id_name()
        short_obj_id = self.kwargs.get(short_obj_id_name, None)

        if short_obj_id is None:
            return None 

        return shortuuid.decode(short_obj_id).hex
Example #20
0
    def get_short_object_id(self):
        if not shortuuid:
            return None

        short_obj_id_name = self.get_short_object_id_name()
        short_obj_id = self.kwargs.get(short_obj_id_name, None)

        if short_obj_id is None:
            return None

        return shortuuid.decode(short_obj_id).hex
Example #21
0
    def getGame(response, connection, id, dateId, pitchId, gameId):
        (tournament, date, pitch) = Game.getPitch(response, connection, id,
                                                  dateId, pitchId)
        if pitch:
            fullGameId = shortuuid.decode(gameId)
            game = next((x for x in pitch.games if x.id == fullGameId), None)
            if not game:
                response.status = '404 Not Found'
                response.text = '{"message"="Game with id ' + gameId + ' not found."}'
            else:
                return (tournament, date, pitch, game)

        return (None, None, None, None)
Example #22
0
    def from_dict(activity: Dict[str, Any]) -> 'Activity':
        visibility = activity["visibility"]
        if visibility in (1, "anonymous"):
            visibility = ActivityVisibility.anonymous
        elif visibility in (2, "authenticated"):
            visibility = ActivityVisibility.authenticated
        elif visibility in (3, "collaborator"):
            visibility = ActivityVisibility.collaborator
        elif visibility in (4, "owner"):
            visibility = ActivityVisibility.owner

        org_id = activity.get("org_id")
        if org_id:
            org_id = shortuuid.decode(org_id)

        workspace_id = activity.get("workspace_id")
        if workspace_id:
            workspace_id = shortuuid.decode(workspace_id)

        experiment_id = activity.get("experiment_id")
        if experiment_id:
            experiment_id = shortuuid.decode(experiment_id)

        execution_id = activity.get("execution_id")
        if execution_id:
            execution_id = shortuuid.decode(execution_id)

        return Activity(account_id=shortuuid.decode(
            activity.get("account_id")),
                        org_id=org_id,
                        workspace_id=workspace_id,
                        experiment_id=experiment_id,
                        execution_id=execution_id,
                        kind=activity.get("type"),
                        visibility=visibility,
                        title=activity.get("title"),
                        info=activity.get("info"),
                        extra=activity.get("extra"),
                        timestamp=activity.get("timestamp"))
Example #23
0
    def from_dict(token: Dict[str, Any]) -> 'APIAccessToken':
        """
        Create or update a token from the source access token.

        On update, only the scope, revoked and dates properties are changed.
        Others are left as they are.
        """
        access_token = APIAccessToken.get_by_token(token["access_token"])
        if not access_token:
            access_token = APIAccessToken()
            access_token.id = shortuuid.decode(token["id"])
            access_token.account_id = shortuuid.decode(token["account_id"])
            access_token.access_token = token["access_token"]
            access_token.client_id = token["client_id"]

        access_token.name = token["name"]
        access_token.refresh_token = token["refresh_token"]
        access_token.scope = token["scope"]
        access_token.revoked = token["revoked"]
        access_token.issued_at = token["issued_at"]
        access_token.expires_in = token["expires_in"]

        return access_token
Example #24
0
    def getPitch(response, connection, id, dateId, pitchId):
        tournament = connection.tournaments.getByShortId(id)
        if not tournament:
            response.status = '404 Not Found'
            response.text = '{"message"="Tournament with id ' + id + ' not found."}'
        else:
            fullDateId = shortuuid.decode(dateId)
            date = next(
                (x for x in tournament.gameDates if x.id == fullDateId), None)
            if not date:
                response.status = '404 Not Found'
                response.text = '{"message"="Date with id ' + dateId + ' not found."}'
            else:
                fullPitchId = shortuuid.decode(pitchId)
                pitch = next((x for x in date.pitches if x.id == fullPitchId),
                             None)
                if not pitch:
                    response.status = '404 Not Found'
                    response.text = '{"message"="Pitch with id ' + pitchId + ' not found."}'
                else:
                    return (tournament, date, pitch)

        return (None, None, None)
 def get_search_results(self, request, queryset, search_term):
     queryset, use_distinct = super().get_search_results(
         request, queryset, search_term)
     try:
         search_term_as_uuid = shortuuid.decode(search_term.strip())
     except ValueError as e:
         pass
     else:
         for uuid_search_field in self._uuid_search_fields:
             search_params = {
                 uuid_search_field: search_term_as_uuid,
             }
             queryset |= self.model.objects.filter(**search_params)
     return queryset, use_distinct
Example #26
0
    def get_redirect_url(self, *args, **kwargs):
        try:
            uuid = shortuuid.decode(kwargs['short_uuid'])
        except ValueError:
            logger.warning('can not convert %s to uuid with actual decode() method', kwargs['short_uuid'])
            uuid = shortuuid.decode(kwargs['short_uuid'], legacy=True)

        receipt = get_object_or_404(Receipt, internal_uuid=uuid)

        if not receipt.content:
            logger.warning('access receipt before backend processed receipt, suspicious')
            raise MissingReceipt()

        payload = receipt.content['payload']
        receipt_dt = parse_receipt_datetime(payload['receipt_datetime'])

        return settings.RECEIPTS_OFD_URL_TEMPLATE.format(
            t='{:%Y%m%dT%H%M%S}'.format(receipt_dt),
            s=payload['total'],
            fn=payload['fn_number'],
            fd=payload['fiscal_document_number'],
            fp=payload['fiscal_document_attribute'],
            n=payload['fiscal_receipt_number'],
        )
Example #27
0
def revoke_token(token_id: str, user_claim: UserClaim):
    if request.headers.get('Accept') != 'application/json':
        return abort(405)

    token_id = shortuuid.decode(token_id)
    AuthService.revoke_user_access_token(user_claim, token_id)

    record_activity({
        "title": "Access Token",
        "account_id": user_claim["short_id"],
        "type": "token",
        "info": "revoked",
        "visibility": ActivityVisibility.owner
    })

    return jsonify(None), 204
Example #28
0
def load_experiment(user_claim: UserClaim, experiment_id: str, org: str,
                    workspace: str) -> Experiment:
    experiment_id = shortuuid.decode(experiment_id)
    experiment = Experiment.query.filter(
        Experiment.id == experiment_id).first()
    if not experiment:
        raise abort(404)

    w = DashboardService.get_workspace(user_claim, org, workspace)
    if not w:
        raise abort(404)

    if "view" not in w["context"]["acls"]:
        raise abort(404)

    return experiment
    def replace(self, column):
        if not isinstance(column, sa.Column):
            return
        try:
            table = version_table(column.table)
        except KeyError:
            reflected_column = column
        else:
            reflected_column = table.c[column.name]
            if (column in self.relationship.local_columns
                    and table == self.parent.__table__):
                reflected_column = bindparam(column.key,
                                             getattr(self.parent, column.key))

        with contextlib.suppress(AttributeError, TypeError):
            reflected_column.value = shortuuid.decode(reflected_column.value)
        return reflected_column
Example #30
0
def attendee(request, barcode):
    prefix = request.build_absolute_uri('/register/badges/qrcode/')
    qrcode = shortuuid.decode(barcode)
    ticket = get_object_or_404(Ticket, barcode=qrcode, success=True)

    if request.method == "POST":
        checked_in = request.POST.get('checked_in', None)
        checked_in_bool = checked_in in (True, "true", "True", 1, "1", False,
                                         None, "False", "false", "null", 0)
        p_checked_in = None
        if checked_in and type(checked_in) in (str, unicode):
            try:
                p_checked_in = parser.parse(checked_in)
            except (AttributeError, ValueError):
                pass

        if 'checked_in' not in request.POST or (
                type(checked_in) in (str, unicode) and not p_checked_in
                and not checked_in_bool):
            return HttpResponseBadRequest(json.dumps({
                'error':
                'checked_in parameter required, and must be a datetime, true, false, or null.'
            }),
                                          content_type="application/json")

        if checked_in in (False, None, "False", "false", "null", 0):
            ticket.checked_in = None
        else:
            if ticket.checked_in is not None:
                return HttpResponse(json.dumps(
                    {'error': 'Already checked in.'}),
                                    status=409,
                                    content_type="application/json")

            if checked_in in (True, "true", "True", 1, "1"):
                ticket.checked_in = timezone.localtime(timezone.now())
            elif p_checked_in:
                if not p_checked_in.tzinfo:
                    p_checked_in = p_checked_in.replace(
                        tzinfo=timezone.get_current_timezone())
                ticket.checked_in = p_checked_in
        ticket.save()

    return HttpResponse(json.dumps(
        get_badge(ticket, prefix=prefix, compact=False)),
                        content_type="application/json")
Example #31
0
 def object_hook(self, object):  # pylint: disable=E0202
     if '_type' not in object:
         return object
     type = object['_type']
     if type == 'datetime':
         try:
             return datetime.strptime(object['value'],
                                      '%Y-%m-%dT%H:%M:%S')  # DateTime
         except ValueError:
             try:
                 return datetime.strptime(object['value'],
                                          '%Y-%m-%d')  # Date Only
             except ValueError:
                 return datetime.strptime(object['value'])  # Any Format
     elif type == 'uuid':
         return shortuuid.decode(object['value'])
     return object
Example #32
0
def patch_membership(user_claim: Dict[str, Any], org: Org,
                     workspace: Workspace, user_id: str):
    if request.headers.get('Accept') != 'application/json':
        return render_template('index.html')

    # the user making the request
    account_id = user_claim["id"]
    if not workspace.is_owner(account_id):
        return abort(400)

    # the user to amend
    user = request.json
    if not user:
        return abort(400)

    user_id = user.get("id")
    if not user_id:
        return abort(400)

    account = UserAccount.query.filter(
        UserAccount.id == shortuuid.decode(user_id)).first()
    if not account:
        return "", 204

    turn_owner = user.get("workspace_owner", False)
    if turn_owner and workspace.is_collaborator(account.id):
        workspace.make_owner(account.id)
    elif not turn_owner and workspace.is_owner(account.id):
        if workspace.has_single_owner():
            return abort(400)
        workspace.make_collaborator(account.id)

    db.session.commit()

    record_activity({
        "title": workspace.name,
        "account_id": shortuuid.encode(account.id),
        "type": "workspace",
        "info": "collaborator updated",
        "org_id": shortuuid.encode(org.id),
        "workspace_id": shortuuid.encode(workspace.id),
        "visibility": ActivityVisibility.authenticated
    })

    return "", 200
Example #33
0
def test_generate_access_token(app: Flask):
    with app.app_context():
        claim = {"id": "c1337e77-ccaf-41cf-a68c-d6e2026aef21"}
        name = "my token"

        token = generate_access_token(claim, name)
        token_id = shortuuid.decode(token["id"])
        access_token = AccessToken.query.filter(
            AccessToken.id == token_id).first()
        assert access_token is not None
        assert access_token.name == name
        assert access_token.token_type == "bearer"
        assert access_token.revoked is False
        assert str(access_token.account_id) == \
            "c1337e77-ccaf-41cf-a68c-d6e2026aef21"

        db.session.delete(access_token)
        db.session.commit()
Example #34
0
def item_query(q, model, id=None, **kwargs):
    if id is int:
        q = q.filter(model.pk == id)
    elif issubclass(model, TextIdentified):
        q = q.filter(model.id == id)
    elif id is not None:
        item_uuid = shortuuid.decode(id)
        if item_uuid.version is None:
            return None
        else:
            q = q.filter(model.uuid == item_uuid)

    for key, val in kwargs.items():
        field = getattr(model, key)
        if field is not None:
            filter_value = field == val  # compute expression
            q = q.filter(filter_value)

    return q
Example #35
0
def key_is_staff(key):
    if not key:
        return False

    try:
        ukey = shortuuid.decode(key)
    except:
        return False

    ticket = list(Ticket.objects.filter(barcode=ukey).select_related())
    if not ticket:
        return False

    ticket = ticket[0]
    coupon = ticket.sale.coupon_code

    if coupon and coupon.is_staff:
        return True
    else:
        return False
Example #36
0
def key_is_staff(key):
    if not key:
        return False

    try:
        ukey = shortuuid.decode(key)
    except:
        return False

    ticket = list(Ticket.objects.filter(barcode=ukey).select_related())
    if not ticket:
        return False

    ticket = ticket[0]
    coupon = ticket.sale.coupon_code

    if coupon and coupon.is_staff:
        return True
    else:
        return False
Example #37
0
    def clean(self, value):
        if value is None:
            # Value is nothing; return it.
            return value

        try:
            try:
                if self.short:
                    # Attempt to coerce the short UUID.
                    return shortuuid.decode(value)

            except ValueError:
                pass

            # Attempt to coerce the UUID.
            return uuid.UUID(value)

        except ValueError:
            raise ValueError('UUID must be of the form: '
                             'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
Example #38
0
    def clean(self, value):
        if value is None:
            # Value is nothing; return it.
            return value

        try:
            try:
                if self.short:
                    # Attempt to coerce the short UUID.
                    return shortuuid.decode(value)

            except ValueError:
                pass

            # Attempt to coerce the UUID.
            return uuid.UUID(value)

        except ValueError:
            raise ValueError(
                'UUID must be of the form: '
                'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx')
Example #39
0
 def filter(self, *args, **kwargs):
     if 'short_barcode' in kwargs:
         kwargs['barcode'] = shortuuid.decode(kwargs['short_barcode'])
         del kwargs['short_barcode']
     return super(TicketQuerySet, self).filter(*args, **kwargs)
Example #40
0
 def filter(self, qs, value):
     if value:
         shortuuid.set_alphabet('23456789abcdefghjkmnpqrstuvwxyz')
         value = shortuuid.decode(value)
     return super(ObjectIDFilter, self).filter(qs, value)