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