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 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 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 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 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(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 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 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 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 job_export(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
import shapefile
w = shapefile.Writer(shapefile.POLYGON)
w.field('checkin', 'N', 1, 0)
for tile in job.tiles:
polygon = tile.to_polygon(4326)
coords = polygon.exterior.coords
parts = [[[x, y] for (x, y) in coords]]
w.poly(parts=parts)
w.record(tile.checkin)
# FIXME we should a temp directory
w.save('/tmp/tiles')
import zipfile
myzip = zipfile.ZipFile('/tmp/tiles.zip', 'w', zipfile.ZIP_DEFLATED)
myzip.write('/tmp/tiles.shp', job.title + '/tiles.shp')
myzip.write('/tmp/tiles.dbf', job.title + '/tiles.dbf')
myzip.write('/tmp/tiles.shx', job.title + '/tiles.shx')
myzip.close()
content_disposition = 'attachment; filename=export.zip'
return request.get_response(
FileApp('/tmp/tiles.zip',
**{"Content-Disposition": content_disposition}))
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 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 checkTask(tile):
session = DBSession()
if tile.checkout is not False and tile.checkout is not None:
if datetime.now() > tile.update + EXPIRATION_DURATION:
tile.username = None
tile.checkout = False
tile.update = datetime.now()
session.add(tile)
def task_export(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))
return dict(polygon=tile.to_polygon(4326))
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 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'))
def job_preset(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
response = Response()
response.text = job.josm_preset
response.content_disposition = 'attachment; filename=hotosm_tasking_manager_job_%s.xml' % job.id
response.content_type = 'application/x-josm-preset'
return response
def job_preset(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
response = Response()
response.text = job.josm_preset
response.content_disposition = 'attachment; filename=hotosm_tasking_manager_job_%s.xml' % job.id
response.content_type = 'application/x-josm-preset'
return response
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)
def job_tiles(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
tiles = []
for tile in job.tiles:
tiles.append(Feature(geometry=tile.to_polygon(),
id=str(tile.x) + '-' + str(tile.y) + '-' + str(tile.zoom)))
return FeatureCollection(tiles)
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))
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))
def nextview(request):
session = DBSession()
username = authenticated_userid(request)
user = session.query(User).get(username)
redirect = request.params.get("redirect", request.route_url("home"))
if "accepted_terms" in request.params:
user.accepted_nextview = request.params["accepted_terms"] == "I AGREE"
return HTTPFound(location=redirect)
else:
return dict(user=user, redirect=redirect)
def unlock(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))
tile.username = None
tile.checkout = None
session.add(tile)
return HTTPFound(location=request.route_url('job', job=job_id))
def job_feature(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
job.featured = not job.featured
session.add(job)
request.session.flash('Job "%s" featured status changed!' % job.title)
return HTTPFound(location = route_url('home', request))
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())
def job_feature(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
job.featured = not job.featured
session.add(job)
request.session.flash('Job "%s" featured status changed!' % job.title)
return HTTPFound(location=route_url('home', request))
def nextview(request):
session = DBSession()
username = authenticated_userid(request)
user = session.query(User).get(username)
redirect = request.params.get("redirect", request.route_url("home"))
if "accepted_terms" in request.params:
user.accepted_nextview = request.params["accepted_terms"] == "I AGREE"
return HTTPFound(location=redirect)
else:
return dict(user=user, redirect=redirect)
def job_publish(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
job.status = 1
session.add(job)
request.session.flash('Job "%s" published!' % job.title)
return HTTPFound(location = route_url('home', request))
def job_publish(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
job.status = 1
session.add(job)
request.session.flash('Job "%s" published!' % job.title)
return HTTPFound(location=route_url('home', request))
def job_tiles(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
tiles = []
for tile in job.tiles:
tiles.append(
Feature(geometry=tile.to_polygon(),
id=str(tile.x) + '-' + str(tile.y) + '-' + str(tile.zoom)))
return FeatureCollection(tiles)
def job_tiles_status(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
tiles = {}
for tile in job.tiles:
if tile.username is not None or tile.checkin != 0:
tiles[str(tile.x) + '-' + str(tile.y)] = dict(
checkin=tile.checkin,
username=tile.username)
return tiles
def unlock(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))
tile.username = None
tile.update = datetime.now()
session.add(tile)
return dict(job=tile.job,
prev_task=tile)
def get_tiles_for_user(job, username):
session = DBSession()
""" get the tiles that changed """
filter = and_(TileHistory.change==True, TileHistory.job_id==job.id,
TileHistory.checkin>=1, TileHistory.username == username)
tiles = session.query(TileHistory.x, TileHistory.y, TileHistory.zoom) \
.filter(filter) \
.all()
return tiles
def job_tiles(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
tiles = []
for tile in job.tiles:
checkout = None
if tile.username is not None:
checkout = tile.update.isoformat()
tiles.append(Feature(geometry=tile.to_polygon(),
id=str(tile.x) + '-' + str(tile.y)))
return FeatureCollection(tiles)
def unlock(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))
tile.username = None
tile.checkout = False
tile.change = False
session.add(tile)
return dict(job=tile.job, prev_task=tile)
def license_edit(request):
id = request.matchdict['license']
session = DBSession()
license = session.query(License).get(id)
if 'form.submitted' in request.params:
license.name = request.params['name']
license.description = request.params['description']
license.plain_text = request.params['plain_text']
session.add(license)
request.session.flash('License updated!')
return dict(license=license)
def job_tiles_status(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
tiles = {}
for tile in job.tiles:
if tile.username is not None and tile.checkout is True \
or tile.checkin != 0:
tiles[str(tile.x) + '-' + str(tile.y) + '-' +
str(tile.zoom)] = dict(
checkin=tile.checkin,
username=(tile.username
if tile.checkout is True else None))
return tiles
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)
def license(request):
session = DBSession()
id = request.matchdict['license']
license = session.query(License).get(id)
username = authenticated_userid(request)
user = session.query(User).get(username)
redirect = request.params.get("redirect", request.route_url("home"))
if "accepted_terms" in request.params:
if request.params["accepted_terms"] == "I AGREE":
user.accepted_licenses.append(license)
elif license in user.accepted_licenses:
user.accepted_licenses.remove(license)
return HTTPFound(location=redirect)
else:
return dict(user=user, license=license, redirect=redirect)
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)
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)
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))
def job(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
if job is None:
request.session.flash("Sorry, this job doesn't exist")
return HTTPFound(location=route_url('home', request))
for tile in job.tiles:
checkTask(tile)
username = authenticated_userid(request)
user = session.query(User).get(username)
try:
filter = and_(Tile.username == username, Tile.checkout == True,
Tile.job_id == job.id)
current_task = session.query(Tile).filter(filter).one()
except NoResultFound, e:
current_task = None
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))
def done(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))
tile.comment = request.params['comment']
if 'invalidate' in request.params:
# task goes back to the queue
tile.checkin = 0
elif 'validate' in request.params:
# task in validated
tile.checkin = 2
else:
#task is done
tile.checkin = 1
tile.checkout = False
tile.change = True
session.add(tile)
return dict(job=tile.job)
def job_edit(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
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.requires_nextview = request.params.get('requires_nextview') == 'on'
job.imagery = request.params['imagery']
session.add(job)
return HTTPFound(location=route_url('job', request, job=job.id))
return dict(job=job)
def test_task_take(self):
headers = self.__remember('foo')
try:
res = self.testapp.get('/job/1/task/32774/42026/take', headers=headers,
status=302)
self.assertEquals(res.location,
'http://localhost/job/1/task/32774/42026')
res2 = self.testapp.get(res.location, headers=headers,
status=200)
form = res2.form
res3 = form.submit(headers=headers, status=302)
res4 = res3.follow(headers=headers, status=200)
from OSMTM.models import DBSession, Tile
session = DBSession()
tile = session.query(Tile).get((32774, 42026, 1))
self.assertEquals(tile.checkin, 1)
res5 = form.submit(headers=headers)
tile = session.query(Tile).get((32774, 42026, 1))
self.assertEquals(tile.checkin, 1)
finally:
self.__forget()
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))
def job_new(request):
if 'form.submitted' in request.params:
session = DBSession()
job = Job(request.params['title'], request.params['geometry'],
request.params['zoom'], authenticated_userid(request))
session.add(job)
session.flush()
return HTTPFound(location=route_url('job_edit', request, job=job.id))
return {}
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)
def split_tile(request):
job_id = request.matchdict['job']
x = request.matchdict['x']
y = request.matchdict['y']
zoom = request.matchdict['zoom']
session = DBSession()
job = session.query(Job).get(job_id)
tile = session.query(Tile).get((x, y, zoom, job_id))
session.delete(tile)
new_tiles = []
t = []
for i in range(0, 2):
for j in range(0, 2):
tile = Tile(int(x) * 2 + i, int(y) * 2 + j, int(zoom) + 1)
tile.job = job
t.append(tile)
for tile in t:
new_tiles.append(
Feature(geometry=tile.to_polygon(),
id=str(tile.x) + '-' + str(tile.y) + '-' + str(tile.zoom)))
return dict(job=tile.job,
split_id="-".join([x, y, zoom]),
new_tiles=FeatureCollection(new_tiles))
def job_delete(request):
id = request.matchdict['job']
session = DBSession()
# prevent integrity errors
tiles_history = session.query(TileHistory).filter(TileHistory.job_id == id)
for tile in tiles_history:
session.delete(tile)
job = session.query(Job).get(id)
title = job.title
session.delete(job)
# remove the tiles history twice because removing records from main table
# adds records in the history table
tiles_history = session.query(TileHistory).filter(TileHistory.job_id == id)
for tile in tiles_history:
session.delete(tile)
request.session.flash('Job "%s" removed!' % title)
return HTTPFound(location=route_url('home', request))
def get_stats(job):
session = DBSession()
filter = and_(Tile.job_id == job.id, Tile.checkout == True)
users = session.query(Tile.username).filter(filter)
current_users = [user.username for user in users]
users = {}
user = None
""" the changes (date, checkin) to create a chart with """
changes = []
def read_tiles(tiles):
for ndx, i in enumerate(tiles):
if i.username is not None:
if not users.has_key(i.username):
users[i.username] = StatUser()
user = users[i.username]
date = i.update
if i.checkin == 1:
user.done += 1
if i.checkin == 2 or i.checkin == 0:
user.validated += 1
""" maintain compatibility for jobs that were created before the
'update' column creation """
date = i.update
changes.append((date, i.checkin))
""" get the tiles that changed """
filter = and_(TileHistory.change == True, TileHistory.job_id == job.id,
TileHistory.username is not None)
tiles = session.query(TileHistory) \
.filter(filter) \
.all()
read_tiles(tiles)
""" same for tiles """
filter = and_(Tile.change == True, Tile.job_id == job.id, Tile.username
is not None)
tiles = session.query(Tile) \
.filter(filter) \
.all()
read_tiles(tiles)
contributors = []
validators = []
for i in users:
""" only keep users who have actually done something
or who are currently working on a task """
if users[i].done != 0 or i in current_users:
contributors.append((i, users[i].done, i in current_users))
if users[i].validated != 0:
validators.append((i, users[i].validated))
changes = sorted(changes, key=lambda value: value[0])
chart_done = []
chart_validated = []
done = 0
validated = 0
for date, checkin in changes:
if checkin == 1:
done += 1
chart_done.append([date.isoformat(), done])
if checkin == 2:
validated += 1
chart_validated.append([date.isoformat(), validated])
if checkin == 0:
done -= 1
chart_done.append([date.isoformat(), done])
return dict(current_users=current_users,
contributors=contributors,
validators=validators,
chart_done=simplejson.dumps(chart_done),
chart_validated=simplejson.dumps(chart_validated))
def job_geom(request):
id = request.matchdict['job']
session = DBSession()
job = session.query(Job).get(id)
return FeatureCollection([Feature(id=id, geometry=loads(job.geometry))])
