Python models.DBSession类代码示例

def checkTask(tile):
    session = DBSession()
    if tile.username is not None:
        if datetime.now() > tile.update + EXPIRATION_DURATION:
            tile.username = None 
            tile.update = datetime.now()
            session.add(tile)

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)

def get_users(job):
    """ the changes (date, checkin) to create the list of users with """
    """ get the tiles that changed """
    session = DBSession()
    # filter on tiles with changes, for this job, that have a username and have
    # checkin status == 1 (validation)
    filter = and_(
        TileHistory.change == True, TileHistory.job_id == job.id,
        TileHistory.username != None, TileHistory.checkin == 1,
        TileHistory.version > 0
    )
    # get the users, and order by username (IMPORTANT for group_by later)
    working_users = (
        session.query(
            TileHistory.username, TileHistory.x, TileHistory.y,
            TileHistory.zoom
        )
        .filter(filter)
        .order_by(TileHistory.username)
        .all()
    )

    # create a dictionary of users, grouped by username (aggregate tiles)
    # groupby will produce a key: grouper_object dictionary, so we use a list
    # comprehension to evaluate and expand every grouper_object
    users_grouped = {
        user[0]: [
            tile[1:] for tile in user[1]
        ]
        for user in itertools.groupby(working_users, key=lambda user: user[0])
    }

    log.debug('Users worked on job %s: %s', job.id, len(users_grouped))

    return users_grouped

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)

def task_export(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))
    return dict(polygon=tile.to_polygon(4326))

def checkTask(tile):
    session = DBSession()
    if tile.checkout is not None:
        if datetime.now() > tile.checkout + EXPIRATION_DURATION:
            tile.username = None 
            tile.checkout = None 
            session.add(tile)

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

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))

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)

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)

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))

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)

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)

def user_update(request):
    session = DBSession()
    user = session.query(User).get(request.matchdict["id"])
    if "form.submitted" in request.params:
        user.admin = True if "admin" in request.params else False
        session.flush()
        # request.session.flash('Profile correctly updated!')
    return HTTPFound(location=request.route_url("user", id=user.username))

def profile_update(request):
    if 'form.submitted' in request.params:
        session = DBSession()
        username = authenticated_userid(request)
        user = session.query(User).get(username)
        user.role = request.params['role']
        session.flush()
        request.session.flash('Profile correctly updated!')
    return HTTPFound(location=request.route_url('profile'))