Example #1
0
    def add(self):
        if 'cancel' in self.request.POST:
            url = resource_url(self.context, self.request)
            return HTTPFound(location=url)

        type = self.request.GET['type']
        obj = createContent(type)
        schema = createSchema(obj.schemas['add']).bind(context = self.context, request = self.request)
        form = Form(schema, buttons=('save', 'cancel',))
        self.register_form_resources(form)

        if 'save' in self.request.POST:
            controls = self.request.POST.items()
            try:
                appstruct = form.validate(controls)
            except ValidationFailure, e:
                self.response['form'] = e.render()
                return self.response
            
            obj.set_field_appstruct(appstruct)
            name = obj.suggest_name(self.context)
            self.context[name] = obj

            url = resource_url(self.context, self.request)
            return HTTPFound(location=url)
Example #2
0
 def edit_topic_get(self):
     edit_form = Form(self.request.topic.edit_schema().bind(request=self.request), buttons=('save',))
     return {
         'page_title': 'Edit Topic',
         'username': self.request.username,
         'edit_form': edit_form.render(self.request.topic.__dict__)
     }
Example #3
0
 def create_member_view(self):
     schema = MemberSchema()
     schema = schema.bind(context = self.context, request = self.request)
     
     form = Form(schema, buttons = ('submit',))
     post = self.request.POST
     
     self.context.f_name = None
     self.context.m_name = None
     self.context.l_name = None
     self.context.birthdate = None
     
     response = {}
     response['form_resources'] = form.get_widget_resources(None)
     if 'submit' in post:
         controls = post.items()
         try:
             appstruct = form.validate(controls)
         except ValidationFailure, e:
             response['form'] = e.render()
             
         self.context.f_name = appstruct['f_name']
         self.context.m_name = appstruct['m_name']
         self.context.l_name = appstruct['l_name']
         self.context.birthdate = appstruct['birthdate']
Example #4
0
 def edit_question_get(self):
     edit_form = Form(self.request.question.edit_schema().bind(request=self.request), buttons=('save',))
     return {
         'page_title': 'Edit Question',
         'username': self.request.username,
         'edit_form': edit_form.render(self.request.question.__dict__),
     }
 def add(self):
     schema = ContentTemplateSchema()
     schema = schema.bind(context = self.context, request = self.request)
     form = Form(schema, buttons=('save',))
     post = self.request.POST
     response = {}
     response['form_resources'] = form.get_widget_resources(None)
     if 'save' in post:
         controls = post.items()
         try:
             appstruct = form.validate(controls)
         except ValidationFailure, e:
             response['form'] = e.render()
             return response
         
         obj = ContentTemplate()
         obj.title = appstruct['title']
         obj.description = appstruct['description']
         obj.fields = appstruct['fields']
         #FIXME: Make adaptable to same titles
         self.context[slugify(obj.title)] = obj
         
         url = resource_url(obj, self.request)
         
         return HTTPFound(location=url)
Example #6
0
    def add(self):
        
        content_type = self.request.params.get('content_type')
        root = find_root(self.context)
        c_t_obj = root[content_type]
        schema = c_t_obj.get_schema(context = self.context, request = self.request)
        form = Form(schema, buttons=('save',))
        post = self.request.POST
        response = {}
        response['form_resources'] = form.get_widget_resources(None)
        if 'save' in post:
            controls = post.items()
            try:
                appstruct = form.validate(controls)
            except ValidationFailure, e:
                response['form'] = e.render()
                return response
            
            obj = MemberData(content_type=content_type, values = appstruct)

            #FIXME: Make adaptable to same titles
            self.context["%s" % len(self.context)] = obj
            
            url = resource_url(obj, self.request)
            
            return HTTPFound(location=url)
 def _fixme_edit(self):
     choices = set()
             
     for (name, plugin) in self.request.registry.getAdapters([self.context], IFieldAdapter):
         choices.add((name,plugin.title))
         
     conTemp = ContentTemplateSchema().bind(choices=choices)
     form = Form(conTemp,buttons=('submit',))
     post = self.request.POST
     if 'submit' in post:
         controls = post.items()
         try:
             appstruct = form.validate(controls)
         except ValidationFailure, e:
             return {'form':e.render(),'form_resources':e.get_widget_resources(None)}
         self.data = {}
         
         for field in appstruct['fields']:
             ft = FieldTemplate()
             ft.title = field['title']
             ft.description = field['description']
             ft.field_type = field['field_type']
             self.context[slugify(ft.title)] = ft
             #self.data[slugify(ft.title)] = ft
             #data[slugify(ft.title)] = ft    #adds to the data array
             #results = ResultsView(self, self.context, self.request)
             #results.set_data(self.data)
         
         #url = resource_url(results, self.request)
         return HTTPFound(appstruct)
    def new(self):
        """ create new model object """
        schema = self.context.schema.bind(db_session=self.context.db_session)
        form = Form(schema, buttons=('add',))
        resources = form.get_widget_resources()
        js_resources = resources['js']
        css_resources = resources['css']
        js_links = [self.request.static_url(r) for r in js_resources]
        css_links = [self.request.static_url(r) for r in css_resources]
        js_tags = [literal('<script type="text/javascript" src="%s"></script>' % link)
                   for link in js_links]
        css_tags = [literal('<link rel="stylesheet" href="%s"/>' % link)
                    for link in css_links]
        resource_tags = js_tags + css_tags

        if self.request.method == 'POST':
            controls = self.request.params.items()
            try:
                params = form.validate(controls)
                item = self.context.add(params)
                del self.request.matchdict['traverse']
                location = self.request.resource_url(
                    self.context,
                    route_name=self.request.matched_route.name,
                    route_kw=self.request.matchdict)

                return HTTPFound(location=location)

            except ValidationFailure as e:
                return dict(form=e.render(), resource_tags=resource_tags)
        return dict(form=form.render(), resource_tags=resource_tags)
Example #9
0
 def get_question_creation_form(self):
     try:
         schema, _ = forms.get_question_creation_schema(self.request.GET)
         action = self.request.route_path('create_question', question_set_id=self.request.GET['question_set_id'])
         form = Form(schema.bind(request=self.request), buttons=('create',), action=action)
         return Response(body=form.render())
     except Exception as _:
         return HTTPClientError()
Example #10
0
def my_post(request):
    form = Form(SampleSchema(), buttons=('up', ))
    controls = request.params.items()
    params = form.validate(controls)
    f = params['image']
    request.response.body = f['fp'].read()
    f['fp'].close()
    return request.response
Example #11
0
 def edit_topic_post(self):
     template_vars = {'page_title': 'Edit Topic', 'username': self.request.username}
     try:
         edit_form = Form(self.request.topic.edit_schema().bind(request=self.request), buttons=('save',))
         appstruct = edit_form.validate(self.request.POST.items())
         self.request.topic.edit(appstruct, self.request.db)
         return HTTPFound(self.request.route_url('profile'))
     except ValueError as e:
         exc = colander.Invalid(edit_form.widget, str(e))
         edit_form.widget.handle_error(edit_form, exc)
         template_vars['edit_form'] = edit_form.render()
     except ValidationFailure as e:
         template_vars['edit_form'] = e.render()
     return template_vars
Example #12
0
 def setup(self):
     question_set_id = self.request.question_set.id
     set_name = self.request.question_set.description
     question_set = self.request.question_set.get_questions(self.request.db)
     try:
         template_vars = {'page_title':'Answer', 'username': self.request.username} #Need better title.
         self.request.session[Session.QUESTION_STATE] = QuestionSetState(question_set, question_set_id, set_name)
         question = self.request.session[Session.QUESTION_STATE].get_current_question()
         schema = question.answer_schema(self.request)
         question_form = Form(schema, buttons=('submit',))
         template_vars['question_form'] = question_form.render()
         return template_vars
     except ValueError as e:
         self.request.session.flash(str(e))
         return HTTPFound(self.request.route_url('profile'))
Example #13
0
 def render_results_view(self):
     strDisp = ""
     if self.data is not None:
         for field in self.data:
             #Allows for concatenation for display
             title = field['title']
             description = field['description']
             field_type = field['field_type']
             
             #concatenating the data
             strDisp = strDisp.concatenate(' %s %s %s ' % (title, description, field_type))
         
     #temporary schema to see if the results are being transferred
     schism = TextSchema().bind(type = ['turtle','peacock'])        
     form = Form(schism,button=('save',))
     #return HTTPFound(strDisp)
     return {'form':form.render(),'form_resources':form.get_widget_resources(None)}
Example #14
0
 def edit(self):
     schema = ContentTemplateSchema()
     schema = schema.bind(context = self.context, request = self.request, field_types = self.get_field_types())
     form = Form(schema, buttons=('save',))
     post = self.request.POST
     response = {}
     response['form_resources'] = form.get_widget_resources(None)
     if 'save' in post:
         controls = post.items()
         try:
             appstruct = form.validate(controls)
         except ValidationFailure, e:
             response['form'] = e.render()
             return response
         self.context.title = appstruct['title']
         self.context.description = appstruct['description']
         self.context.fields = appstruct['fields']
Example #15
0
 def register(self):
     schema = forms.RegistrationSchema().bind(request=self.request)
     form = Form(schema, buttons=('submit',))
     if self.request.method == 'POST' and 'submit' in self.request.POST:
         try:
             appstruct = form.validate(self.request.POST.items())
             user = User.create(appstruct, self.request.db)
             Session.login(self.request.session, user)
             return HTTPFound(self.request.route_url('profile'))
         except ValueError as e:
             exc = colander.Invalid(form.widget, str(e))
             form.widget.handle_error(form,exc)
             rendered_form = form.render()
         except ValidationFailure as e:
             rendered_form = e.render()
     else:
         rendered_form = form.render()
     return {'page_title':'Register', 'form':rendered_form}
Example #16
0
    def profile_vars(self):
        user = User.get_user(Session.user_id(self.request.session),self.request.db)
        template_vars = {
            'csrf_token': self.request.session.get_csrf_token(),
            'page_title':'Profile',
            'username': self.request.username,
            'user':user,
        }
        schema = forms.TopicsSchema().bind(request=self.request)
        add_topic_form = Form(schema, buttons=('add topics',))

        #TODO: Figure out how to make buttons multiple words without uncapitalizing every word after the first.
        if user.topics:
            schema = forms.QuestionSetsSchema().bind(request=self.request,choices=forms.QuestionSetsSchema.prepare_topics(user.topics))
            add_question_set_form = Form(schema, buttons=('add question sets',))
            return template_vars, add_topic_form, add_question_set_form
        else:
            return template_vars, add_topic_form, None
Example #17
0
    def edit_question_post(self):
        template_vars = {'page_title': 'Edit Question', 'username': self.request.username}
        if 'save' in self.request.POST:
            edit_form = Form(self.request.question.edit_schema().bind(request=self.request), buttons=('save',))
            try:
                appstruct = edit_form.validate(self.request.POST.items())
                self.request.question.edit(appstruct, self.request.db)
                #Temporary, need to redirect to question set page
                return HTTPFound(self.request.route_url('profile'))
            except ValueError as e:
                exc = colander.Invalid(edit_form.widget, str(e))
                edit_form.widget.handle_error(edit_form,exc)
                template_vars['edit_form'] = edit_form.render()
            except ValidationFailure as e:
                template_vars['edit_form'] = e.render()
        else:
            return HTTPFound(self.request.route_url('profile'))

        return template_vars
Example #18
0
    def edit(self):
        if 'cancel' in self.request.POST:
            url = resource_url(self.context, self.request)
            return HTTPFound(location=url)

        schema = createSchema(self.context.schemas['edit']).bind(context = self.context, request = self.request)
        form = Form(schema, buttons=('save', 'cancel',))
        self.register_form_resources(form)

        if 'save' in self.request.POST:
            controls = self.request.POST.items()
            try:
                appstruct = form.validate(controls)
            except ValidationFailure, e:
                self.response['form'] = e.render()
                return self.response
            self.context.set_field_appstruct(appstruct)
            url = resource_url(self.context, self.request)
            return HTTPFound(location=url)
Example #19
0
    def login(self):
        schema = forms.LoginSchema().bind(request=self.request)
        form = Form(schema, buttons=('Login',))

        if self.request.method == 'POST' and 'Login' in self.request.POST:
            try:
                appstruct = form.validate(self.request.POST.items())
                user = User.login(appstruct, self.request.db)
                if user:
                    Session.login(self.request.session, user)
                    return HTTPFound(self.request.route_url('profile'))
                else:
                    exc = colander.Invalid(form.widget, 'Username or password is incorrect.')
                    form.widget.handle_error(form, exc)
                    rendered_form = form.render()
            except ValidationFailure as e:
                rendered_form = e.render()
        else:
            rendered_form = form.render()
        return {'page_title':'Login','form':rendered_form}
Example #20
0
 def create_question(self):
     template_vars = {
         'page_title': 'Create Question',
         'username': self.request.username,
         'question_choices': forms.get_question_select_options(self.request.route_url('question_creation_form')),
     }
     if self.request.method == 'POST':
         try:
             schema, question_type = forms.get_question_creation_schema(self.request.POST)
             action = self.request.route_path('create_question', question_set_id=self.request.question_set.id)
             form = Form(schema.bind(request=self.request), buttons=('create',), action=action)
             appstruct = form.validate(self.request.POST.items())
             question_set_id = self.request.matchdict['question_set_id']
             Question.create(question_set_id, appstruct, self.request.db)
             return HTTPFound(self.request.route_url('profile'))
         except ValueError as e:
             exc = colander.Invalid(form.widget, str(e))
             form.widget.handle_error(form,exc)
             template_vars['form'] = (question_type, form.render())
         except ValidationFailure as e:
             template_vars['form'] = (question_type, e.render())
     return template_vars
    def __call__(self):
        schema = self.context.schema.bind(db_session=self.context.db_session)
        form = Form(schema, buttons=('save',))
        resources = form.get_widget_resources()
        js_resources = resources['js']
        css_resources = resources['css']
        js_links = [self.request.static_url(r) for r in js_resources]
        css_links = [self.request.static_url(r) for r in css_resources]
        js_tags = [literal('<script type="text/javascript" src="%s"></script>' % link)
                   for link in js_links]
        css_tags = [literal('<link rel="stylesheet" href="%s"/>' % link)
                    for link in css_links]
        resource_tags = js_tags + css_tags

        if self.request.method == 'POST':
            controls = self.request.params.items()
            try:
                params = form.validate(controls)
            except ValidationFailure as e:
                return dict(form=e.render(), resource_tags=resource_tags)
        return dict(form=form.render(self.context.appstruct),
                    resource_tags=resource_tags)
def get_method_schema_preview(method_schema_id):
    """
    Create and render the method schema identified by method_schema_id as HTML.

    :param method_schema_id: ID of the MethodSchema to preview.
    :return: Deform rendered HTML form for the identified MethodSchema (Note: The <form> element is removed).
    """
    method_schema = DBSession.query(MethodSchema).filter_by(id=method_schema_id).first()
    if method_schema is None:
        return "<p>Please create your data mapping using the standardised and custom fields.</p>"

    model_schema = DataTypeSchema(method_schema)

    # Create a dummy request object to make file upload widgets display properly for preview purposes.
    settings = {'workflows.files': "./"}
    Registry = namedtuple('registry', 'settings')
    Request = namedtuple('registry', ['registry', 'session'])
    dummy_request = Request(registry=Registry(settings=settings), session=DummySession())

    model_schema._bind({'request': dummy_request})   # Use _bind instead of bind so the schema isn't cloned
    form = Form(model_schema, action="")
    display = form.render({})
    display = display[display.index(">")+1:].replace("</form>", "").strip()
    return display
Example #23
0
    def answer(self):
        if 'submit' in self.request.POST and Session.QUESTION_STATE in self.request.session:
            template_vars = {'page_title':'Answer', 'username': self.request.username}
            try:
                #Store the previous question's answer.
                question = self.request.session[Session.QUESTION_STATE].get_current_question()
                schema = question.answer_schema(self.request)
                question_form = Form(schema)
                appstruct = question_form.validate(self.request.POST.items())
                self.request.session[Session.QUESTION_STATE].record_answer(appstruct['answer'])

                #Present the next question.
                question = self.request.session[Session.QUESTION_STATE].get_next_question()
                if question:
                    schema = question.answer_schema(self.request)
                    question_form = Form(schema, buttons=('submit',))
                    template_vars['question_form'] = question_form.render()
                else:
                    return HTTPFound(self.request.route_url('report'))
            except ValidationFailure as e:
                template_vars['question_form'] = e.render()
            return template_vars
        else:
            return HTTPFound(self.request.route_url('profile'))
Example #24
0
 def _makeForm(self, schema):
     from deform.form import Form
     return Form(schema, formid='myform')
Example #25
0
def gamedep_add_binary(context, request):
    check_owner(context, request)
    gamedeptype = request.matchdict.get('type')
    g = GameDepLib(gamedeptype)
    page_id = request.matchdict.get('page_id')
    binary_id = request.matchdict.get('binary_id')
    revision = request.matchdict.get('revision')
    edittype = request.matchdict.get('edittype')

    try:
        bin_obj = g.show_binary(binary_id)
    except GameDepNotFound:
        bin_obj = None

    if binary_id and edittype:
        pass

    # Initialise form library
    if not binary_id and not edittype:
        schema = AddBinarySchema()
    elif binary_id and edittype == "1":
        schema = EditBinarySchema()
    elif binary_id and edittype == "2":
        schema = EditOSArchSchema()
    else:
        request.session.flash(s.show_setting("ERROR_INVALID_BINARY_ID"), ERROR)
        return redirect(request, "gamedep_item", page_id=page_id,
                        type=gamedeptype)

    schema = schema.bind(gamedep_type=gamedeptype, bin_obj=bin_obj,
                         req_file_folder=["%s/" % page_id])
    myform = Form(schema, buttons=['submit'])
    reqts = myform.get_widget_resources()

    if 'submit' in request.POST:
        controls = request.POST.items()
        try:
            deserialized = myform.validate(controls)
        except ValidationFailure as e:
            # Failed validation
            return {'page_id': page_id, 'form': e.render(),
                    'js_links': reqts['js']}

        # Form submitted, all validated!
        binary = deserialized.get("binary")
        operatingsystem = deserialized.get("operatingsystem")
        architecture = deserialized.get("architecture")
        if not binary_id and not edittype:
            g.create_binary(page_id, revision, operatingsystem, architecture,
                            binary['fp'], binary['mimetype'],
                            binary['filename'], request)
            request.session.flash(s.show_setting("INFO_BINARY_ADDED")
                                  % binary['filename'], INFO)
        else:
            g.update_binary(page_id, revision, binary_id, operatingsystem,
                            architecture, binary, request)
            request.session.flash(s.show_setting("INFO_BINARY_UPDATED")
                                  % binary['filename'], INFO)
        return redirect(request, "gamedep_item", page_id=page_id,
                        type=gamedeptype)
    # Display default form
    return {'page_id': page_id, 'form': myform.render(),
            'js_links': reqts['js']}
Example #26
0
 def _makeOne(self, schema, **kw):
     from deform.form import Form
     return Form(schema, **kw)
Example #27
0
def gamedep_add_binary(context, request):
    check_owner(context, request)
    gamedeptype = request.matchdict.get('type')
    g = GameDepLib(gamedeptype)
    page_id = request.matchdict.get('page_id')
    binary_id = request.matchdict.get('binary_id')
    revision = request.matchdict.get('revision')
    edittype = request.matchdict.get('edittype')

    try:
        bin_obj = g.show_binary(binary_id)
    except GameDepNotFound:
        bin_obj = None

    if binary_id and edittype:
        pass

    # Initialise form library
    if not binary_id and not edittype:
        schema = AddBinarySchema()
    elif binary_id and edittype == "1":
        schema = EditBinarySchema()
    elif binary_id and edittype == "2":
        schema = EditOSArchSchema()
    else:
        request.session.flash(s.show_setting("ERROR_INVALID_BINARY_ID"), ERROR)
        return redirect(request,
                        "gamedep_item",
                        page_id=page_id,
                        type=gamedeptype)

    schema = schema.bind(gamedep_type=gamedeptype,
                         bin_obj=bin_obj,
                         req_file_folder=["%s/" % page_id])
    myform = Form(schema, buttons=['submit'])
    reqts = myform.get_widget_resources()

    if 'submit' in request.POST:
        controls = request.POST.items()
        try:
            deserialized = myform.validate(controls)
        except ValidationFailure as e:
            # Failed validation
            return {
                'page_id': page_id,
                'form': e.render(),
                'js_links': reqts['js']
            }

        # Form submitted, all validated!
        binary = deserialized.get("binary")
        operatingsystem = deserialized.get("operatingsystem")
        architecture = deserialized.get("architecture")
        if not binary_id and not edittype:
            g.create_binary(page_id, revision, operatingsystem, architecture,
                            binary['fp'], binary['mimetype'],
                            binary['filename'], request)
            request.session.flash(
                s.show_setting("INFO_BINARY_ADDED") % binary['filename'], INFO)
        else:
            g.update_binary(page_id, revision, binary_id, operatingsystem,
                            architecture, binary, request)
            request.session.flash(
                s.show_setting("INFO_BINARY_UPDATED") % binary['filename'],
                INFO)
        return redirect(request,
                        "gamedep_item",
                        page_id=page_id,
                        type=gamedeptype)
    # Display default form
    return {
        'page_id': page_id,
        'form': myform.render(),
        'js_links': reqts['js']
    }
Example #28
0
    def _makeForm(self, schema):
        # Deform
        from deform.form import Form

        return Form(schema, formid="myform")
Example #29
0
def my_view(request):
    form = Form(SampleSchema(), buttons=('up', ))
    return {'project': 'fileupload', 'form': form}
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    set_global_settings(settings)

    logging.basicConfig()
    logging.getLogger('sqlalchemy.engine').setLevel(logging.WARN)
    logging.captureWarnings(True)
#    execfile("D:/Repositories/JCU-DC24/venv/Scripts/activate_this.py", dict(__file__="D:/Repositories/JCU-DC24/venv/Scripts/activate_this.py"))

#def main():
    scripts.initializedb.initialise_all_db(settings)

    deform_templates = resource_filename('deform', 'templates')
    search_path = (resource_filename('jcudc24provisioning', 'templates/widgets'),resource_filename('jcudc24provisioning', 'templates/widgets/readonly'), resource_filename('jcudc24provisioning', 'templates/custom_widgets'), resource_filename('jcudc24provisioning', 'templates/custom_widgets/readonly'), deform_templates)
    Form.set_zpt_renderer(search_path, encoding="latin-1")

    set_cache_regions_from_settings(settings)
    my_session_factory = session_factory_from_settings(settings)
    config = Configurator(settings=settings, session_factory = my_session_factory, root_factory=RootFactory)

#    ---------------Project/Workflow pages------------------------
    config.add_route('create', '/project/create')              # Project creation wizard - templates, pre-fill etc.
    config.add_route('general', '/project/{project_id}/general')              # Project creation wizard - templates, pre-fill etc.
    config.add_route('description', '/project/{project_id}/description')    # descriptions
    config.add_route('information', '/project/{project_id}/information')    # metadata or associated information
    config.add_route('methods', '/project/{project_id}/methods')            # Data collection methods
    config.add_route('datasets', '/project/{project_id}/datasets')          # Datasets or collections of data
    config.add_route('submit', '/project/{project_id}/submit')              # Submit, review and approval

    # Project action pages
    config.add_route('dataset_log', '/project/{project_id}/logs/dataset_{dataset_id}_logs.txt')
    config.add_route('logs', '/project/{project_id}/logs')
    config.add_route('dataset_calibration', '/project/{project_id}/dataset/{dataset_id}/calibration/*calibration_id')
    config.add_route('dataset', '/project/{project_id}/dataset/*dataset_id')          # Datasets or collections of data
    config.add_route('ingester_dataset', '/project/{project_id}/dataset/{dataset_id}')    # View current settings for exported dataset.
    config.add_route('data_calibration', '/project/{project_id}/datasets/{dataset_id}/data/{id_list}/calibration/*calibration_id')
    config.add_route('data', '/project/{project_id}/datasets/{dataset_id}/data/*data_id')
    config.add_route('permissions', '/project/{project_id}/permissions')
    config.add_route('notifications', '/project/{project_id}/notifications')
    config.add_route('duplicate', '/project/{project_id}/duplicate')
    config.add_route('create_template', '/project/{project_id}/create_template')
    config.add_route('search', '/search*search_info')
    config.add_route('dataset_record', '/project/{project_id}/datasets/{dataset_id}/record')          # Datasets or collections of data
    config.add_route('delete_record', '/project/{project_id}/datasets/{dataset_id}/delete_record')          # Datasets or collections of data

#    config.add_route('browse', '/browse')
#    config.add_route('browse_projects', '/browse/projects/*search_info')
#    config.add_route('browse', '/browse/datasets')
#    config.add_route('browse', '/browse/data')
#    config.add_route('browse', '/browse/data/calibrations')

    # Exception handler
    config.add_route('workflow_exception', '/project/{route:.*}')

#    --------------JSON Search views--------------------------------
    config.add_route('get_model', '/get_model/{object_type}/{id}', xhr=True)
    config.add_route('get_ingester_logs', '/get_ingester_logs/{dam_id}/{filtering:.*}', xhr=True)
    config.add_route('add_method_from_template', '/add/{project_id}/{method_id}', xhr=True)

    config.add_route('get_activities', '/mint/activities/{search_terms}', xhr=True)
    config.add_route('get_parties', '/mint/parties/{search_terms}', xhr=True)
    config.add_route('get_from_identifier', '/mint/{identifier:.*}', xhr=True)

    config.add_route('dashboard', '/')                                      # Home page/user dashboard
    config.add_route('user', '/user')
    config.add_route('login', '/login')                                     # Login page
    config.add_route('login_shibboleth', '/login/shibboleth')                                     # Login page
    config.add_route('logout', '/logout')                                     # logout and redirect page
    config.add_route('admin', '/admin')                                     # administer user permissions + view admin required items
    config.add_route('help', '/help')                                     # administer user permissions + view admin required items
    config.add_route('lock_page', '/lock_page/{user_id}/*url')
    config.add_route('unlock_page', '/unlock_page/{lock_id}')
    config.add_route('record_data', '/{metadata_id}')
    config.add_route('record_data_portal', '/{metadata_id}/data')           # Redirect to the data portal

    #    --------------Static resources--------------------------------
    config.add_static_view('deform_static', 'deform:static', cache_max_age=0)
    config.add_static_view('static', 'jcudc24provisioning:static')
    config.add_static_view('project_uploads', "jcudc24provisioning:project_uploads", permission=DefaultPermissions.VIEW_PROJECT)

    authn_policy = ShibbolethAuthenticationPolicy(settings)
    authz_policy = ACLAuthorizationPolicy()
    config.set_authentication_policy(authn_policy)
    config.set_authorization_policy(authz_policy)
    config.set_default_permission(NO_PERMISSION_REQUIRED)

    config.add_request_method(get_user, 'user', reify=True)

    config.scan()

    json_config = create_json_config()
    f = open(settings.get("redbox.local_config_file"), 'w')
    f.write(json_config)

    # Upload the json cofiguration to ReDBox
#    hostname = global_settings.get("redbox.ssh_address") # remote hostname where SSH server is running
#    port = asint(global_settings.get("redbox.ssh_port"))
#    rsa_private_key = global_settings.get("redbox.rsa_private_key")
#    username = global_settings.get("redbox.ssh_username")
#    password = global_settings.get("redbox.ssh_password")
#    file_send = SFTPFileSend(hostname, port, username, password=password, rsa_private_key=rsa_private_key)
#    file_send.upload_file(settings.get("redbox.local_config_file"), settings.get("redbox.ssh_config_file"))
#    file_send.close()

#    try:
#        InitialiseDatabase()
#    except Exception as e:
#        logger.exception("Error initialising database: %s", e)
#        sys.exit()

    # Create the temporary folders if they don't already exist
    if not os.path.exists(settings.get("tmpdir")):
        os.mkdir(settings.get("tmpdir"))
    if not os.path.exists(settings.get("pyramid_deform.tempdir")):
        os.mkdir(settings.get("pyramid_deform.tempdir"))
    if not os.path.exists(settings.get("mint.tmpdir")):
        os.mkdir(settings.get("mint.tmpdir"))
    if not os.path.exists(settings.get("redbox.tmpdir")):
        os.mkdir(settings.get("redbox.tmpdir"))
    if not os.path.exists(settings.get("workflows.files")):
            os.mkdir(settings.get("workflows.files"))
#    if not os.path.exists(settings.get("mail.queue_path")):
#        os.mkdir(settings.get("mail.queue_path"))

    return config.make_wsgi_app()