def project_new_arbitrary(request):
    _ = request.translate
    ngettext = request.plural_translate

    user_id = authenticated_userid(request)
    user = DBSession.query(User).get(user_id)

    try:
        project = Project(
            _(u'Untitled project'),
            user
        )
        count = project.import_from_geojson(request.POST['geometry'])
        request.session.flash(
            ngettext('Successfully imported ${n} geometry',
                     'Successfully imported ${n} geometries',
                     count,
                     mapping={'n': count}),
            'success')
        return HTTPFound(location=route_path('project_edit', request,
                         project=project.id))
    except Exception, e:
        msg = _("Sorry, could not create the project. <br />%s") % e.message
        request.session.flash(msg, 'alert')
        raise HTTPFound(location=route_path('project_new', request))

 def test_resources_with_parent_resource(self):
     self.config.add_resource('pyramid_routehelper.tests:DummyCrudHandler',
                              'message', 'messages',
                              parent_resource = dict(member_name='category', collection_name='categories'))
     
     assert route_path('category_messages', testing.DummyRequest(), category_id=2) == '/categories/2/messages'
     assert route_path('category_message', testing.DummyRequest(), category_id=2, id=1) == '/categories/2/messages/1'

def menu(request):
    """
        returns the main menu
    """
    # TODO : view/edit permission ...
    menu = (
        dict(label="Users", url=route_path("users", request), title="User management", icon=""),
        dict(label="Contacts", url=route_path("contacts", request), title="Contact and relationships", icon=""),
    )
    return dict(menu=menu)

    def test_basic_resources(self):
        from nefertari.resource import add_resource_routes
        add_resource_routes(self.config, DummyCrudView, 'message', 'messages')

        self.assertEqual(
            '/messages',
            route_path('messages', testing.DummyRequest())
        )
        self.assertEqual(
            '/messages/1',
            route_path('message', testing.DummyRequest(), id=1)
        )

    def test_singular_resource(self, *a):
        View = get_test_view_class()
        config = _create_config()
        root = config.get_root_resource()
        root.add('thing', view=View)
        grandpa = root.add('grandpa', 'grandpas', view=View)
        wife = grandpa.add('wife', view=View, renderer='string')
        wife.add('child', 'children', view=View)

        config.begin()
        app = TestApp(config.make_wsgi_app())

        self.assertEqual(
            '/grandpas/1/wife',
            route_path('grandpa:wife', testing.DummyRequest(), grandpa_id=1)
        )

        self.assertEqual(
            '/grandpas/1',
            route_path('grandpa', testing.DummyRequest(), id=1)
        )

        self.assertEqual(
            '/grandpas/1/wife/children/2',
            route_path('grandpa_wife:child', testing.DummyRequest(),
                       grandpa_id=1, id=2)
        )

        self.assertEqual(app.put('/grandpas').body, six.b('update_many'))
        self.assertEqual(app.head('/grandpas').body, six.b(''))
        self.assertEqual(app.options('/grandpas').body, six.b(''))

        self.assertEqual(app.delete('/grandpas/1').body, six.b('delete'))
        self.assertEqual(app.head('/grandpas/1').body, six.b(''))
        self.assertEqual(app.options('/grandpas/1').body, six.b(''))

        self.assertEqual(app.put('/thing').body, six.b('replace'))
        self.assertEqual(app.patch('/thing').body, six.b('update'))
        self.assertEqual(app.delete('/thing').body, six.b('delete'))
        self.assertEqual(app.head('/thing').body, six.b(''))
        self.assertEqual(app.options('/thing').body, six.b(''))

        self.assertEqual(app.put('/grandpas/1/wife').body, six.b('replace'))
        self.assertEqual(app.patch('/grandpas/1/wife').body, six.b('update'))
        self.assertEqual(app.delete('/grandpas/1/wife').body, six.b('delete'))
        self.assertEqual(app.head('/grandpas/1/wife').body, six.b(''))
        self.assertEqual(app.options('/grandpas/1/wife').body, six.b(''))

        self.assertEqual(six.b('show'), app.get('/grandpas/1').body)
        self.assertEqual(six.b('show'), app.get('/grandpas/1/wife').body)
        self.assertEqual(
            six.b('show'), app.get('/grandpas/1/wife/children/1').body)

def motion_add(request):
    """create a new motion.
    
    1. show new motion form
    2. save to database after user submit
    """
    
    # initialize the form to select all participants
    all_users = load_users()
    all_user_options = [(itm.id, itm.name) for itm in all_users]
    selected_users = [itm.id for itm in all_users]

    # add four blank options on new motion form
    form = Form(request, schema=MotionSchema, defaults=dict(participants = selected_users, 
                                                            options=["","","",""]))
    
    if form.validate():
        title = form.data.get("title")
        desc = form.data.get("desc")
        options = form.data.get("options")
        users = form.data.get("participants")

        add_motion(title, desc, options, users)

        return HTTPFound(location=route_path('motion_list', request))
        
    return dict(renderer=FormRenderer(form), all_user_options=all_user_options)

def result_view(request):
  logger.info("result_view")
  image = request.session.get('image')
  logger.debug('From session got image: {0}'.format(image))
  if not image:
    return HTTPFound(location=route_path('home', request))

  def retrieve_similar_images(ref, images):
    img_distance_pairs = [(img, ImgStatisticCounter.distance(ref, img)
                           , ImgStatisticCounter.deviation_distance(ref, img))
                          for img in images]
    img_distance_pairs.sort(key=lambda (image, distance, deviation): distance)
    result = []
    for pair in img_distance_pairs:
        if not ImgStatisticCounter.are_similar(ref, pair[0]):
            break
        result.append(pair)
    return result

  images = retrieve_similar_images(
    ref=image,
    images=DBManager.retrieve_all_except_one(image_id=image['id'])
  )

  return {
    'image': image,
    'images': images,
    'page_name': 'Result'
  }

    def route(self, route_name, *elements, **kw):
        """Generate a route URL.

        I return a URL based on a named route. Calling the URLGenerator 
        instance is the same as calling me.
        If the constructor arg 'qualified' is true, I call
        ``pyramid.url.route_url``, otherwise I call ``pyramid.url.route_path``.

        Arguments: 

        * ``route_name``: the name of a route.
        * ``*elements``: additional segments to append to the URL path.


        Keyword arguments are passed to the underlying function. The following
        are recognized:

        * ``_query``: the query parameters. May be a dict-like object with
          a ``.items()`` method or a sequence of 2-tuples.
        * ``_anchor``: the URL's "#ancor" fragment without the "#".
        * ``_app_url``: override the "scheme://host" prefix. (This also causes
          the result to be qualified if it wouldn't otherwise be.)
        * Other keyword args override path variables defined in the route.

        If the relevant route has a *pregenerator* defined, it may modify the
        elements or keyword args.
        """
        if self.qualified or "_app_url" in kw:
            return url.route_url(route_name, self.request, *elements, **kw)
        else:
            return url.route_path(route_name, self.request, *elements, **kw)

def project(request):
    check_project_expiration()
    id = request.matchdict['project']
    project = DBSession.query(Project).get(id)

    if project is None:
        _ = request.translate
        request.session.flash(_("Sorry, this project doesn't  exist"))
        return HTTPFound(location=route_path('home', request))

    project.locale = get_locale_name(request)

    filter = and_(TaskState.project_id == id,
                  TaskState.state != TaskState.state_removed,
                  TaskState.state != TaskState.state_ready)
    history = DBSession.query(TaskState) \
                       .filter(filter) \
                       .order_by(TaskState.date.desc()) \
                       .limit(20).all()

    user_id = authenticated_userid(request)
    locked_task = None
    user = None
    if user_id:
        user = DBSession.query(User).get(user_id)
        locked_task = get_locked_task(project.id, user)

    features = []
    for area in project.priority_areas:
        features.append(Feature(geometry=shape.to_shape(area.geometry)))

    return dict(page_id='project', project=project,
                locked_task=locked_task,
                history=history,
                priority_areas=FeatureCollection(features),)

def project_new_grid(request):
    if 'zoom' in request.params:

        user_id = authenticated_userid(request)
        user = DBSession.query(User).get(user_id)
        project = Project(
            u'Untitled project',
            user
        )

        DBSession.add(project)
        DBSession.flush()

        zoom = int(request.params['zoom'])

        geometry = request.params['geometry']

        polygons = parse_geojson(geometry)
        from shapely.geometry import MultiPolygon
        multipolygon = MultiPolygon([polygon for polygon in polygons])

        geometry = shape.from_shape(multipolygon, 4326)
        project.area = Area(geometry)
        project.auto_fill(zoom)

        _ = request.translate
        request.session.flash(_("Project #${project_id} created successfully",
                              mapping={'project_id': project.id}),
                              'success')
        return HTTPFound(location=route_path('project_edit', request,
                                             project=project.id))

    return dict(page_id='project_new_grid')

def promote_owner(request):
	userid = request.matchdict['id']
	promuser = DBSession.query(User).get(userid)

	promuser.role = User.role_owner if not promuser.is_owner else None
	DBSession.flush()

	return HTTPFound(location=route_path('admin_user_list',request))

def project_publish(request):
    id = request.matchdict['project']
    project = DBSession.query(Project).get(id)

    project.status = project.status_published

    return HTTPFound(location=route_path('project', request,
                                         project=project.id))

def book_delete(request):
    try:
        book_id = int(request.matchdict['id'])
        if book_id:
            DBSession.query(Book).filter(Book.id==book_id).delete()
        return HTTPFound(location=route_path("book_list", request))
    except Exception:
        return HTTPForbidden()

    def test_resources_with_path_prefix_with_trailing_slash(self):
        from nefertari.resource import add_resource_routes
        add_resource_routes(
            self.config,
            DummyCrudView,
            'message',
            'messages',
            path_prefix='/category/{category_id}/'
        )

        self.assertEqual(
            '/category/2/messages',
            route_path('messages', testing.DummyRequest(), category_id=2)
        )
        self.assertEqual(
            '/category/2/messages/1',
            route_path('message', testing.DummyRequest(), id=1, category_id=2)
        )

def user_validator(request):
    id = request.matchdict['id']
    user = DBSession.query(User).get(id)

    user.role ^= User.role_validator
    DBSession.flush()

    return HTTPFound(location=route_path("user", request,
                                         username=user.username))

def user_add(request):
    form = Form(request, schema=UserSchema)

    if form.validate():

        add_user(form.data.get("name"), form.data.get("email"), form.data.get("vote_weight"))
        return HTTPFound(location=route_path("user_list", request))

    return dict(renderer=FormRenderer(form))

def add_urlhelpers(event):
    """
    Add helpers to the template engine.
    """
    event['static_url'] = lambda x: static_path(x, event['request'])
    event['route_url'] = lambda name, *args, **kwargs: \
        route_path(name, event['request'], *args, **kwargs)
    event['parse_rest'] = parse_rest
    event['has_permission'] = event['request'].has_permission

def genpadname(request):
    """
        Redirect to a new pad with a random name
    """
    all_pads = [p.get_name() for p in get_all_pads()]
    name = gen_random()
    while name in all_pads:
        name = gen_random()
    return HTTPFound(route_path('pad', request, padid=name))

def user_delete(request):
    id = request.matchdict['id']
    user = load_user(id)

    if not user:
        return HTTPUnauthorized()
    
    delete_user(id)

    return HTTPFound(location=route_path("user_list", request))

def crime_delete(request):
    try:

        crime_id = int(request.matchdict['id'])
        
        if crime_id:
            DBSession.query(Crime).filter(Crime.id==crime_id).delete()
        return HTTPFound(location=route_path("crimes", request))
    except Exception:
        return HTTPForbidden()