Python DBSession.query方法代码示例

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def take_random(request):
    job_id = request.matchdict['job']
    if "checkin" in request.matchdict:
        checkin = request.matchdict['checkin']
    else:
        checkin = None
    session = DBSession()
    username = authenticated_userid(request)
    user = session.query(User).get(username)
    job = session.query(Job).get(job_id)

    filter = and_(Tile.checkin==checkin, Tile.job_id==job_id)
    tiles = session.query(Tile).filter(filter).all()
    # take random tile
    if checkin is not None:
        # get the tile the user worked on previously
        filter = and_(TileHistory.username==username, TileHistory.job_id==job_id)
        p = session.query(TileHistory).filter(filter).order_by(TileHistory.update.desc()).limit(4).all()
        tile = None
        if p is not None and len(p) > 0:
            p = p[len(p) -1]
            neighbours = [
                (p.x - 1, p.y - 1), (p.x - 1, p.y), (p.x - 1, p.y + 1),
                (p.x, p.y - 1), (p.x, p.y + 1),
                (p.x + 1, p.y - 1), (p.x + 1, p.y), (p.x + 1, p.y + 1)]
            for t in tiles:
                if (t.x, t.y) in neighbours:
                    tile = t
                    break
    if tile is None:
        tile = tiles[random.randrange(0, len(tiles))]

    return dict(success=True, tile=dict(x=tile.x, y=tile.y, z=tile.zoom))

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def job_edit(request):
    id = request.matchdict['job']
    session = DBSession()
    job = session.query(Job).get(id)

    licenses = session.query(License).all()

    if 'form.submitted' in request.params:
        job.title = request.params['title']
        job.short_description = request.params['short_description']
        job.description = request.params['description']
        job.workflow = request.params['workflow']
        josm_preset = request.params['josm_preset']
        josm_preset = josm_preset.value.decode('UTF-8') if josm_preset != '' else ''
        job.josm_preset = josm_preset 
        job.is_private = request.params.get('is_private') == 'on'
        job.imagery = request.params['imagery']
        job.task_extra = request.params['task_extra']

        if request.params['license_id'] != "":
            license_id = int(request.params['license_id'])
            license = session.query(License).get(license_id)
            job.license = license

        session.add(job)
        return HTTPFound(location = route_url('job', request, job=job.id))

    return dict(job=job, licenses=licenses)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def task(request):
    job_id = request.matchdict['job']
    x = request.matchdict['x']
    y = request.matchdict['y']
    session = DBSession()
    tile = session.query(Tile).get((x, y, job_id))
    checkTask(tile)
    if tile is None:
        return HTTPNotFound()
    polygon=tile.to_polygon()
    username = authenticated_userid(request)
    user = session.query(User).get(username)
    time_left = 'null'
    if tile.user != user:
        request.session.flash('You cannot see this task.')
        return HTTPFound(location=request.route_url('job', job=job_id))
    if tile.checkout:
        time_left = (tile.checkout - (datetime.now() - EXPIRATION_DURATION)) \
            .seconds
    return dict(tile=tile,
            time_left=time_left,
            feature=dumps(polygon),
            user=user,
            job=tile.job,
            job_url=request.route_url('job', job=job_id),
            done_url=request.route_url('task_done', job=job_id, x=x, y=y))

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def task_xhr(request):
    job_id = request.matchdict['job']
    x = request.matchdict['x']
    y = request.matchdict['y']
    zoom = request.matchdict['zoom']
    session = DBSession()
    tile = session.query(Tile).get((x, y, zoom, job_id))
    if tile is None:
        return HTTPNotFound()
    username = authenticated_userid(request)
    user = session.query(User).get(username)
    time_left = 'null'
    #if tile.user != user:
        #request.session.flash('You cannot see this task.')
        #return HTTPFound(location=request.route_url('job', job=job_id))
    if tile.update:
        time_left = (tile.update - (datetime.now() - EXPIRATION_DURATION)) \
            .seconds
    filter = and_(TileHistory.x==x, TileHistory.y==y, TileHistory.job_id==job_id)
    history = session.query(TileHistory).filter(filter)\
        .order_by(TileHistory.update)\
        .all()

    current_task = get_locked_task(job_id, username)
    log.debug(
        'Tile username: %s, checkout: %s, checkin: %s',
        tile.username, tile.checkout, tile.checkin
    )
    return dict(tile=tile,
            current_task=current_task,
            history=history,
            time_left=time_left,
            user=user,
            job=tile.job)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def task(request):
    job_id = request.matchdict['job']
    x = request.matchdict['x']
    y = request.matchdict['y']
    zoom = request.matchdict['zoom']
    session = DBSession()
    tile = session.query(Tile).get((x, y, zoom, job_id))
    if tile is None:
        return HTTPNotFound()
    username = authenticated_userid(request)
    user = session.query(User).get(username)
    time_left = 'null'
    if tile.user != user:
        request.session.flash('You cannot see this task.')
        return HTTPFound(location=request.route_url('job', job=job_id))
    if tile.update:
        time_left = (tile.update - (datetime.now() - EXPIRATION_DURATION)) \
            .seconds
    filter = and_(TileHistory.x==x, TileHistory.y==y, TileHistory.job_id==job_id)
    history = session.query(TileHistory).filter(filter).all()
    return dict(tile=tile,
            history=history,
            time_left=time_left,
            user=user,
            job=tile.job)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def home(request):
    session = DBSession()
    username = authenticated_userid(request)
    user = session.query(User).get(username)
    jobs = session.query(Job).order_by(desc(Job.id))
    if user is None:
        redirect = request.params.get("redirect", request.route_url("logout")) 
        return HTTPFound(location=redirect)
    if not user.is_admin():
        jobs = [job for job in jobs if not job.is_private and job.status == 1] + user.private_jobs
    tiles = session.query(Tile) \
        .filter(Tile.username!=None) \
        .group_by(Tile.username)
    # unlock expired tiles
    for tile in tiles:
        checkTask(tile)
    my_jobs = session.query(TileHistory) \
        .filter(TileHistory.username==user.username) \
        .group_by(TileHistory.job_id)
    my_jobs = [tile.job_id for tile in my_jobs]
    
    return dict(jobs=jobs,
            user=user,
            admin=user.is_admin(),
            my_jobs=my_jobs)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def home(request):
    session = DBSession()
    username = authenticated_userid(request)
    user = session.query(User).get(username)
    jobs = session.query(Job).order_by(desc(Job.id))
    tag = request.params.get('tag')
    if user is None:
        redirect = request.params.get("redirect", request.route_url("logout")) 
        return HTTPFound(location=redirect)
    if tag is not None:
        jobs = jobs.filter(Job.tags.any(tag=tag))
    if not user.is_admin():
        jobs = [job for job in jobs if not job.is_private] + user.private_jobs
    tiles = session.query(Tile) \
        .filter(Tile.username!=None) \
        .group_by(Tile.username)
    # unlock expired tiles
    for tile in tiles:
        checkTask(tile)
    users = [tile.username for tile in tiles]
    tags = session.query(Tag).all()
    return dict(jobs=jobs,
            user=user,
            users=users,
            admin=user.is_admin(),
            tags=tags,
            current_tag=tag)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def home(request):
    session = DBSession()
    username = authenticated_userid(request)
    user = session.query(User).get(username)
    jobs = session.query(Job).order_by(desc(Job.id))
    if user is None:
        redirect = request.params.get("redirect", request.route_url("logout"))
        return HTTPFound(location=redirect)
    if not user.is_admin():
        jobs = [job for job in jobs if not job.is_private and job.status == 1] + user.private_jobs
    tiles = session.query(Tile).filter(Tile.username != None).group_by(Tile.username)
    # unlock expired tiles
    for tile in tiles:
        checkTask(tile)
    my_jobs = session.query(TileHistory).filter(TileHistory.username == user.username).group_by(TileHistory.job_id)
    my_jobs = [tile.job_id for tile in my_jobs]

    dthandler = lambda obj: obj.isoformat() if isinstance(obj, datetime.datetime) else None

    def to_five(i):
        return int(round(i / 5)) * 5

    def to_dict(job):
        centroid = job.get_centroid()
        filter = and_(Tile.job == job, Tile.checkout == True, Tile.username != None)
        current_users = session.query(distinct(Tile.username)).filter(filter).all()
        current_users = [u[0] for u in current_users]

        x, y = transform_900913_to_4326(centroid.x, centroid.y)
        left = (x + 180) * 120 / 360 - 1
        top = (-y + 90) * 60 / 180 - 1

        return dict(
            title=job.title,
            status=job.status,
            short_description=markdown(job.short_description),
            author=job.author,
            is_private=job.is_private,
            featured=job.featured,
            last_update=timesince(job.last_update),
            done=job.done,
            users=current_users,
            usersText="Currently working: %s" % ", ".join(current_users),
            url=request.route_url("job", job=job.id),
            feature_url=request.route_url("job_feature", job=job.id),
            archive_url=request.route_url("job_archive", job=job.id),
            publish_url=request.route_url("job_publish", job=job.id),
            edit_url=request.route_url("job_edit", job=job.id),
            tags=[tag.tag for tag in job.tags],
            is_mine=job.id in [_job for _job in my_jobs],
            lon=centroid.x,
            lat=centroid.y,
            left=left,
            top=top,
        )

    jobs = dumps([to_dict(job) for job in jobs], default=dthandler)

    return dict(jobs=jobs, user=user, admin=user.is_admin(), my_jobs=my_jobs)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def user(request):
    session = DBSession()
    profile_user = session.query(User).get(request.matchdict["id"])
    jobs = user_job_info(profile_user.username)

    username = authenticated_userid(request)
    user = session.query(User).get(username)
    admin = user.is_admin()
    return dict(user=profile_user, jobs=jobs, admin=admin)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def home(request):
    session = DBSession()
    username = authenticated_userid(request)
    user = session.query(User).get(username)
    jobs = session.query(Job).order_by(desc(Job.id))
    if not user.is_admin():
        jobs = [job for job in jobs if not job.is_private] + user.private_jobs
    return dict(jobs=jobs,
            user=user,
            admin=user.is_admin())

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def job_tags(request):
    id = request.matchdict['job']
    session = DBSession()
    job = session.query(Job).get(id)
    if 'form.submitted' in request.params:
        new_tag = request.params['tag']
        tag = session.query(Tag).get(new_tag)
        if tag is None:
            tag = Tag(new_tag)
        if (tag in job.tags) is False:
            job.tags.append(tag)

    all_tags = session.query(Tag).order_by('tag').all()
    return dict(job=job, all_tags=all_tags)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def job_users(request):
    id = request.matchdict['job']
    session = DBSession()
    job = session.query(Job).get(id)
    if 'form.submitted' in request.params:
        username = request.params['username']
        user = session.query(User).get(username)
        if user:
            job.users.append(user)
            session.flush()
            request.session.flash('User "%s" added to the whitelist!' % username)
        else:
            request.session.flash('User "%s" not found!' % username)
    all_users = session.query(User).order_by('username').all()
    return dict(job=job, all_users=all_users)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def job_user(request):
    id = request.matchdict['job']
    user = request.matchdict['user']
    session = DBSession()
    job = session.query(Job).get(id)

    return get_tiles_for_user(job, user)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def done(request):
    job_id = request.matchdict['job']
    x = request.matchdict['x']
    y = request.matchdict['y']
    zoom = request.matchdict['zoom']
    session = DBSession()
    username = authenticated_userid(request)
    tile = session.query(Tile).get((x, y, zoom, job_id))
    tile.comment = request.params['comment']
    if 'invalidate' in request.params:
        # task goes back to the queue
        tile.checkin = 0
        tile.username = username
    elif 'validate' in request.params:
        # task goes back to the queue
        tile.checkin = 2
        tile.username = username
    else:
        #task is done
        tile.checkin = 1
    tile.change = True
    tile.checkout = False
    session.add(tile)
    session.flush()

    # reset tile values
    tile.username = None
    tile.change = False
    tile.comment = None
    session.add(tile)
    return dict(success=True, tile=dict(x=tile.x, y=tile.y, z=tile.zoom))

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import query [as 别名]
def get_locked_task(job_id, username):
    session = DBSession()
    try:
        filter = and_(Tile.username==username, Tile.checkout==True, Tile.job_id==job_id)
        return session.query(Tile).filter(filter).one()
    except NoResultFound, e:
        return None