Python DBSession.flush方法代码示例

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [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 flush [as 别名]
def oauth_callback(request):
    # the request token we have in the user session should be the same
    # as the one passed to the callback
    session = request.session
    request_token = session.get('request_token')
    if request.params.get('oauth_token') != request_token['oauth_token']:
        return HTTPBadRequest('Tokens don\'t match')
    # get the access token
    token = oauth.Token(request_token['oauth_token'],
                        request_token['oauth_token_secret'])
    verifier = request.params.get('oauth_verifier')
    token.set_verifier(verifier)
    client = oauth.Client(consumer, token)
    resp, content = client.request(ACCESS_TOKEN_URL, "POST")
    access_token = dict(urlparse.parse_qsl(content))
    token = access_token['oauth_token']
    token_secret = access_token['oauth_token_secret']
    # get the user details, finally
    token = oauth.Token(token, token_secret)
    client = oauth.Client(consumer, token)
    resp, content = client.request(USER_DETAILS_URL, "GET")
    user_elt = ElementTree.XML(content).find('user')
    # save the user's "display name" in the session
    if 'display_name' in user_elt.attrib:
        username = user_elt.attrib['display_name']
        db_session = DBSession()
        if db_session.query(User).get(username) is None:
            db_session.add(User(username))
            db_session.flush()
        headers = remember(request, username, max_age=20*7*24*60*60)

    # and redirect to the main page
    return HTTPFound(location=session.get('came_from'), headers=headers)

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
def user_add(request):
    session = DBSession()
    username = request.params.get("username")
    if session.query(User).get(username) is None:
        session.add(User(username))
        session.flush()
    return HTTPFound(location=request.route_url("user", id=username))

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
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))

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
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
        user.accepted_nextview = request.params.get('accepted_nextview') == 'on'
        session.flush()
        #request.session.flash('Profile correctly updated!')
    return HTTPFound(location=request.route_url('user',id=user.username))

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

    session.delete(license)
    session.flush()
    request.session.flash('License removed!')
    return HTTPFound(location = route_url('licenses', request))

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
def user_update(request):
    session = DBSession()
    user = session.query(User).get(request.matchdict["id"])
    if 'form.submitted' in request.params:
        user.role = request.params['role']
        user.accepted_nextview = request.params.get('accepted_nextview', 0)
        session.flush()
        request.session.flash('Profile correctly updated!')
    return HTTPFound(location=request.route_url('user',id=user.username))

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
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'))

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
def license_new(request):
    session = DBSession()
    license = License()
    license.name = ''
    license.description = ''
    license.plain_text = ''

    session.add(license)
    session.flush()
    return HTTPFound(location = route_url('license_edit', request, license=license.id))

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
def job_new(request):
    if 'form.submitted' in request.params:
        session = DBSession()
        job = Job(
            request.params['title'],
            request.params['geometry'],
            request.params['zoom']
        )

        session.add(job)
        session.flush()
        return HTTPFound(location = route_url('job_edit', request, job=job.id))
    return {} 

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [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 flush [as 别名]
def job_new(request):
    if 'form.submitted' in request.params:
        session = DBSession()
        job = Job(
            request.params['title'],
            request.params['short_description'],
            request.params['description'],
            request.params['workflow'],
            request.params['geometry'],
            request.params['zoom'],
            request.params.get('is_private', 0),
            request.params['imagery'],
            request.params.get('requires_nextview', 0)
        )

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

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
def job_new(request):
    if "form.submitted" in request.params:
        session = DBSession()
        job = Job()
        job.title = request.params["title"]
        job.description = request.params["description"]
        job.geometry = request.params["geometry"]
        job.workflow = request.params["workflow"]
        job.imagery = request.params["imagery"]
        job.zoom = request.params["zoom"]
        job.is_private = request.params.get("is_private", 0)
        job.requires_nextview = request.params.get("requires_nextview", 0)

        tiles = []
        for i in get_tiles_in_geom(loads(job.geometry), int(job.zoom)):
            tiles.append(Tile(i[0], i[1]))
        job.tiles = tiles

        session.add(job)
        session.flush()
        return HTTPFound(location=route_url("job", request, job=job.id))
    return {}

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
def job_new(request):
    if 'form.submitted' in request.params:
        session = DBSession()
        job = Job()
        job.title = request.params['title']
        job.description = request.params['description']
        job.geometry = request.params['geometry']
        job.workflow = request.params['workflow']
        job.imagery = request.params['imagery']
        job.zoom = request.params['zoom']
        job.is_private = request.params.get('is_private', 0)
        job.requires_nextview = request.params.get('requires_nextview', 0)

        tiles = []
        for i in get_tiles_in_geom(loads(job.geometry), int(job.zoom)):
            tiles.append(Tile(i[0], i[1]))
        job.tiles = tiles

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

# 需要导入模块: from OSMTM.models import DBSession [as 别名]
# 或者: from OSMTM.models.DBSession import flush [as 别名]
from sqlalchemy import create_engine
from OSMTM.models import (
    Tile,
    DBSession
)
import json

engine = create_engine('sqlite:///OSMTM.db')
DBSession.configure(bind=engine)


json_data=open('census.geojson')
data = json.load(json_data)
json_data.close()

x = 0
for f in data['features']:
  wkt = ''
  for c in f['geometry']['coordinates'][0]:
    if wkt != '':
      wkt = wkt + ','
    wkt = wkt + str(c[0]) + " " + str(c[1])

  t = Tile(x,0,0,'POLYGON((' + wkt + '))')
  x = x + 1
  t.job_id = 7

  with transaction.manager:
    DBSession.add(t)
    DBSession.flush()