Beispiel #1
0
def update_location_by_id(id, ld):
    with get_db().transaction() as t:
        q = t.query(_Location).filter(_Location.id == id)
        location = q.one()
        ld.map_out(location)

    return get_location_by_id(id)
Beispiel #2
0
def create_card(**kwargs):
    with get_db().transaction() as t:
        card = _Card(**kwargs)
        t.add(card)
        t.commit()
        id = card.id
    return get_card_by_id(id)
Beispiel #3
0
def get_user_by_name(name):
    with get_db().transaction() as t:
        try:
            user = (t.query(_User).filter(_User.name == name).one())
            return User.map_in(user)
        except NoResultFound:
            raise bottle.HTTPError(404)
Beispiel #4
0
 def map_out(self, entry, system=False):
     entry.original_filename = self.original_filename
     entry.export_filename = self.export_filename
     entry.source = self.source
     entry.import_location_id = self.import_location_id
     entry.state = self.state
     entry.taken_ts = (datetime.datetime.strptime(
         self.taken_ts, '%Y-%m-%d %H:%M:%S').replace(microsecond=0)
         if self.taken_ts else None
     )
     if self.deleted and self.delete_ts is None:
         self.delete_ts = ((
             datetime.datetime.utcnow() + datetime.timedelta(hours=DELETE_AFTER)
         ).strftime('%Y-%m-%d %H:%M:%S'))
     elif self.deleted is False and self.delete_ts is not None:
         self.delete_ts = None
     entry.delete_ts = (datetime.datetime.strptime(
         self.delete_ts, '%Y-%m-%d %H:%M:%S').replace(microsecond=0)
         if self.delete_ts else None
     )
     entry.access = self.access
     entry.data = self.metadata.to_json() if self.metadata else None
     entry.physical_data = (
         self.physical_metadata.to_json() if self.physical_metadata else None
     )
     entry.user_id = self.user_id
     entry.parent_entry_id = self.parent_entry_id
     entry.latitude = self.latitude
     entry.longitude = self.longitude
     with get_db().transaction() as t:
         entry.tags = [t.query(_Tag).get(tag.id) for tag in self.tags]
         entry.files = [t.query(_File).get(file.id) for file in self.files]
Beispiel #5
0
def fail_import(entry, reason):
    logging.error(reason)
    with get_db().transaction() as t:
        e = t.query(_Entry).get(entry.id)
        e.state = _Entry.State.import_failed
        metadata = wrap_raw_json(e.data) or _Entry.DefaultMetadata()
        metadata.error = reason
        e.data = metadata.to_json()
Beispiel #6
0
def delete_entry_by_id(id, system=False):
    with get_db().transaction() as t:
        q = t.query(_Entry).filter(_Entry.id == id)
        if not system:
            q = q.filter(
                (_Entry.user_id == current_user_id()) | (_Entry.access >= _Entry.Access.common)
            )
        q.delete()
Beispiel #7
0
def create_location(ld):
    with get_db().transaction() as t:
        location = _Location()
        ld.map_out(location)
        t.add(location)
        t.commit()
        id = location.id
    return get_location_by_id(id)
Beispiel #8
0
def get_names_by_run(run):
    authenticate_cookie()
    with get_db().transaction() as t:
        tokens = t.query(_Token).filter(_Token.run == run).all()

        return {
            '*schema': 'Names',
            'entries': [token.name for token in tokens],
            'count': len(tokens),
        }
Beispiel #9
0
def get_names_by_run(run):
    authenticate_cookie()
    with get_db().transaction() as t:
        tokens = t.query(_Token).filter(_Token.run == run).all()

        return {
            '*schema': 'Names',
            'entries': [token.name for token in tokens],
            'count': len(tokens),
        }
Beispiel #10
0
def get_tag_by_id(id):
    with get_db().transaction() as t:
        tag = t.query(_Tag).filter(_Tag.id == id).one()

        return Tag(
            id=tag.id,
            color_id=tag.color,
            background_color=colors[tag.color][0],
            foreground_color=colors[tag.color][1],
            color_name=colors[tag.color][2],
        )
Beispiel #11
0
def update_entry_by_id(id, ed, system=False):
    with get_db().transaction() as t:
        q = t.query(_Entry).filter(_Entry.id == id)
        if not system:
            q = q.filter(
                (_Entry.user_id == current_user_id()) | (_Entry.access >= _Entry.Access.common)
            )
        entry = q.one()
        ed.map_out(entry)

    return get_entry_by_id(id)
Beispiel #12
0
def create_file(f):
    with get_db().transaction() as t:
        try:
            _f = _File()
            f.map_out(_f)
            t.add(_f)
            t.commit()
            id = _f.id
            return get_file_by_id(id)
        except IntegrityError:
            t.rollback()
    raise _File.ConflictException()
Beispiel #13
0
def get_entry_by_source(source, filename, system=False):
    with get_db().transaction() as t:
        q = t.query(_Entry).filter(
            _Entry.source == source,
            _Entry.original_filename == filename
        )
        if not system:
            q = q.filter(
                (_Entry.user_id == current_user_id()) | (_Entry.access >= _Entry.Access.public)
            )
        entry = q.one()
        return Entry.map_in(entry)
Beispiel #14
0
def create_entry(ed, system=False):
    with get_db().transaction() as t:
        entry = _Entry()

        for tag in ed.tags:
            ensure_tag(tag)

        ed.map_out(entry, system=system)
        t.add(entry)
        t.commit()
        id = entry.id

    return get_entry_by_id(id)
Beispiel #15
0
def add_tag(td):
    if not td.id:
        raise ValueError("Tag id must not be empty")

    with get_db().transaction() as t:
        tag = _Tag()
        tag.id = td.id.lower()
        tag.color = td.color_id if td.color_id is not None else random.randrange(
            0, len(colors))
        t.add(tag)
        t.commit()
        id = tag.id

    return get_tag_by_id(id)
Beispiel #16
0
def get_tags():
    with get_db().transaction() as t:
        tags = t.query(_Tag).order_by(_Tag.id).all()

        return TagFeed(count=len(tags),
                       entries=[
                           Tag(
                               id=tag.id,
                               color_id=tag.color,
                               background_color=colors[tag.color][0],
                               foreground_color=colors[tag.color][1],
                               color_title=colors[tag.color][2],
                           ) for tag in tags
                       ])
Beispiel #17
0
def create_token(name, run):
    with get_db().transaction() as t:
        _token = _Token(
            name=name,
            run=run,
            token=''.join(random.SystemRandom().choice(
                string.ascii_lowercase + string.ascii_uppercase + string.digits
            ) for _ in range(32))
        )

        t.add(_token)
        token = Token.map_in(_token)
    logging.debug("Adding token for %s (running as %s).", token.name, token.run)
    return token
Beispiel #18
0
def pick_up_import_ready_entry(location_id):
    with get_db().transaction() as t:
        try:
            entry = t.query(_Entry).filter(
                _Entry.import_location_id == location_id,
                _Entry.state == _Entry.State.import_ready,
            ).order_by(_Entry.create_ts).first()
            if entry is None:
                return None

            entry.state = _Entry.State.importing
            return Entry.map_in(entry)

        except NoResultFound:
            return None
Beispiel #19
0
def ensure_tag(tag_id):
    """
    Check if a tag with id `tag_id` exists. If not, create it.
    """
    if not tag_id:
        raise ValueError("Tag id must not be empty")

    with get_db().transaction() as t:
        try:
            t.query(_Tag).filter(_Tag.id == tag_id).one()
        except NoResultFound:
            tag = _Tag()
            tag.id = tag_id
            tag.color = random.randrange(0, len(colors))
            t.add(tag)
Beispiel #20
0
def create_token(name, run):
    with get_db().transaction() as t:
        _token = _Token(
            name=name,
            run=run,
            token=''.join(random.SystemRandom().choice(string.ascii_lowercase +
                                                       string.ascii_uppercase +
                                                       string.digits)
                          for _ in range(32)))

        t.add(_token)
        token = Token.map_in(_token)
    logging.debug("Adding token for %s (running as %s).", token.name,
                  token.run)
    return token
Beispiel #21
0
def authenticate(token_string):
    if hasattr(bottle.request, 'token'):
        token = bottle.request.token
        logging.debug("Already authenticated as %s (running as %s).", token.name, token.run)
        return
        
    with get_db().transaction() as t:
        token = t.query(_Token).get(token_string)

        if token is None:
            raise bottle.HTTPError(401)

        bottle.request.token = Token.map_in(token)
        bottle.response.set_cookie('token', token_string, path='/')

        logging.debug("Authenticated as %s (running as %s).", token.name, token.run)
Beispiel #22
0
def authenticate(token_string):
    if hasattr(bottle.request, 'token'):
        token = bottle.request.token
        logging.debug("Already authenticated as %s (running as %s).",
                      token.name, token.run)
        return

    with get_db().transaction() as t:
        token = t.query(_Token).get(token_string)

        if token is None:
            raise bottle.HTTPError(401)

        bottle.request.token = Token.map_in(token)
        bottle.response.set_cookie('token', token_string, path='/')

        logging.debug("Authenticated as %s (running as %s).", token.name,
                      token.run)
Beispiel #23
0
def sync_records():
    run = bottle.request.token.run
    test_cases = list_testcases()
    for category in test_cases.entries:
        for test_case in category.entries:
            with get_db().transaction() as t:
                q = (t.query(_Record).filter(
                    _Record.run == run, _Record.test_category == category.name,
                    _Record.test_name == test_case.name))
                if q.count() == 0:
                    logging.debug('Creating record for %s/%s/%s' %
                                  (run, category.name, test_case.name))
                    r = _Record(
                        run=run,
                        test_category=category.name,
                        test_name=test_case.name,
                        state=int(State.not_run),
                    )
                    t.add(r)
Beispiel #24
0
def basic_auth(username, password):
    """
    Bottle-compatible simple-checker that stores the user descriptor
    of the currently logged in user onto the request.
    """
    with get_db().transaction() as t:
        try:
            user = (t.query(_User).filter(_User.name == username).filter(
                _User.password == password_hash(password)).filter(
                    _User.status == _User.Status.enabled).one())

            bottle.request.user = User(
                id=user.id,
                status=_User.Status(user.status),
                name=user.name,
                fullname=user.fullname,
                user_class=_User.Class(user.user_class),
            )
            logging.debug("Logged in as %s", user.name)
            return True
        except NoResultFound:
            return False
Beispiel #25
0
def op_record(category, test, state):
    if category == 'undefined' or test == 'undefined':
        raise bottle.HTTPError(400)

    run = bottle.request.token.run
    assignee = bottle.request.token.name
    state = getattr(State, state)

    if bottle.request.json is not None:
        comment = bottle.request.json.get('comment', None) or None
        jira = bottle.request.json.get('jira', None) or None
    else:
        comment = None
        jira = None

    with get_db().transaction() as t:
        r = _Record(
            run=run,
            assignee=assignee,
            test_category=category,
            test_name=test,
            state=int(state),
            comment=comment,
            jira=jira,
        )
        t.add(r)

    return Record(
        run=run,
        assignee=assignee,
        test_name=test,
        test_category=category,
        state=state,
        comment=comment,
        jira=jira,
        url='%s/%s/%s' % (TestcaseApp.BASE, category, test),
        history_url='%s/history/%s/%s' % (App.BASE, category, test),
    ).to_dict()
Beispiel #26
0
def op_record(category, test, state):
    if category == 'undefined' or test == 'undefined':
        raise bottle.HTTPError(400)

    run = bottle.request.token.run
    assignee = bottle.request.token.name
    state = getattr(State, state)
    
    if bottle.request.json is not None:
        comment = bottle.request.json.get('comment', None) or None
        jira = bottle.request.json.get('jira', None) or None
    else:
        comment = None
        jira = None

    with get_db().transaction() as t:
        r = _Record(
            run=run,
            assignee=assignee,
            test_category=category,
            test_name=test,
            state=int(state),
            comment=comment,
            jira=jira,
        )
        t.add(r)

    return Record(
        run=run,
        assignee=assignee,
        test_name=test,
        test_category=category,
        state=state,
        comment=comment,
        jira=jira,
        url='%s/%s/%s' % (TestcaseApp.BASE, category, test),
        history_url='%s/history/%s/%s' % (App.BASE, category, test),
    ).to_dict()
Beispiel #27
0
def sync_records():
    run = bottle.request.token.run
    test_cases = list_testcases()
    for category in test_cases.entries:
        for test_case in category.entries:
            with get_db().transaction() as t:
                q = (
                    t.query(_Record)
                        .filter(
                            _Record.run == run,
                            _Record.test_category == category.name,
                            _Record.test_name == test_case.name
                    )
                )
                if q.count() == 0:
                    logging.debug('Creating record for %s/%s/%s' % (run, category.name, test_case.name))
                    r = _Record(
                        run=run,
                        test_category=category.name,
                        test_name=test_case.name,
                        state=int(State.not_run),
                    )
                    t.add(r)
Beispiel #28
0
def delete_location_by_id(id):
    with get_db().transaction() as t:
        t.query(_Location).filter(_Location.id == id).delete()
Beispiel #29
0
Datei: box.py Projekt: eblade/org
def create_box(**kwargs):
    with get_db().transaction() as t:
        _box = _Box(**kwargs)
        t.add(_box)
        box = Box.map_in(_box)
    return box
Beispiel #30
0
def get_locations():
    with get_db().transaction() as t:
        locations = t.query(_Location).all()
        return LocationFeed(
            count=len(locations),
            entries=[Location.map_in(location) for location in locations])
Beispiel #31
0
def get_locations_by_type(*types):
    with get_db().transaction() as t:
        locations = t.query(_Location).filter(_Location.type.in_(types)).all()
        return LocationFeed(
            count=len(locations),
            entries=[Location.map_in(location) for location in locations])
Beispiel #32
0
def get_location_by_name(name):
    with get_db().transaction() as t:
        location = t.query(_Location).filter(_Location.name == name).one()
        return Location.map_in(location)
Beispiel #33
0
def get_location_by_id(id):
    with get_db().transaction() as t:
        location = t.query(_Location).filter(_Location.id == id).one()
        return Location.map_in(location)
Beispiel #34
0
def get_card_by_id(card_id):
    with get_db().transaction() as t:
        _card = t.query(_Card).filter(_Card.id == card_id).one()
        card = Card.map_in(_card)
    return card
Beispiel #35
0
Datei: box.py Projekt: eblade/org
def get_box_by_id(box_id):
    with get_db().transaction() as t:
        _box = t.query(_Box).filter(Box.id == box_id).one()
        box = Box.map_in(_box)
    return box
Beispiel #36
0
def get_records(history=False, only_category=None, only_test_case=None):
    run = bottle.request.token.run
    with get_db().transaction() as t:
        q = t.query(_Record).filter(_Record.run == run)

        if only_category is not None:
            q = q.filter(_Record.test_category == only_category)

        if only_test_case is not None:
            q = q.filter(_Record.test_name == only_test_case)

        q = q.order_by(
            _Record.test_category.desc(),
            _Record.test_name.desc(),
            _Record.ts.asc(),
        )

        records = q.all()

        per_category = {}
        count = 0
        for _record in records:
            record = Record.map_in(_record)
            if record.test_category not in per_category.keys():
                per_category[record.test_category] = {}

            if history:
                if record.test_name not in per_category[record.test_category].keys():
                    per_category[record.test_category][record.test_name] = []
                    count += 1

                per_category[record.test_category][record.test_name].append(record)
            else:
                if record.test_name not in per_category[record.test_category]:
                    count += 1
                per_category[record.test_category][record.test_name] = record

    if history:
        return RecordFeedWithHistory(
            history=True,
            count=count,
            entries=[
                RecordCategoryWithHistory(
                    name=category,
                    entries=[
                        RecordHistory(
                            name=name,
                            entries=records,
                            current=records[-1],
                        ) for name, records in sorted(per_name.items())
                    ]
                ) for category, per_name in sorted(per_category.items())
            ]
        )
    else:
        for category, records in sorted(per_category.items()):
            print(category)
            print(records)
        return RecordFeed(
            history=False,
            count=count,
            entries=[
                RecordCategory(
                    name=category,
                    entries=[record for name, record in sorted(records.items())],
                ) for category, records in sorted(per_category.items())
            ]
        )
Beispiel #37
0
def get_file_by_id(id):
    with get_db().transaction() as t:
        f = t.query(_File).get(id)
        return File.map_in(f)
Beispiel #38
0
def delete_file_by_id(id):
    with get_db().transaction() as t:
        t.query(_File).filter(_File.id == id).delete()