Beispiel #1
0
def set_password(context, request,
                 success_msg=u"You've reset your password successfully."):
    form = Form(SetPasswordSchema(), buttons=('submit',))
    rendered_form = None

    if 'submit' in request.POST:
        try:
            appstruct = form.validate(request.POST.items())
        except ValidationFailure, e:
            request.session.flash(u"There was an error.", 'error')
            rendered_form = e.render()
        else:
            token = appstruct['token']
            email = appstruct['email']
            user = _find_user(email)
            if (user is not None and
                validate_token(user, token) and
                token == user.confirm_token):
                password = appstruct['password']
                user.password = get_principals().hash_password(password)
                user.confirm_token = None
                headers = remember(request, user.name)
                location = (appstruct['continue_to'] or
                            resource_url(context, request))
                request.session.flash(success_msg, 'success')
                return HTTPFound(location=location, headers=headers)
            else:
                request.session.flash(
                    u"Your password reset token may have expired.", 'error')
Beispiel #2
0
def view_edit_unposting(request):
    row = query_id(request).first()
    
    if not row:
        return id_not_found(request)
    if not row.posted:
        request.session.flash('Data tidak dapat di Unposting, karena belum diposting.', 'error')
        return route_list(request)
    if row.disabled:
        request.session.flash('Data jurnal Tagihan sudah diposting.', 'error')
        return route_list(request)
        
    form = Form(colander.Schema(), buttons=('unposting','cancel'))
    
    if request.POST:
        if 'unposting' in request.POST: 
        
            #Update status posted pada UTANG
            row.posted=0
            save_request3(request, row)
            
            r = DBSession.query(AkJurnal.id).filter(AkJurnal.source_no==row.kode).first()
            #Menghapus Item Jurnal
            DBSession.query(AkJurnalItem).filter(AkJurnalItem.ak_jurnal_id==r).delete()
            DBSession.flush()
                
            #Menghapus UTANG yang sudah menjadi jurnal
            DBSession.query(AkJurnal).filter(AkJurnal.source_no==row.kode).delete()
            DBSession.flush()
            
        return route_list(request)
    return dict(row=row, form=form.render())
    
      
Beispiel #3
0
def view_delete(request):
    q = query_id(request)
    row = q.first()
    
    if not row:
        return id_not_found(request)
    if row.posted:
        request.session.flash('Data sudah diposting SKPD', 'error')
        return route_list(request)
    if row.posted1:
        request.session.flash('Data sudah diposting PPKD', 'error')
        return route_list(request)
    if row.nominal:
        request.session.flash('Data tidak bisa dihapus, karena memiliki data items', 'error')
        return route_list(request)
            
    form = Form(colander.Schema(), buttons=('hapus','cancel'))
    values= {}
    if request.POST:
        if 'hapus' in request.POST:
            msg = '%s dengan kode %s telah berhasil.' % (request.title, row.kode)
            DBSession.query(Sts).filter(Sts.id==request.matchdict['id']).delete()
            DBSession.flush()
            request.session.flash(msg)
        return route_list(request)
    return dict(row=row, form=form.render())
Beispiel #4
0
def my_view(request):
    request.response.headers.update({
        'Access-Control-Allow-Origin': '*',
        'Access-Control-Allow-Methods': 'POST,GET,DELETE,PUT,OPTIONS',
        'Access-Control-Allow-Headers':
        'Origin, Content-Type, Accept, Authorization',
        'Access-Control-Allow-Credentials': 'true',
        'Access-Control-Max-Age': '1728000',
    })

    ct = request.dbsession.query(Carrier).filter(Carrier.trackedOnly == True)
    cr = request.dbsession.query(Carrier).filter(Carrier.trackedOnly == False)
    print(ct.count())
    print(cr.count())
    schema = Search()
    searchform = Form(schema,
                      action='/search/system',
                      buttons=('submit', ),
                      method='POST')
    rendered_form = searchform.render()
    return {
        'searchform': rendered_form,
        'deform': True,
        'tracked_carriers': ct.count(),
        'registered_carriers': cr.count()
    }
Beispiel #5
0
    def password_form(self):
        # if admin is changing password for another user no verification of current password is needed
        if self.context != self.api.user_profile and self.api.context_has_permission(MANAGE_SERVER, self.api.root):
            schema = createSchema('ChangePasswordAdminSchema')
        else:
            schema = createSchema('ChangePasswordSchema')
        add_csrf_token(self.context, self.request, schema)
        schema = schema.bind(context=self.context, request=self.request, api = self.api)
        form = Form(schema, buttons=(button_update, button_cancel))
        self.api.register_form_resources(form)

        post = self.request.POST
        if 'update' in post:
            controls = post.items()
            try:
                #appstruct is deforms convention. It will be the submitted data in a dict.
                appstruct = form.validate(controls)
            except ValidationFailure, e:
                self.response['form'] = e.render()
                return self.response
            
            self.context.set_password(appstruct['password'])
            
            msg = _(u"Password changed")
            self.api.flash_messages.add(msg)
            
            url = resource_url(self.context, self.request)
            return HTTPFound(location=url)
Beispiel #6
0
def view_delete(request):
    q = query_id(request)
    row = q.first()
    
    if not row:
        return id_not_found(request)
    if row.posted:
        request.session.flash('Data sudah diposting', 'error')
        return route_list(request)
    if row.status_spp:
        request.session.flash('Data sudah masuk di SPP', 'error')
        return route_list(request)
    if row.status_pay:
        request.session.flash('Data sudah masuk di Pembayaran Tagihan', 'error')
        return route_list(request)
    if row.amount:
        request.session.flash('Data tidak bisa dihapus, karena memiliki data items', 'error')
        return route_list(request)
        
    form = Form(colander.Schema(), buttons=('hapus','cancel'))
    values= {}
    if request.POST:
        if 'hapus' in request.POST:
            msg = '%s dengan kode %s telah berhasil.' % (request.title, row.kode)
            DBSession.query(APInvoice).filter(APInvoice.id==request.matchdict['id']).delete()
            DBSession.flush()
            request.session.flash(msg)
        return route_list(request)
    return dict(row=row, form=form.render())
Beispiel #7
0
def init_deform(root_package):
    Form.set_zpt_renderer(default_search_paths, translator=translator)

    node_modules_root = '{}:node_modules'.format(root_package)

    registry = widget.default_resource_registry
    registry.set_js_resources(
        'openlayers', '3.0.0',
        '{}/openlayers/dist/ol.js'.format(node_modules_root))
    registry.set_css_resources(
        'openlayers', '3.0.0',
        '{}/openlayers/dist/ol.css'.format(node_modules_root))
    registry.set_js_resources(
        'c2cgeoform.deform_map', None,
        'c2cgeoform:static/deform_map/controls.js')
    registry.set_css_resources(
        'c2cgeoform.deform_map', None,
        'c2cgeoform:static/deform_map/style.css')
    registry.set_js_resources(
        'typeahead', '0.10.5',
        '{}/typeahead.js/dist/typeahead.bundle.min.js'.
        format(node_modules_root))
    registry.set_css_resources(
        'typeahead', '0.10.5',
        'c2cgeoform:static/js/typeaheadjs.css')
    registry.set_js_resources(
        'c2cgeoform.deform_search', None,
        'c2cgeoform:static/deform_search/search.js')

    widget.MappingWidget.fields_template = 'mapping_fields'
    widget.FormWidget.fields_template = 'mapping_fields'
Beispiel #8
0
 def view_delete(self):
     q = self.query_id()
     row = q.first()
     request=self.request
     
     if not row:
         return id_not_found(request)
     if row.posted:
         request.session.flash('Data sudah diposting', 'error')
         return self.route_list()
     if row.status_giro:
         request.session.flash('Data masih terdapat pada Giro', 'error')
         return self.route_list()
         
     form = Form(colander.Schema(), buttons=('hapus','cancel'))
     values= {}
     if request.POST:
         if 'hapus' in request.POST:
         
             #Untuk menghapus SP2D
             msg = '%s dengan kode %s telah berhasil.' % (request.title, row.kode)
             DBSession.query(Sp2d).filter(Sp2d.id==request.matchdict['id']).delete()
             DBSession.flush()
             request.session.flash(msg)
             
             #Untuk update status posted dan disabled pada SPM
             row = DBSession.query(Spm).filter(Spm.id==row.ap_spm_id).first()   
             row.posted=0
             row.disabled=0
             self.save_request3(row)
             
         return self.route_list()
     return dict(row=row,form=form.render())
Beispiel #9
0
    def add_form(self):
        post = self.request.POST
        if 'cancel' in post:
            self.api.flash_messages.add(_(u"Canceled"))
            url = resource_url(self.context, self.request)
            return HTTPFound(location=url)

        schema = createSchema('AddUserSchema')
        add_csrf_token(self.context, self.request, schema)
        schema = schema.bind(context=self.context, request=self.request, api = self.api)
        form = Form(schema, buttons=(button_add, button_cancel))
        self.api.register_form_resources(form)

        if 'add' in post:
            controls = post.items()
            try:
                #appstruct is deforms convention. It will be the submitted data in a dict.
                appstruct = form.validate(controls)
            except ValidationFailure, e:
                self.response['form'] = e.render()
                return self.response
            
            #Userid and name should be consistent
            name = appstruct['userid']
            del appstruct['userid']
            
            #creators takes care of setting the role owner as well as adding it to creators attr.
            obj = createContent('User', creators=[name], **appstruct)
            self.context[name] = obj

            self.api.flash_messages.add(_(u"Successfully added"))

            url = resource_url(self.context, self.request)            
            return HTTPFound(location=url)
Beispiel #10
0
    def edit(self):
        contest = self.context.contest

        e = {}
        e['name'] = contest.disp_name
        e['url'] = {}
        e['url']['manage'] = self.request.route_url('defcne.c', traverse=(contest.dc, contest.id, 'manage'))
        e['url']['edit'] = self.request.route_url('defcne.c', traverse=(contest.dc, contest.id, 'edit'))
        e['url']['extrainfo'] = self.request.route_url('defcne.c', traverse=(contest.dc, contest.id, 'extrainfo'))

        astruct = contest.to_appstruct()
        astruct['name'] = astruct['disp_name']

        (schema, f) = ContestForm.create_form(request=self.request,
                action=self.request.current_route_url(), type='contest', origname=contest.name)

        if contest.logo:
            schema['logo'].description = "A logo has already been uploaded. Uploading a new logo will overwrite the previous logo!"
        del astruct['logo']
        del schema['ticket']

        f = Form(schema, action=self.request.current_route_url(), buttons=('submit',))

        return {
                'page_title': 'Edit Contest: {}'.format(contest.disp_name),
                'cve': e,
                'form': f.render(astruct),
                'type': 'contest',
                }
Beispiel #11
0
def login(request):

    schema = UserLoginSchema(validator=user_login_validator)
    form = Form(schema, buttons=("submit",))

    userid = authenticated_userid(request)
    if userid:
        return HTTPFound(location="/")

    if "submit" in request.POST:
        controls = request.POST.items()

        try:
            values = form.validate(controls)

            try:
                user = User.objects.get(email=values["email"])
            except DoesNotExist:
                return HTTPNotFound()

            headers = remember(request, str(user.id))
            return HTTPFound(location="/", headers=headers)
        except ValidationFailure:
            form_render = form.render()
    else:
        form_render = form.render()

    params = {"form": Markup(form_render)}

    return render_to_response("user/login.html", params)
def view_delete(request):
    q = query_id(request)
    row = q.first()
    x   = row.approval_level
    a   = row.product_plan_id
	
    if not row:
        return id_not_found(request)
    if x == 2: 
        request.session.flash('Data tidak dapat dihapus, karena sudah disetujui.', 'error')
        return route_list(request)
		
    form = Form(colander.Schema(), buttons=('hapus','batal'))
    if request.POST:
        if 'hapus' in request.POST:
            msg = 'Approval rencana ID %d sudah dihapus.' % (row.id)
            q.delete()
            DBSession.flush()
            request.session.flash(msg)
			
            r = DBSession.query(ProductPlan).filter(ProductPlan.id==a).first()   
            r.approval_level = 0
            r.disabled       = 0
            save_request2(r)
	
        return route_list(request)
    return dict(row=row, form=form.render())
def register_view(context, request):
    form = Form(Signup(), buttons=('register',))
    rendered_form = form.render(null)
    if 'register' in request.POST:
        try:
            appstruct = form.validate(request.POST.items())
        except ValidationFailure, e:
            rendered_form = e.render()
        else:
            pending = request.registry.queryAdapter(context, IRegistrations,
                                                    name='pending')
            if pending is None:  #pragma NO COVERAGE
                pending = PendingRegistrations(context)
            email = appstruct['email']
            token = getRandomToken(request)
            pending.set(email, token=token)

            from_addr = request.registry.settings['cartouche.from_addr']
            delivery = request.registry.queryUtility(IMailDelivery,
                                                     default=localhost_mta)
            confirmation_url = view_url(context, request, 'confirmation_url',
                                        'confirm_registration.html',
                                        email=email)
            body = REGISTRATION_EMAIL % {'token': token,
                                         'confirmation_url': confirmation_url}
            message = Message()
            message['Subject'] = 'Site registration confirmation'
            message.set_payload(body)
            delivery.send(from_addr, [email], message)
            return HTTPFound(location=confirmation_url)
    def calibration_report(self):
        """ Process form paramters, create a pdf calibration report form
        and generate a thumbnail view.
        """
        form = Form(ReportSchema(), buttons=("submit",))

        if "submit" in self.request.POST:
            #log.info("submit: %s", self.request.POST)
            controls = self.request.POST.items()
            try:
                appstruct = form.validate(controls)
                rendered_form = form.render(appstruct)

                report = self.populate_data(appstruct)
                self.makedir_write_files(appstruct)
                pdf = WasatchSinglePage(filename=report.filename,
                                        report=report)
                pdf.write_thumbnail()

                return {"form":rendered_form, "appstruct":appstruct}

            except ValidationFailure as exc: 
                #log.exception(exc)
                log.info("Validation failure")
                return {'form':exc.render()} 

        return {"form":form.render()}
Beispiel #15
0
def view_delete(request):
    q = query_id(request)
    row = q.first()
    uid = row.id
    
    if not row:
        return id_not_found(request)
        
    # Untuk mengecek apakah Rekening tersebut sedang dipakai oleh tabel lain. #    
    a = DBSession.query(Reklame).filter(Reklame.rekening_id==uid).first()
    if a:
        request.session.flash('Data tidak bisa dihapus, karena sudah masuk di Objek Pajak.', 'error')
        return route_list(request)
        
    b = DBSession.query(Jenis).filter(Jenis.rekening_id==uid).first()
    if b:
        request.session.flash('Data tidak bisa dihapus, karena sudah masuk di Jenis Reklame.', 'error')
        return route_list(request)
    #--------------------------------------------------------------------------------------------------------#    
    
    form = Form(colander.Schema(), buttons=('hapus','batal'))
    if request.POST:
        if 'hapus' in request.POST:
            msg = 'Rekening ID %d %s sudah dihapus.' % (row.id, row.nama)
            q.delete()
            DBSession.flush()
            request.session.flash(msg)
        return route_list(request)
    return dict(row=row, form=form.render())
Beispiel #16
0
    def update_user(self):
        template_vars = {'menu_active': 'update_user'}
        form = Form(Registration().bind(request=self.request), buttons=('submit',),
                action=self.request.route_url('update_user'))
        if 'submit' in self.request.POST: # detect that the submit button was clicked

            controls = self.request.POST.items() # get the form controls

            try:
                form_data = form.validate(controls)  # call validate
            except ValidationFailure as e: # catch the exception
                template_vars['form'] = form.render() # re-render the form with an exception
                return template_vars

            # if user is logged, we update his profile. Else we create a new user.
            userid = authenticated_userid(self.request)
            if userid:
                user =  User.by_id(userid)
                # WARNING: only update authorized values

            else:
                del(form_data['csrf'])
                user = User(**form_data)
                DBSession.add(user)

            url = self.request.route_url('home')
            return HTTPFound(location=url)
        template_vars['form'] = form.render()
        return template_vars
Beispiel #17
0
 def view_ar_payment_item_delete(self):
     request = self.request
     q       = self.query_id()
     row     = q.first()
     
     if not row:
         return self.id_not_found(request)
     if row.posted:
         request.session.flash('Data sudah diposting', 'error')
         return self.route_list()
     if row.posted1:
         request.session.flash('Data sudah diposting rekap', 'error')
         return self.route_list()
         
     form = Form(colander.Schema(), buttons=('hapus','batal'))
     if request.POST:
         if 'hapus' in request.POST:
             msg = 'TBP ID %d %s sudah dihapus.' % (row.id, row.ref_nama)
             try:
               q.delete()
               DBSession.flush()
             except:
               msg = 'TBP ID %d %s tidak dapat dihapus.' % (row.id, row.ref_nama)
             request.session.flash(msg)
         return self.route_list()
     return dict(row=row, form=form.render())
Beispiel #18
0
def admin_user_edit(request):
    def default_values(schema, user):
        for field in schema.children:
            if field.name in user and field.name != 'password':
                field.default = user[field.name]


    user = User.objects.with_id(request.matchdict['user'])
    schema = UserFormSchema(validator=user_form_validator(user))

    default_values(schema, user)

    form = Form(schema, buttons=('submit',))
    form_render = None

    if 'submit' in request.POST:
        controls = request.POST.items()

        try:
            values = form.validate(controls)
            user.update(values)
            user.save()
            default_values(schema, user)
        except ValidationFailure, e:
            form_render = e.render()
Beispiel #19
0
    def generate_thumbnails(self):
        """ Display the form on get, on submission, save the uploaded
        pdf to the "serial" directory, and return the form populated 
        along with the generated thumbnails.
        """
        form = Form(PDFUploadSchema(), buttons=("submit",))

        if "submit" in self.request.POST:
            log.info("submit: %s", self.request.POST)

            controls = self.request.POST.items()
            try:
                appstruct = form.validate(controls)
                rendered_form = form.render(appstruct)

                self.write_upload_files(appstruct)
                self.write_thumbnails(appstruct)

                return {"form":rendered_form, "appstruct":appstruct}

            except ValidationFailure as exc: 
                log.info("Validation failure")
                return {'form':exc.render()} 

        return {"form":form.render()}
Beispiel #20
0
def view_delete(request):
    q = query_id(request)
    row = q.first()
    
    if not row:
        return id_not_found(request)
    if row.posted:
        request.session.flash('Data sudah diposting', 'error')
        return route_list(request)
    if row.status_spp:
        request.session.flash('Data sudah di SPP', 'error')
        return route_list(request)
    """
    if row.amount:
        request.session.flash('Data tidak bisa dihapus, karena memiliki data items', 'error')
        return route_list(request)
    """    
    form = Form(colander.Schema(), buttons=('hapus','cancel'))
    values= {}
    if request.POST:
        if 'hapus' in request.POST:
            msg = '%s dengan kode %s telah berhasil.' % (request.title, row.kode)
            DBSession.query(APPayment).filter(APPayment.id==request.matchdict['id']).delete()
            DBSession.flush()
            request.session.flash(msg)
            
            #Untuk update status posted dan status_pay pada APInvoice
            inv_id = row.invoice_id
            row = DBSession.query(APInvoice).filter(APInvoice.id==inv_id).first()   
            row.status_pay = 0
            save_request2(row)
    
        return route_list(request)
    return dict(row=row, form=form.render())
    
Beispiel #21
0
 def request_password(self):        
     schema = createSchema('RequestNewPasswordSchema').bind(context=self.context, request=self.request)
     form = Form(schema, buttons=(button_request, button_cancel))
     self.api.register_form_resources(form)
 
     #Handle submitted information
     if 'request' in self.request.POST:
         controls = self.request.POST.items()
 
         try:
             #appstruct is deforms convention. It will be the submitted data in a dict.
             appstruct = form.validate(controls)
         except ValidationFailure, e:
             self.response['form'] = e.render()
             return self.response
         
         userid_or_email = appstruct['userid_or_email']
 
         #userid here can be either an email address or a login name
         if '@' in userid_or_email:
             #assume email
             user = self.context['users'].get_user_by_email(userid_or_email)
         else:
             user = self.context['users'].get(userid_or_email)
         
         if IUser.providedBy(user):
             user.new_request_password_token(self.request)
             self.api.flash_messages.add(_('Email sent.'))
             url = resource_url(self.api.root, self.request)
             return HTTPFound(location = url)
 
         self.api.flash_messages.add(_('Username or email not found.'), type='error')
Beispiel #22
0
def view_login(request):
    if authenticated_userid(request):
        return HTTPFound(location=request.route_url('forbidden'))
    
    login_url = request.resource_url(request.context,'login')
    referrer = request.url
   
    if referrer == login_url:
        referrer = '/'
            
    came_from = request.params.get('came_from', referrer)
    schema = Login(validator=login_validator)
    form = Form(schema, buttons=('login',))
    if 'login' in request.POST: 
        controls = request.POST.items()
        identity = request.POST.get('username')
        user = schema.user = User.get_by_identity(identity)
        try:
            c = form.validate(controls)
        except ValidationFailure, e:
            request.session['login failed'] = e.render()
            return HTTPFound(location=came_from) #location.request.route_url('login')
                    
            
        headers = get_login_headers(request, user)
        return HTTPFound(location=came_from, # request.route_url(came_from),
                          headers=headers)
Beispiel #23
0
def view_delete(request):
    q   = query_id(request)
    row = q.first()
    a   = row.id
	
    if not row:
        return id_not_found(request)
		
    # Seleksi untuk mengecek komentar
    i = DBSession.query(DisposisiComment).filter(DisposisiComment.disposisi_id==a).first()
    if i:
        request.session.flash('Hapus dahulu komentar pada surat masuk.', 'error')
        return route_list(request)
		
    # Seleksi untuk mengecek penerima
    b = DBSession.query(PenerimaDisposisi).filter(PenerimaDisposisi.disposisi_id==a).first()
    if b:
        request.session.flash('Hapus dahulu penerima.', 'error')
        return route_list(request)
        
    form = Form(colander.Schema(), buttons=('hapus','batal'))
    if request.POST:
        if 'hapus' in request.POST:
            msg = 'Surat masuk ID %d sudah dihapus.' % (row.id)
            q.delete()
            DBSession.flush()
            request.session.flash(msg)
        return route_list(request)
    return dict(row=row, form=form.render())
Beispiel #24
0
def login_view(request):
    """
        Login view
    """
    log.debug("# Login page")
    form = Form(authSchema,
                buttons=(Button(name="submit",
                                title="Valider",
                                type='submit'),))
    nextpage = request.params.get('nextpage') or request.route_url('index')
    app_struct = {'nextpage':nextpage}
    myform = form.render(app_struct)
    fail_message = None
    if 'submit' in request.params:
        log.debug(" + Validating authentication")
        controls = request.params.items()
        try:
            datas = form.validate(controls)
        except ValidationFailure, err:
            log.debug("Erreur d'authentification")
            myform = err.render()
            request.session.flash(_(request, u"Authentication error"), "error")
            return {'title':"Login page",
                    'form':myform,}
        log.debug("  + Validation ok, redirecting")
        log.debug("     -> {0}".format(nextpage))
        login = datas['login']
        # Storing the datas in the session
        remember(request, login)
        return HTTPFound(location=nextpage)
Beispiel #25
0
def view_delete(request):
    q = query_id(request)
    row = q.first()
    uid = row.id
    
    if not row:
        return id_not_found(request)
        
    a = DBSession.query(Kelurahan).filter(Kelurahan.kecamatan_id==uid).first()
    if a:
        request.session.flash('Data tidak bisa dihapus, karena sudah masuk di Tabel Kelurahan.', 'error')
        return route_list(request)
        
    b = DBSession.query(Reklame).filter(Reklame.kecamatan_id==uid).first()
    if b:
        request.session.flash('Data tidak bisa dihapus, karena sudah masuk di Tabel Objek Pajak.', 'error')
        return route_list(request)
        
    form = Form(colander.Schema(), buttons=('hapus','batal'))
    if request.POST:
        if 'hapus' in request.POST:
            msg = 'Kecamatan ID %d %s sudah dihapus.' % (row.id, row.nama)
            q.delete()
            DBSession.flush()
            request.session.flash(msg)
        return route_list(request)
    return dict(row=row,form=form.render())
Beispiel #26
0
def register(request):
    schema = RegisterForm()
    myform = Form(schema, buttons=('submit',))
    userid = authenticated_userid(request)
    username = False
    if userid:
        user = User.by_id(userid)
        if user:
            username = user.name
    fields = {
            "layout": site_layout(),
            "page_title": "Register",
            "message": "",
            "url": request.application_url + '/register',
            "logged_in": username,
        }
    if username:
        fields['form'] = "You are already logged in.  Please log out and try again."
        return fields
    if 'submit' in request.POST:
        controls = request.POST.items()
        try:
            myform.validate(controls)
        except ValidationFailure, e:
            fields['form'] = e.render()
            return fields
        #passed validation
        user = User()
        user.name = request.POST['username']
        user.email = request.POST['email']
        user.setpass(request.POST['password'])
        DBSession.add(user)
        fields['form'] = request.POST['username']
        
        return fields
    def variant(self):
        question_name = self.request.GET.get('question_name', None)
        globalquestions = self.root['questions']

        if question_name not in globalquestions:
            self.add_flash_message(_(u"Invalid question name."))
            url = self.request.resource_url(self.context)
            return HTTPFound(location=url)

        question = globalquestions[question_name]
        schema = createSchema(question.schemas['translate'])
        schema.title = _(u"Edit question variant for this organisation")
        schema = schema.bind(context = question, request = self.request)
        # add default locale
        description = question.get_original_title()
        descriptions = question.get_question_text()
        self.trans_util.add_translation_schema(schema['question_text'], self.trans_util.default_locale_name, description=description)
        self.trans_util.add_translations_schema(schema['question_text'], self.context, descriptions=descriptions, only_with_description=True)
        
        form = Form(schema, action = self.request.url, buttons=(self.buttons['save'], self.buttons['cancel']))
        self.response['form_resources'] = form.get_widget_resources()
        
        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
            for (lang, value) in appstruct['question_text'].items():
                self.context.set_variant(question_name, lang, value)
            url = self.request.resource_url(self.context, 'variants')
            return HTTPFound(location = url)
Beispiel #28
0
def login(request):

    schema = UserLoginSchema(validator=user_login_validator)
    form = Form(schema, buttons=('submit',))

    userid = authenticated_userid(request)
    if userid:
        return HTTPFound(location='/')

    if 'submit' in request.POST:
        controls = request.POST.items()

        try:
            values = form.validate(controls)

            try:
                user = User.objects.get(email=values['email'])
                user.tzoffset = values['tzoffset']
                user.save()
            except DoesNotExist:
                return HTTPNotFound()

            headers = remember(request, str(user.id), max_age=10000000000)
            return HTTPFound(location='/', headers=headers)
        except ValidationFailure:
            form_render = form.render()
    else:
        form_render = form.render()

    params = {
        'form': Markup(form_render)
    }

    return render_to_response('user/login.html', params)
Beispiel #29
0
	def post(self):

		controls = self.request.POST.items()
		form = Form(SignupForm())
		data = form.validate(controls)

		name = data.get("name")
		mail = data.get("email")

		if DBSession.query(User).get(name):
			raise DuplicateUserName()
		if DBSession.query(User).filter_by(mail=mail).count() > 0:
			raise DuplicateEmail()

		user = User(name=name)
		password = user.generate_password()
		user.mail = mail
		DBSession.add(user)

		msg = WelcomeMessage()
		msg.send(self.request, user, password)

		self.flash("info", "Your account has been created and your "
				"initial password was sent to %s" % (mail))
		return self.redirect("login")
Beispiel #30
0
    def user_edit_submit(self):
        user = self.context.user

        controls = self.request.POST.items()
        schema = MagicUserEdit().bind(request=self.request)
        f = Form(schema, action=self.request.current_route_url(), button=('submit',))

        try:
            appstruct = f.validate(controls)

            current_groups = set([x.id for x in user.groups])
            selected_groups = set([x['group_id'] for x in appstruct['groups']])
            new_groups = selected_groups - current_groups
            rem_groups = current_groups - selected_groups

            for g in new_groups:
                group = m.Group.find_group_by_id(g)
                user.groups.append(group)

            if len(rem_groups):
                for g in user.groups:
                    if g.id in rem_groups:
                        user.groups.remove(g)

            user.validated = appstruct['validated']

            self.request.session.flash('User {} has been modified.'.format(user.disp_uname), queue='magic')
            return HTTPSeeOther(location = self.request.route_url('defcne.magic', traverse=('u')))
        except ValidationFailure, e:
            return {
                    'form': e.render(),
                    'page_title': 'Editing user: {}'.format(user.disp_uname),
                    }
Beispiel #31
0
def preferences(request):
    schema = UserPreferencesSchema()
    button1 = Button('submit', _('Save changes'))
    button1.css_class = 'btn-primary'

    form = Form(schema, buttons=(button1, ))

    user = request.user

    if 'submit' in request.POST:
        controls = request.POST.items()
        try:
            appstruct = form.validate(controls)
        except ValidationFailure as e:
            return {'form': e.render()}

        user.update_preferences(appstruct)
        Session.add(user)

        request.session.flash(
            _('The changes were saved successfully'),
            'success',
        )
        return HTTPFound(location=request.route_path('user_preferences'))

    return {
        'form': form.render({
            'allow_google_analytics': user.allow_google_analytics,
            'send_passwords_periodically': user.send_passwords_periodically,
        })
    }
Beispiel #32
0
    def view_login(self):

        authed_user = None

        # TODO deferred validator doesn't work!
        # @colander.deferred
        # @staticmethod
        def validate_auth(form, values):
            nonlocal authed_user

            login = values.get('login')
            password = values.get('password')
            """:type : User"""
            user = User.by_any(login)

            # TODO check
            # -cdunklau- : d9k_ so i'm thinking you just need to do
            # form['login'].error = colander.Invalid(form['login'], 'Unknown login')
            # and then raise deform.ValidationFailure(form, form.cstruct, None) or something

            if not user:
                raise exception_for_schema_field(form, 'login', 'Пользователь не найден')
            if not user.active:
                raise exception_for_schema_field(form, 'login', 'Аккаунт пользователя заблокирован')
            if user.password_hash is None:
                if user.email is None:
                    raise exception_for_schema_field(form, 'password',
                                                     'Вход по паролю отключен. Почта не была привязана к аккаунту')
                raise exception_for_schema_field(form, 'password', 'Вход по паролю отключен')
            if not user.check_password(password):
                raise exception_for_schema_field(form, 'password', 'Неверный пароль')
            if not user.email_checked:
                raise exception_for_schema_field(form, 'login',
                                                 'Email пользователя не подтверждён. Проверьте почтовый ящик')
                # TODO показывать email "в звёздочках"
            authed_user = user

        login_form = Form(
            LoginSchema(validator=validate_auth).bind(),
            buttons=[Button(name='login_form_submit', title='Вход')],
            # css_class='no-red-stars'
        )

        login_form.css_class += ' no-red-stars'

        if 'login_form_submit' in self.request.params:
            controls = self.request.POST.items()
            try:
                login_form.validate(controls)
            except deform.ValidationFailure as e:
                return dict(rendered_login_form=e.render())

            if authed_user is not None:
                self.request.session.invalidate()
                headers = security.remember(self.request, authed_user.id)
                index = self.request.route_url('admin_index' if authed_user.is_admin() else 'index')
                return HTTPFound(location=index, headers=headers)

        return dict(rendered_login_form=login_form.render())
Beispiel #33
0
 def get_year_form(self):
     """
         Return the year selection form
     """
     schema = self.year_form_schema.bind(request=self.request)
     form = Form(schema=schema, buttons=(), method='GET', formid='year_form')
     form.set_appstruct(self.submit_year())
     return form
Beispiel #34
0
 def login_form_show(self):
     """Just show login form
     
     @todo add request_from hidden value
     @todo add csrf hidden value"""
     schema = AuthSchema()
     form = Form(schema, buttons=('submit', ))
     return {'form': form.render()}
Beispiel #35
0
def get_project_form(request):
    """
    Returns the project add/edit form
    """
    schema = get_project_schema().bind(request=request)
    form = Form(schema, buttons=(submit_btn, ))
    form.widget = GridFormWidget(named_grid=FORM_GRID)
    return form
 def __init__(self, request):
     super(Home, self).__init__(request)
     schema = PlanSchema().bind(request=self.request)
     self.plan_form = Form(
         schema,
         buttons=(Button(title=u'登録'), ),
         method='post',
         action=self.request.route_path('plan'),
     )
Beispiel #37
0
def get_customer_form(request):
    """
        Returns the customer add/edit form
    """
    schema = get_customer_schema(request)
    schema = schema.bind(request=request)
    form = Form(schema, buttons=(submit_btn, ))
    form.widget = GridFormWidget(grid=FORM_GRID)
    return form
Beispiel #38
0
def init():
    from deform import Form
    from deform_jinja2 import jinja2_renderer_factory
    from deform_jinja2.translator import PyramidTranslator

    renderer = jinja2_renderer_factory(search_paths=SEARCH_PATHS,
                                       translator=PyramidTranslator())

    Form.set_default_renderer(renderer)
Beispiel #39
0
    def site_view(self):
        def refresh_cache():
            # we simply remove all cached files
            cache_directory = real_path(CACHE_SUBDIRECTORY)
            if os.path.exists(cache_directory):
                for fn in os.listdir(cache_directory):
                    shutil.rmtree(os.path.join(cache_directory, fn))

        schema = Configuration()
        settings = get_current_registry().settings

        def get_some_scan(request):
            result = request.solr_scan.search(q='*:*', rows=1)
            if not result.documents:
                return None
            doc = result.documents[0]
            url = request.route_url('service_scan_images_item',
                                    number=str(doc['number']),
                                    number_of_image=doc['default_image_id'])
            image_url = os.path.join(
                url, 'file_%s' % str(hash(doc['dateLastModified'])))
            return image_url

        example_image = ''

        default_values = [(node.name, unicode(settings.get(node.name, 'xxx')))
                          for node in schema.children]
        form = Form(schema, buttons=('submit', ))
        if self.request.POST:
            controls = self.request.POST.items()
            try:
                appstruct = form.validate(controls)
            except ValidationFailure, e:
                return {'form': e.render(), 'example_image': example_image}

            # Process the valid form data, do some work
            # if the file does not exist, we raise a validation error
            if appstruct['watermark_file'] and not os.path.exists(
                    appstruct['watermark_file']):
                raise HTTPBadRequest(
                    'This file {watermark_file} cannot be found'.format(
                        **appstruct))
            # if anything has changed, we reset the cache
            for key in appstruct:
                if settings.get(key) != appstruct[key]:
                    refresh_cache()
                    continue

            for key in appstruct:
                # save the new settings in the database
                self.set_setting(self.request, key, appstruct[key])

            # update the global settings object with our new values
            settings.update(appstruct)
            example_image = get_some_scan(self.request)
            return {"form": form.render(), 'example_image': example_image}
Beispiel #40
0
def edit_account_view(context, request):
    confirmed = request.registry.queryAdapter(context,
                                              IRegistrations,
                                              name='confirmed')
    if confirmed is None:  #pragma NO COVERAGE
        confirmed = ConfirmedRegistrations(context)

    identity = request.environ.get('repoze.who.identity')
    if identity is None:
        return HTTPUnauthorized()

    userid = identity['repoze.who.userid']
    account_info = confirmed.get(userid)
    if account_info is None:
        return HTTPForbidden()

    appstruct = {
        'login_name': account_info.login,
        'email': account_info.email,
        'security': {
            'question': account_info.security_question or '',
            'answer': account_info.security_answer or '',
        },
    }
    schema = EditAccount().bind(current_login_name=account_info.login,
                                confirmed=confirmed,
                                old_password=account_info.password)
    form = Form(schema, buttons=('update', ))
    rendered_form = form.render(appstruct)

    if 'update' in request.POST:
        try:
            appstruct = form.validate(request.POST.items())
        except ValidationFailure, e:
            rendered_form = e.render()
        else:
            login = appstruct['login_name']
            email = appstruct['email']
            pwd_mgr = SSHAPasswordManager()
            password = pwd_mgr.encodePassword(appstruct['password'])
            security_question = appstruct['security']['question']
            security_answer = appstruct['security']['answer']
            confirmed.set(
                userid,
                email=email,
                login=login,
                password=password,
                security_question=security_question,
                security_answer=security_answer,
            )
            return HTTPFound(location=view_url(
                context,
                request,
                'after_edit_url',
                request.view_name,
            ))
Beispiel #41
0
 def poll_form(self):
     """ Return rendered poll form or process a vote. """
     poll_plugin = self.query_poll_plugin(self.context)
     if not poll_plugin:
         return HTTPForbidden()
     schema = poll_plugin.get_vote_schema(self.request, self.api)
     add_csrf_token(self.context, self.request, schema)
     schema = schema.bind(context=self.context,
                          request=self.request,
                          api=self.api)
     form = Form(schema,
                 action=self.request.resource_url(self.context,
                                                  '_poll_form'),
                 buttons=(button_vote, ),
                 formid="vote_form")
     can_vote = has_permission(security.ADD_VOTE, self.context,
                               self.request)
     userid = self.api.userid
     post = self.request.POST
     if 'vote' in post:
         if not can_vote:
             raise HTTPForbidden(u"You're not allowed to vote")
         controls = post.items()
         try:
             appstruct = form.validate(controls)
         except ValidationFailure, e:
             self.response['form'] = e.render()
             return self.response
         Vote = poll_plugin.get_vote_class()
         if not IVote.implementedBy(Vote):
             raise TypeError(
                 "Poll plugins method get_vote_class returned something that didn't implement IVote."
             )
         #Remove crsf_token from appstruct after validation
         appstruct.pop('csrf_token', None)
         if userid in self.context:
             vote = self.context[userid]
             assert IVote.providedBy(vote)
             vote.set_vote_data(appstruct)
         else:
             vote = Vote(creators=[userid])
             #We don't need to send events here, since object added will take care of that
             vote.set_vote_data(appstruct, notify=False)
             #To fire events after set_vote_data is done
             self.context[userid] = vote
         success_msg = _(u"Your vote has been registered!")
         if self.request.is_xhr:
             self.response['success_msg'] = success_msg
             return Response(
                 render("templates/snippets/vote_success.pt",
                        self.response,
                        request=self.request))
         self.api.flash_messages.add(success_msg)
         url = self.request.resource_url(self.context.__parent__,
                                         anchor=self.context.uid)
         return HTTPFound(location=url)
Beispiel #42
0
def destroy(request):
    schema = AccountDestroySchema()
    button1 = Button('submit', _('Yes, I am sure. Destroy my account'))
    button1.css_class = 'btn-danger'
    button2 = Button('cancel', _('Cancel'))
    button2.css_class = 'btn-default'

    form = Form(schema, buttons=(button1, button2))

    user = request.user

    can_destroy = len(user.applications) == 0

    context = {
        'passwords': len(user.passwords),
        'can_destroy': can_destroy,
    }

    if 'submit' in request.POST:

        if not can_destroy:
            request.session.flash(
                _('You must remove your applications before destroying your account'
                  ),
                'error',
            )
            return HTTPFound(
                location=request.route_path('oauth2_developer_applications'))

        controls = request.POST.items()
        try:
            appstruct = form.validate(controls)
        except ValidationFailure as e:
            context['form'] = e.render()
            return context

        reason = appstruct['reason']
        notify_admins_of_account_removal(request, user, reason)

        Session.delete(user)

        request.session.flash(
            _('Your account has been removed. Have a nice day!'),
            'success',
        )
        return logout(request)

    elif 'cancel' in request.POST:
        request.session.flash(
            _('Thanks for reconsidering removing your account!'),
            'info',
        )
        return HTTPFound(location=request.route_path('user_information'))

    context['form'] = form.render()
    return context
Beispiel #43
0
    def view_register(self):

        # def validate_register(form, values):
        #     pass

        register_form = Form(
            RegisterSchema(
                # validator=validate_register
            ).bind(),
            buttons=[Button(name='register_form_submit', title='Зарегистрировать')]
        )

        if 'register_form_submit' in self.request.params:
            controls = self.request.POST.items()
            try:
                data = register_form.validate(controls)
            except deform.ValidationFailure as e:
                r = e.render()
                return dict(rendered_register_form=r)

            # TODO create new user

            # new_user = User(login='******', name='Дмитрий Комаров', email='*****@*****.**')

            new_user = User()
            dictalchemy.utils.fromdict(new_user, data)
            self.request.session.invalidate()
            # TODO check user.beforeSave() is called before save
            # if not new_user.name:
            #     new_user.name = new_user.login
            password = data.get('password')
            if not password:
                password = User.generate_password()
                self.request.session['new_password'] = password
            new_user.set_password(password)
            try:
                with transaction.manager:
                    DBSession.add(new_user)
            except DBAPIError:
                return Response(conn_err_msg, content_type='text/plain', status_int=500)

            helpers.send_html_mail(new_user.email, 'registered',
                                   {'user_name': new_user.name, 'password': password})

            new_user.initiate_email_check()
            try:
                with transaction.manager:
                    DBSession.add(new_user)
            except DBAPIError:
                return Response(conn_err_msg, content_type='text/plain', status_int=500)

            self.request.session['new_user_id'] = new_user.id
            success_location = self.request.route_url('register_success')
            return HTTPFound(location=success_location)

        return dict(rendered_register_form=register_form.render())
Beispiel #44
0
def form_view(request):
    schema = Schema()
    form = Form(schema)
    if 'submit' in request.POST:
        controls = request.POST.items()
        try:
            appstruct = form.validate(controls)
        except ValidationFailure as e:
            return {'form': form}
    return {'form': form}
Beispiel #45
0
    def view(self):
        # Get LDAP settings
        ldap_settings = self.request.db.ldap.find_one()
        if ldap_settings is None:
            ldap_settings = dict()

        # Generate form
        from phoenix.settings.schema import LdapSchema
        ldap_form = Form(schema=LdapSchema().bind(request=self.request), buttons=('submit',), formid='deform')

        if 'submit' in self.request.params:
            check_csrf_token(self.request)
            try:
                # Validate form
                appstruct = ldap_form.validate(list(self.request.params.items()))
            except ValidationFailure as e:
                LOGGER.exception('Validation failed!')
                return dict(title='LDAP Settings', form=e.render())
            else:
                # Update LDAP settings
                ldap_settings['server'] = appstruct['server']
                ldap_settings['use_tls'] = appstruct['use_tls']
                ldap_settings['bind'] = appstruct['bind']
                ldap_settings['passwd'] = appstruct['passwd']
                ldap_settings['base_dn'] = appstruct['base_dn']
                ldap_settings['filter_tmpl'] = appstruct['filter_tmpl']
                ldap_settings['scope'] = appstruct['scope']
                # Optional:
                ldap_settings['name'] = appstruct['name']
                ldap_settings['email'] = appstruct['email']
                self.request.db.ldap.save(ldap_settings)

                import ldap
                if ldap_settings['scope'] == 'ONELEVEL':
                    ldap_scope = ldap.SCOPE_ONELEVEL
                else:
                    ldap_scope = ldap.SCOPE_SUBTREE

                from pyramid.config import Configurator
                config = Configurator(registry=self.request.registry)
                config.ldap_setup(
                    ldap_settings['server'],
                    bind=ldap_settings['bind'],
                    passwd=ldap_settings['passwd'],
                    use_tls=ldap_settings['use_tls'])
                config.ldap_set_login_query(
                    base_dn=ldap_settings['base_dn'],
                    filter_tmpl=ldap_settings['filter_tmpl'],
                    scope=ldap_scope)
                config.commit()

                self.session.flash('Successfully updated LDAP settings!', queue='success')

        # Display form
        return dict(title='LDAP Settings', form=ldap_form.render(ldap_settings))
Beispiel #46
0
 def contact(self):
     """ Contact moderators of the meeting
     """
     recipients = []
     for userid in find_role_userids(self.context, ROLE_MODERATOR):
         user = self.api.get_user(userid)
         email = user.get_field_value('email')
         if email:
             recipients.append(email)
     if not recipients:
         for userid in find_authorized_userids(self.context,
                                               (MODERATE_MEETING, )):
             user = self.api.get_user(userid)
             email = user.get_field_value('email')
             if email:
                 recipients.append(email)
     schema = createSchema('ContactSchema').bind(context=self.context,
                                                 request=self.request,
                                                 api=self.api)
     form = Form(schema, buttons=(button_send, ))
     self.api.register_form_resources(form)
     post = self.request.POST
     if self.request.method == 'POST':
         controls = post.items()
         try:
             appstruct = form.validate(controls)
         except ValidationFailure, e:
             self.response['form'] = e.render()
             return self.response
         if appstruct.get('email', None):
             sender = appstruct['email']
             if self.api.user_profile:
                 sender += " <%s>" % self.api.user_profile.title
         else:
             sender = None
         response = {
             'api': self.api,
             'meeting': self.context,
             'name': appstruct['name'],
             'email': appstruct['email'],
             'subject': appstruct['subject'],
             'message': appstruct['message'],
         }
         body_html = render('templates/email/help_contact.pt',
                            response,
                            request=self.request)
         subject = "[%s] %s" % (self.context.title, appstruct['subject'])
         send_email(subject,
                    recipients,
                    body_html,
                    sender=sender,
                    request=self.request)
         self.api.flash_messages.add(_(u"Message sent to the moderators"))
         url = self.request.resource_url(self.context)
         return HTTPFound(location=url)
Beispiel #47
0
def contact(request):
    button1 = Button('submit', _('Send message'))
    button1.css_class = 'btn-primary'
    button2 = Button('cancel', _('Cancel'))
    button2.css_class = 'btn-default'

    form = Form(ContactSchema(), buttons=(button1, button2))

    if 'submit' in request.POST:
        controls = request.POST.items()
        try:
            appstruct = form.validate(controls)
        except ValidationFailure as e:
            return {'form': e.render()}

        context = {'link': request.route_url('contact')}
        context.update(appstruct)
        subject = ("%s sent a message from Yith's contact form" %
                   appstruct['name'])

        result = send_email_to_admins(
            request,
            'yithlibraryserver:templates/email_contact',
            context,
            subject,
            extra_headers={'Reply-To': appstruct['email']},
        )

        if result is None:
            log.error(
                '%s <%s> tried to send a message from the contact form but no '
                'admin emails were configured. Message: %s' % (
                    appstruct['name'],
                    appstruct['email'],
                    appstruct['message'],
                ))

        request.session.flash(
            _('Thank you very much for sharing your opinion'),
            'info',
        )

        return HTTPFound(location=request.route_path('home'))

    elif 'cancel' in request.POST:
        return HTTPFound(location=request.route_path('home'))

    initial = {}
    if request.user is not None:
        initial['name'] = request.user.first_name
        if request.user.email_verified:
            initial['email'] = request.user.email

    return {'form': form.render(initial)}
Beispiel #48
0
def view_contactform(context, request):

    locale_name = get_locale_name(request)

    tmpstore = FileUploadTempStore(request)

    def file_size_limit(node, value):
        value['fp'].seek(0, 2)
        size = value['fp'].tell()
        value['fp'].seek(0)
        max_size = 10
        if size > max_size * 1024 * 1024:
            msg = _('Maximum file size: ${size}MB', mapping={'size': max_size})
            raise colander.Invalid(node, msg)

    def maybe_show_attachment(node, kw):
        if kw.get('maybe_show_attachment', True) is False:
            del node['attachment']

    class SubmissionSchema(colander.MappingSchema):

        name = colander.SchemaNode(colander.String(), title=_("Full Name"))
        sender = colander.SchemaNode(colander.String(),
                                     validator=colander.Email(),
                                     title=_("E-Mail Address"))
        subject = colander.SchemaNode(colander.String(), title=_("Subject"))
        content = colander.SchemaNode(colander.String(),
                                      widget=TextAreaWidget(cols=40, rows=5),
                                      title=_("Your message"))
        attachment = colander.SchemaNode(
            FileData(),
            title=_('Attachment'),
            widget=FileUploadWidget(tmpstore),
            validator=file_size_limit,
            missing=None,
        )
        _LOCALE_ = colander.SchemaNode(colander.String(),
                                       widget=HiddenWidget(),
                                       default=locale_name)

    schema = SubmissionSchema(after_bind=maybe_show_attachment)
    schema = schema.bind(maybe_show_attachment=context.show_attachment)
    form = Form(schema, buttons=[Button('submit', _('Submit'))])
    appstruct = None
    rendered_form = None
    if 'submit' in request.POST:
        controls = request.POST.items()
        try:
            appstruct = form.validate(controls)
            mail_submission(context, request, appstruct)
        except ValidationFailure, e:
            appstruct = None
            rendered_form = e.render()
 def ajax_set_groups(self):
     schema = createSchema('PermissionsSchema')
     add_csrf_token(self.context, self.request, schema)
     schema = schema.bind(context=self.context,
                          request=self.request,
                          api=self.api)
     form = Form(schema, buttons=('save', 'cancel'))
     controls = self.request.POST.items()
     appstruct = form.validate(controls)
     #FIXME: Handle error some way, and return a proper response
     self.context.set_security(appstruct['userids_and_groups'])
     return Response()  # i.e. 200 ok
Beispiel #50
0
def view_delete(request):
    q = query_id(request)
    row = q.first()
    a = row.id
    x = row.approval_level

    if not row:
        return id_not_found(request)
    if x == 1:
        request.session.flash(
            'Data tidak dapat dihapus, karena sudah masuk di Menu Approval.',
            'error')
        return route_list(request)
    if x == 2:
        request.session.flash(
            'Data tidak dapat dihapus, karena sudah disetujui.', 'error')
        return route_list(request)
    if row.disabled:
        request.session.flash(
            'Data tidak dapat dihapus, karena sudah masuk di Menu Approval.',
            'error')
        return route_list(request)
    if row.status_dlv:
        request.session.flash(
            'Data tidak dapat dihapus, karena sudah masuk di Menu Pengiriman Gudang.',
            'error')
        return route_list(request)

    # Seleksi untuk di menu Approval
    r = DBSession.query(ProductReqAppr).filter(
        ProductReqAppr.product_request_id == a).first()
    if r:
        request.session.flash(
            'Hapus dahulu data rencana yang sudah pernah dibuat di Menu Approval.',
            'error')
        return route_list(request)

    # Seleksi untuk mengecek item
    i = DBSession.query(ProductRequestItem).filter(
        ProductRequestItem.product_request_id == a).first()
    if i:
        request.session.flash('Hapus dahulu item produk / barang.', 'error')
        return route_list(request)

    form = Form(colander.Schema(), buttons=('hapus', 'batal'))
    if request.POST:
        if 'hapus' in request.POST:
            msg = 'Order ID %d sudah dihapus.' % (row.id)
            q.delete()
            DBSession.flush()
            request.session.flash(msg)
        return route_list(request)
    return dict(row=row, form=form.render())
Beispiel #51
0
def edit_slideshow(request):
    context = request.context
    form = Form(schema.Slideshow(), buttons=('submit', ))
    appstruct = {
        'name':
        context.name,
        'slides': [
            dict(shard=slide.shard_id, duration=slide.duration)
            for slide in context.slides
        ]
    }
    return {'form': form.render(appstruct), 'title': u'Edit Slideshow'}
Beispiel #52
0
 def add_form(self):
     content_type = self.request.params.get('content_type')
     tag = self.request.GET.get('tag', None)
     #Permission check
     add_permission = self.api.content_types_add_perm(content_type)
     if not has_permission(add_permission, self.context, self.request):
         raise HTTPForbidden(
             "You're not allowed to add '%s' in this context." %
             content_type)
     factory = self.api.get_content_factory(content_type)
     schema_name = self.api.get_schema_name(content_type, 'add')
     schema = createSchema(schema_name).bind(context=self.context,
                                             request=self.request,
                                             api=self.api)
     form = Form(schema, buttons=(button_add, button_cancel))
     self.api.register_form_resources(form)
     if content_type == 'AgendaItem':
         self.response['tabs'] = self.api.render_single_view_component(
             self.context, self.request, 'tabs', 'manage_agenda')
     post = self.request.POST
     if 'add' in post:
         controls = post.items()
         try:
             #appstruct is deforms convention. It will be the submitted data in a dict.
             appstruct = form.validate(controls)
         except ValidationFailure, e:
             self.response['form'] = e.render()
             return self.response
         kwargs = {}
         kwargs.update(appstruct)
         if self.api.userid:
             kwargs['creators'] = [self.api.userid]
         obj = createContent(content_type, **kwargs)
         name = self.generate_slug(obj.title)
         self.context[name] = obj
         self.api.flash_messages.add(_(u"Successfully added"))
         #Success, redirect
         url = self.request.resource_url(obj)
         #Polls might have a special redirect action if the poll plugin has a settings schema:
         if content_type == 'Poll':
             if obj.get_poll_plugin().get_settings_schema() is not None:
                 url += 'poll_config'
             else:
                 url = self.request.resource_url(obj.__parent__,
                                                 anchor=obj.uid)
             msg = _(
                 u"private_poll_info",
                 default=
                 u"The poll is created in private state, to show it the participants you have to change the state to upcoming."
             )
             self.api.flash_messages.add(msg)
         return HTTPFound(location=url)
Beispiel #53
0
def item_new():
    if 'cancel' in request.form:
        return redirect(url_for('.item_list'))

    item_new_schema = ItemNewSchema()
    item_new_form = Form(
        item_new_schema,
        action=url_for('.item_new'),
        buttons=get_form_buttons()
    )

    if 'submit' in request.form:
        print request.form
        try:
            appstruct = item_new_form.validate(request.form.items())
        except ValidationFailure as e:
            current_app.logger.warning(e.error)
            template_context = {'item_new_form': item_new_form}
            return render_template(ITEM_NEW_TEMPLATE, **template_context)

        new_item = Item()
        for key in appstruct:
            if hasattr(new_item, key):
                if appstruct[key] == colander.null:
                    setattr(new_item, key, None)
                else:
                    setattr(new_item, key, appstruct[key])
        Session.add(new_item)
        Session.flush()

        clients = get_client_list()
        client_items_to_add = []
        for client in clients:
            client_item = Session.query(ClientItem)\
                .filter(ClientItem.client_id == client.id,
                        ClientItem.item_id == new_item.id,
                        ClientItem.deleted == False).first()
            if not client_item:
                client_item = ClientItem(client.id, new_item.id, new_item.price)
                client_items_to_add.append(client_item)
        if client_items_to_add:
            Session.add_all(client_items_to_add)
            Session.flush()

        flash(u'Uspješno ste dodali novi artikl', 'success')
        return redirect(url_for('.item_list'))

    template_context = {
        'page_title': u'Novi artikl',
        'item_new_form': item_new_form
    }
    return render_template(ITEM_NEW_TEMPLATE, **template_context)
Beispiel #54
0
    def support(self):
        """ Support form - requires support email to be set!
        """
        support_email = self.api.root.get_field_value('support_email', None)
        if not support_email:
            self.api.flash_messages.add(
                _(u"No support email set for this site. Form won't work!"))
            url = self.request.resource_url(self.context)
            return HTTPFound(location=url)
        schema = createSchema('SupportSchema').bind(context=self.context,
                                                    request=self.request,
                                                    api=self.api)
        form = Form(schema,
                    action=self.request.resource_url(self.context, 'support'),
                    buttons=(button_send, ))
        self.api.register_form_resources(form)

        post = self.request.POST
        if self.request.method == 'POST':
            controls = post.items()
            try:
                appstruct = form.validate(controls)
            except ValidationFailure, e:
                self.response['form'] = e.render()
                return self.response

            sender = appstruct['email'] and appstruct[
                'email'] or "VoteIT <*****@*****.**>"
            response = {
                'api': self.api,
                'meeting': self.api.meeting,
                'name': appstruct['name'],
                'email': appstruct['email'],
                'subject': appstruct['subject'],
                'message': appstruct['message'],
                'meeting_title': appstruct.get('meeting_title', ''),
            }
            body_html = render('templates/email/support.pt',
                               response,
                               request=self.request)
            title = "%s %s" % (self.api.root.get_field_value(
                'site_title', u"VoteIT"), self.api.translate(_(u"Support")))
            subject = "[%s] | %s" % (title, appstruct['subject'])
            msg = Message(subject=subject,
                          sender=sender and sender or None,
                          recipients=(support_email, ),
                          html=body_html)
            mailer = get_mailer(self.request)
            mailer.send(msg)
            self.api.flash_messages.add(_(u"Support request sent!"))
            url = self.request.resource_url(self.context)
            return HTTPFound(location=url)
Beispiel #55
0
 def account_view(self):
     """This is the settings form for the user. The first time a
     user logs in, they are taken here so we can get their first and
     last name.
     """
     # Special case when the db was blown away
     if self.user_id is not None and self.user is None:
         return self.logout()
     section_name = 'account'
     schema = SettingsSchema()
     form = Form(schema, buttons=('submit', ))
     css_resources, js_resources = self.form_resources(form)
     if 'submit' in self.request.POST:
         controls = self.request.POST.items()
         try:
             form.validate(controls)
         except ValidationFailure as e:
             msg = 'There was an error saving your settings.'
             self.request.session.flash(msg, queue='error')
             return {
                 'form': e.render(),
                 'css_resources': css_resources,
                 'js_resources': js_resources,
                 'section': section_name,
             }
         values = parse(self.request.params.items())
         # Update the user
         with transaction.manager:
             self.user.first_name = values.get('first_name', u'')
             self.user.last_name = values.get('last_name', u'')
             self.user.time_zone = values.get('time_zone', u'US/Eastern')
             DBSession.add(self.user)
         self.request.session.flash(
             'Settings updated successfully',
             queue='success',
         )
         return HTTPFound('/list')
     # Get existing values
     if self.user is not None:
         appstruct = dict(
             first_name=self.user.first_name,
             last_name=self.user.last_name,
             time_zone=self.user.time_zone,
         )
     else:
         appstruct = {}
     return {
         'form': form.render(appstruct),
         'css_resources': css_resources,
         'js_resources': js_resources,
         'section': section_name,
     }
Beispiel #56
0
def view_admin(request):
    id_ = request.matchdict['id']
    geo_form_schema = _get_schema(request)
    renderer = _get_renderer(geo_form_schema.templates_admin)
    form = Form(geo_form_schema.schema_admin, buttons=('submit',),
                renderer=renderer)
    obj = DBSession.query(geo_form_schema.model).get(id_)
    rendered = form.render(geo_form_schema.schema_admin.dictify(obj),
                           readonly=True, request=request)
    return {
        'form': rendered,
        'schema': geo_form_schema,
        'deform_dependencies': form.get_widget_resources()}
Beispiel #57
0
    def get_form(self, schema):
        """
        Return the search form that should be used for this view

        :param obj schema: The form's colander.Schema
        :returns: The form object
        :rtype: obj
        """
        # counter is used to avoid field name conflicts
        form = Form(schema, counter=itertools.count(15000), method='GET')
        form = self.set_form_widget(form)
        form.buttons = (self.get_filter_button(), )
        return form
Beispiel #58
0
 def get_form(self, schema):
     # counter is used to avoid field name conflicts
     form = Form(schema, counter=itertools.count(15000), method='GET')
     if self.grid is not None:
         form.formid = 'grid_search_form'
         form.widget = deform_extensions.GridFormWidget(
             named_grid=self.grid)
         form.buttons = (deform.Button(title='Filtrer',
                                       name='submit',
                                       type='submit',
                                       css_class='btn btn-primary'), )
     else:
         form.widget.template = "autonomie:deform_templates/searchform.pt"
     return form
Beispiel #59
0
def view_delete(request):
    q = query_id(request)
    row = q.first()
    if not row:
        return id_not_found(request)
    form = Form(colander.Schema(), buttons=('delete', 'cancel'))
    if request.POST:
        if 'delete' in request.POST:
            msg = 'Rekon E-PAP ID %d berhasil dihapus.' % (row.id)
            q.delete()
            DBSession.flush()
            request.session.flash(msg)
        return route_list(request)
    return dict(row=row, form=form.render())
Beispiel #60
0
def client_edit(client_id):
    if 'cancel' in request.form:
        return redirect(url_for('.client_list'))

    client = Session.query(Client).filter(Client.id == client_id,
                                          Client.deleted == False).first()
    if not client:
        current_app.logger.warning(
            u'Client with id {0} not found'.format(client_id))
        flash(u'Klijent nije pronađen', 'danger')
        return redirect(url_for('.client_list'))

    client_new_schema = ClientNewValidator()
    client_new_form = Form(client_new_schema,
                           action=url_for('.client_edit', client_id=client.id),
                           appstruct=client.get_appstruct(),
                           buttons=get_form_buttons())

    if 'submit' in request.form:
        print request.form
        try:
            controls = request.form.items(multi=True)
            appstruct = client_new_form.validate(controls)
        except ValidationFailure as e:
            current_app.logger.warning(e.error)
            template_context = {'client_new_form': client_new_form}
            return render_template(CLIENT_NEW_TEMPLATE, **template_context)

        edited = False
        for key in appstruct:
            if hasattr(client, key):
                if appstruct[key] != colander.null:
                    if getattr(client, key) != appstruct[key]:
                        setattr(client, key, appstruct[key])
                        edited = True
                else:
                    if getattr(client, key) is not None:
                        setattr(client, key, None)
                        edited = True

        if edited:
            Session.flush()
            flash(u'Uspješno ste uredili klijenta', 'success')
        return redirect(url_for('.client_list'))

    template_context = {
        'page_title': u'Uredi klijenta',
        'client_new_form': client_new_form
    }
    return render_template(CLIENT_NEW_TEMPLATE, **template_context)