Пример #1
0
    def sendmail_record(self, record=None, thermo=None, storagekey=None,**kwargs):
        record.update(self.batch_parameters)
        as_pdf = self.batch_parameters['as_pdf']
        to_address = templateReplace(self.mail_pars.getItem('to_address',''),record)
        subject = templateReplace(self.mail_pars.getItem('subject',''),record)
        cc_address = templateReplace(self.mail_pars.getItem('cc_address',''),record)

        htmlContent=templateReplace(self.compiledTemplate,record, 
                                    safeMode=True,noneIsBlank=False,
                                    locale=self.page.locale,
                                    formats=self.compiledTemplate.getItem('main?formats'),
                                    masks=self.compiledTemplate.getItem('main?masks'),
                                    localizer=self.page.localizer)
                                    
        result = self.htmlMaker(htmlContent=htmlContent,
                                filename='%s.html' %record['id'],
                                record=record, thermo=thermo, pdf=as_pdf,
                                **self.batch_parameters)
        if result:
            attachments = templateReplace(self.mail_pars.getItem('attachments',''),record)
            attachments = attachments.split(',') if attachments else []
            body = None
            if as_pdf:
                attachments.append(result)
                body = ''
            else:
                body = result
                attachments = attachments or None
            self.send_one_email(to_address=to_address,cc_address=cc_address,subject=subject,body=body,attachments=attachments,_record_id=record[self.tblobj.pkey])
Пример #2
0
    def sendMailTemplate(self, tpl, mailto, params, locale=None, **kwargs):
        locale = locale or self.locale
        localelang = locale.split('-')[0]
        mailtpl = self.getMailTemplate(tpl, locale=localelang)

        if mailtpl:
            subject = templateReplace(mailtpl['subject'], params)
            body = templateReplace(mailtpl['body'], params)
            self.application.sendmail(mailtpl['from_address'], mailto, subject, body)
            return 'mail sent'
Пример #3
0
    def sendMailTemplate(self, tpl, mailto, params, locale=None, **kwargs):
        locale = locale or self.locale
        localelang = locale.split("-")[0]
        mailtpl = self.getMailTemplate(tpl, locale=localelang)

        if mailtpl:
            subject = templateReplace(mailtpl["subject"], params)
            body = templateReplace(mailtpl["body"], params)
            self.application.sendmail(mailtpl["from_address"], mailto, subject, body)
            return "mail sent"
Пример #4
0
    def sendMailTemplate(self, tpl, mailto, params, locale=None, **kwargs):
        locale = locale or self.locale
        localelang = locale.split('-')[0]
        mailtpl = self.getMailTemplate(tpl, locale=localelang)

        if mailtpl:
            subject = templateReplace(mailtpl['subject'], params)
            body = templateReplace(mailtpl['body'], params)
            self.application.sendmail(mailtpl['from_address'], mailto, subject,
                                      body)
            return 'mail sent'
Пример #5
0
 def print_record(self,
                  record=None,
                  thermo=None,
                  storagekey=None,
                  **kwargs):
     record.update(self.batch_parameters)
     htmlContent = templateReplace(
         self.compiledTemplate,
         record,
         safeMode=True,
         noneIsBlank=False,
         locale=self.page.locale,
         formats=self.compiledTemplate.getItem('main?formats'),
         masks=self.compiledTemplate.getItem('main?masks'),
         dtypes=self.compiledTemplate.getItem('main?dtypes'),
         localizer=self.page.localizer,
         urlformatter=self.page.externalUrl)
     result = self.htmlMaker(htmlContent=htmlContent,
                             filename='%s.html' % record['id'],
                             record=record,
                             thermo=thermo,
                             pdf=self.pdf_make,
                             **self.batch_parameters)
     if result:
         self.storeResult(storagekey,
                          result,
                          record,
                          filepath=self.htmlMaker.filepath)
Пример #6
0
    def te_renderTemplate(self, templateBuilder, record_id=None, extraData=None, locale=None,contentOnly=False,**kwargs):
        record = Bag()
        if record_id:
            record = templateBuilder.data_tblobj.record(pkey=record_id,
                                                        virtual_columns=templateBuilder.virtual_columns).output('bag')
        else:
            record = templateBuilder.data_tblobj.record(pkey='*sample*',ignoreMissing=True,
                                                        virtual_columns=templateBuilder.virtual_columns).output('sample')
        if extraData:
            record.update(extraData)
        locale = locale or templateBuilder.locale
        formats = templateBuilder.formats or dict()
        masks = templateBuilder.masks or dict()
        editcols = templateBuilder.editcols or dict()

        df_templates = templateBuilder.df_templates or dict()
        dtypes = templateBuilder.dtypes or dict()

        record.setItem('_env_', Bag(self.db.currentEnv))
        #record.setItem('_template_', templateBuilder.doctemplate_info)
        htmlContent = templateReplace(templateBuilder.doctemplate,record, safeMode=True,noneIsBlank=False,locale=locale, 
                                                            formats=formats,masks=masks,editcols=editcols,df_templates=df_templates,
                                                            dtypes=dtypes,localizer=self.localizer,
                                                            urlformatter=self.externalUrl)
        if contentOnly:
            return htmlContent
        body = templateBuilder(htmlContent=htmlContent,
                            record=record,page_debug='silver',**kwargs)
        return body
Пример #7
0
 def te_renderChunk(self,
                    record_id=None,
                    template_address=None,
                    templates=None,
                    template_id=None,
                    **kwargs):
     data, dataInfo = self.loadTemplate(template_address=template_address,
                                        asSource=True)
     if not data:
         return '<div class="chunkeditor_emptytemplate">Template not yet created</div>', dataInfo
     compiled = data['compiled']
     result = Bag()
     if not compiled:
         content = data['content']
         record = self.db.table(
             template_address.split(':')[0]).recordAs(record_id)
         result['rendered'] = templateReplace(content, record)
         result['template_data'] = data
         return result, dataInfo
     tplbuilder = self.te_getTemplateBuilder(compiled=compiled,
                                             templates=templates)
     result['rendered'] = self.te_renderTemplate(
         tplbuilder,
         record_id=record_id,
         extraData=Bag(dict(host=self.request.host)),
         contentOnly=True)
     result['template_data'] = data
     return result, dataInfo
Пример #8
0
 def sendMailTemplateMany(self, tpl, mailto_param, locale_param, params_list, **kwargs):
     mailtpldict = {}
     send_errors = []
     for params in params_list:
         locale = params.get(locale_param) or self.locale
         mailtpl = mailtpldict.get(locale)
         if not mailtpl:
             mailtpl = self.getMailTemplate(tpl, locale=locale)
             mailtpldict[locale] = mailtpl
         try:
             subject = templateReplace(mailtpl["subject"], params)
             body = templateReplace(mailtpl["body"], params)
             self.application.sendmail(mailtpl["from_address"], params[mailto_param], subject, body)
         except:
             send_errors.append(params[mailto_param])
     return send_errors
Пример #9
0
 def templateReplaceRow(self, row, totals=False):
     if not row: return ''
     if totals or row.get('_gnr_tbl_footer'):
         row_template = '<tfoot>%s</tfoot>' % (self.row_template_totals or self.row_template)
     else:
         row_template = self.row_template
     return gnrstring.templateReplace(row_template, row, safeMode=True)# per debug
Пример #10
0
    def sendmail_record(self,
                        record=None,
                        thermo=None,
                        storagekey=None,
                        **kwargs):
        record.update(self.batch_parameters)
        as_pdf = self.batch_parameters['as_pdf']
        to_address = templateReplace(self.mail_pars.getItem('to_address', ''),
                                     record)
        subject = templateReplace(self.mail_pars.getItem('subject', ''),
                                  record)
        cc_address = templateReplace(self.mail_pars.getItem('cc_address', ''),
                                     record)

        htmlContent = templateReplace(
            self.compiledTemplate,
            record,
            safeMode=True,
            noneIsBlank=False,
            locale=self.page.locale,
            formats=self.compiledTemplate.getItem('main?formats'),
            masks=self.compiledTemplate.getItem('main?masks'),
            localizer=self.page.localizer)

        result = self.htmlMaker(htmlContent=htmlContent,
                                filename='%s.html' % record['id'],
                                record=record,
                                thermo=thermo,
                                pdf=as_pdf,
                                **self.batch_parameters)
        if result:
            attachments = templateReplace(
                self.mail_pars.getItem('attachments', ''), record)
            attachments = attachments.split(',') if attachments else []
            body = None
            if as_pdf:
                attachments.append(result)
                body = ''
            else:
                body = result
                attachments = attachments or None
            self.send_one_email(to_address=to_address,
                                cc_address=cc_address,
                                subject=subject,
                                body=body,
                                attachments=attachments,
                                _record_id=record[self.tblobj.pkey])
Пример #11
0
def test_templateReplace():
    """docstring for test_templateReplace"""
    assert gnrstring.templateReplace(
        '$foo loves $bar but she loves $aux and not $foo', {
            'foo': 'John',
            'bar': 'Sandra',
            'aux': 'Steve'
        }) == 'John loves Sandra but she loves Steve and not John'
Пример #12
0
 def te_compileBagForm(self,table=None,sourcebag=None,varsbag=None,parametersbag=None,record_id=None,templates=None):
     result = Bag()
     varsdict = dict()
     for varname,fieldpath in varsbag.digest('#v.varname,#v.fieldpath'):
         varsdict[varname] = '$%s' %fieldpath
     for k,v in sourcebag.items():
         if v:
             result[k] = templateReplace(v, varsdict, True,False,urlformatter=self.externalUrl)
     return result
Пример #13
0
 def templateReplaceRow(self, row, totals=False):
     if not row: return ''
     if totals or row.get('_gnr_tbl_footer'):
         row_template = '<tfoot>%s</tfoot>' % (self.row_template_totals
                                               or self.row_template)
     else:
         row_template = self.row_template
     return gnrstring.templateReplace(row_template, row,
                                      safeMode=True)  # per debug
Пример #14
0
 def sendMailTemplateMany(self, tpl, mailto_param, locale_param,
                          params_list, **kwargs):
     mailtpldict = {}
     send_errors = []
     for params in params_list:
         locale = params.get(locale_param) or self.locale
         mailtpl = mailtpldict.get(locale)
         if not mailtpl:
             mailtpl = self.getMailTemplate(tpl, locale=locale)
             mailtpldict[locale] = mailtpl
         try:
             subject = templateReplace(mailtpl['subject'], params)
             body = templateReplace(mailtpl['body'], params)
             self.application.sendmail(mailtpl['from_address'],
                                       params[mailto_param], subject, body)
         except:
             send_errors.append(params[mailto_param])
     return send_errors
Пример #15
0
    def openPage(self):
        html = """
    <html>
        <head>
            <meta http-equiv="content-type" content="text/html; charset=utf-8" />
            <style type="text/css">    
                $all_css
            </style>
            
            <script type="text/javascript">
                var genro = window.parent.genro;
            </script>
            <title>$title</title>
        </head>
        <body class="$bodyclasses tableWindow">
            $header
            <table class="full_page $tableclass" id="maintable">
            """
        all_css = []
        self.page.theme = getattr(self.page, 'theme', 'tundra')
        styles = self.page.get_css_genro()
        print_styles = styles.pop('print', [])

        for cssmedia, cssnames in styles.items():
            for cssname in cssnames:
                all_css.append('@import url("%s") %s;' % (cssname, cssmedia))

        for cssname in print_styles:
            all_css.append('@import url("%s") print;' % (cssname, ))

        cssname = self.page.getResourceUri('html_tables/html_tables', 'css')
        all_css.append('@import url("%s") %s;' % (cssname, 'all'))

        cssname = self.page.getResourceUri('html_tables/html_tables_print',
                                           'css')
        all_css.append('@import url("%s") %s;' % (cssname, 'print'))

        css_path, css_media_path = self.page.get_css_path()

        for cssname in css_path:
            all_css.append('@import url("%s");' % cssname)

        for cssmedia, cssnames in css_media_path.items():
            for cssname in cssnames:
                all_css.append('@import url("%s") %s;' % (cssname, cssmedia))

        html = gnrstring.templateReplace(
            html,
            dict(all_css='\n'.join(all_css),
                 bodyclasses=self.page.get_bodyclasses(),
                 title=self.title,
                 header=self.header,
                 tableclass=self.tableclass))
        return html
Пример #16
0
 def do(self):
     thermo_s = dict(line_code='selection', message='sending')
     smspars = dict()
     smspars.update(self.sms_preference.asDict(True))
     pkeys = self.get_selection_pkeys()
     for pkey in self.btc.thermo_wrapper(pkeys, **thermo_s):
         
         smspars['data'] = templateReplace(value, datasource)
         self.doctemplate_tbl.renderTemplate(self.htmlBuilder, record_id=pkey)
         smspars['receiver'] = record[self.batch_parameters.get('receiver')]
         self.sms_handler.sendsms(**smspars)
Пример #17
0
 def renderTemplate(self, templateBuilder, record_id=None, extraData=None):
     record = Bag()
     if record_id:
         record = templateBuilder.data_tblobj.record(pkey=record_id,
                                                     virtual_columns=templateBuilder.virtual_columns).output('bag')
     if extraData:
         record.update(extraData)
     record.setItem('_env_', Bag(self.db.currentEnv))
     record.setItem('_template_', templateBuilder.doctemplate_info)
     templateBuilder.record = record
     return templateBuilder(htmlContent=templateReplace(templateBuilder.doctemplate, record, True))
Пример #18
0
    def do(self):
        thermo_s = dict(line_code='selection', message='sending')
        smspars = dict()
        smspars.update(self.sms_preference.asDict(True))
        pkeys = self.get_selection_pkeys()
        for pkey in self.btc.thermo_wrapper(pkeys, **thermo_s):

            smspars['data'] = templateReplace(value, datasource)
            self.doctemplate_tbl.renderTemplate(self.htmlBuilder,
                                                record_id=pkey)
            smspars['receiver'] = record[self.batch_parameters.get('receiver')]
            self.sms_handler.sendsms(**smspars)
Пример #19
0
    def sendUserTemplateMail(self,record_id=None,letterhead_id=None,template_id=None,table=None,template_code=None,attachments=None,**kwargs):
        if template_id:
            tpl,table = self.parent.db.table('adm.userobject').readColumns(pkey=template_id,columns='$data,$tbl',bagFields=True)
        elif template_code and table:
            tpl = self.parent.db.table('adm.userobject').readColumns(where='$tbl=:tb AND $code=:tc AND $objtype=:ot',
                                                             ot='template',tc=template_code,tb=table,
                                                             columns='$data',bagFields=True)
        tpl = Bag(tpl)
        metadata = tpl['metadata']
        compiled = tpl['compiled']
        email_compiled = metadata['email_compiled']
        htmlbuilder = TableTemplateToHtml(table=self.parent.db.table(table))
        html_text = htmlbuilder(record=record_id,template=compiled,letterhead_id=letterhead_id or metadata['default_letterhead'])
        to_address = templateReplace(email_compiled.getItem('to_address',''),htmlbuilder.record)
        subject = templateReplace(email_compiled.getItem('subject',''),htmlbuilder.record)
        cc_address = templateReplace(email_compiled.getItem('cc_address',''),htmlbuilder.record)
        bcc_address = templateReplace(email_compiled.getItem('bcc_address',''),htmlbuilder.record)
        from_address = templateReplace(email_compiled.getItem('from_address',''),htmlbuilder.record)
        attachments = attachments or templateReplace(email_compiled.getItem('attachments',''),htmlbuilder.record)
        if attachments and isinstance(attachments,basestring):
            attachments = attachments.replace('\n',',').split(',')

        assert to_address,'Missing email address'
        kwargs.setdefault('html',True)
        self.sendmail(to_address=to_address,subject=subject,cc_address=cc_address, bcc_address=bcc_address,
                      from_address=from_address, body=html_text,attachments=attachments,**kwargs)
Пример #20
0
 def renderTemplate(self, templateBuilder, record_id=None, extraData=None):
     record = Bag()
     if record_id:
         record = templateBuilder.data_tblobj.record(
             pkey=record_id,
             virtual_columns=templateBuilder.virtual_columns).output('bag')
     if extraData:
         record.update(extraData)
     record.setItem('_env_', Bag(self.db.currentEnv))
     record.setItem('_template_', templateBuilder.doctemplate_info)
     templateBuilder.record = record
     return templateBuilder(htmlContent=templateReplace(
         templateBuilder.doctemplate, record, True))
Пример #21
0
 def contentFromTemplate(self,record,template,locale=None,**kwargs):
     virtual_columns=None
     if isinstance(template,Bag):
         kwargs['locale'] = locale or template.getItem('main?locale')
         kwargs['masks'] = template.getItem('main?masks')
         kwargs['formats'] = template.getItem('main?formats')
         kwargs['df_templates'] = template.getItem('main?df_templates')
         kwargs['dtypes'] = template.getItem('main?dtypes')
         virtual_columns = template.getItem('main?virtual_columns')
     self.record = self.tblobj.recordAs(record,virtual_columns=virtual_columns)
     return templateReplace(template,self.record, safeMode=True,noneIsBlank=False,
                 localizer=self.db.application.localizeText,urlformatter=self.site.externalUrl,
                 **kwargs)
Пример #22
0
 def contentFromTemplate(self,record,template,locale=None,**kwargs):
     virtual_columns=None
     if isinstance(template,Bag):
         kwargs['locale'] = locale or template.getItem('main?locale')
         kwargs['masks'] = template.getItem('main?masks')
         kwargs['formats'] = template.getItem('main?formats')
         kwargs['df_templates'] = template.getItem('main?df_templates')
         kwargs['dtypes'] = template.getItem('main?dtypes')
         virtual_columns = template.getItem('main?virtual_columns')
     self.record = self.tblobj.recordAs(record,virtual_columns=virtual_columns)
     return templateReplace(template,self.record, safeMode=True,noneIsBlank=False,
                 localizer=self.db.application.localizer,urlformatter=self.site.externalUrl,
                 **kwargs)
Пример #23
0
 def openPage(self):
     html = """
 <html>
     <head>
         <meta http-equiv="content-type" content="text/html; charset=utf-8" />
         <style type="text/css">    
             $all_css
         </style>
         
         <script type="text/javascript">
             var genro = window.parent.genro;
         </script>
         <title>$title</title>
     </head>
     <body class="$bodyclasses tableWindow">
         $header
         <table class="full_page $tableclass" id="maintable">
         """
     all_css = []
     self.page.theme = getattr(self.page, 'theme', 'tundra')
     styles = self.page.get_css_genro()
     print_styles = styles.pop('print', [])
     
     for cssmedia, cssnames  in styles.items():
         for cssname in cssnames:
             all_css.append('@import url("%s") %s;' % (cssname, cssmedia))
             
     for cssname in print_styles:
         all_css.append('@import url("%s") print;' % (cssname, ))
         
     cssname = self.page.getResourceUri('html_tables/html_tables', 'css')
     all_css.append('@import url("%s") %s;' % (cssname, 'all'))
     
     cssname = self.page.getResourceUri('html_tables/html_tables_print', 'css')
     all_css.append('@import url("%s") %s;' % (cssname, 'print'))
     
     css_path, css_media_path = self.page.get_css_path()
     
     for cssname in css_path:
         all_css.append('@import url("%s");' % cssname)
         
     for cssmedia, cssnames  in css_media_path.items():
         for cssname in cssnames:
             all_css.append('@import url("%s") %s;' % (cssname, cssmedia))
             
     html = gnrstring.templateReplace(html, dict(all_css='\n'.join(all_css),
                                                 bodyclasses=self.page.get_bodyclasses(),
                                                 title=self.title, header=self.header,
                                                 tableclass=self.tableclass))
     return html
Пример #24
0
class SmsMobyt(GnrBaseService):
    def __init__(self,
                 parent,
                 username=None,
                 password=None,
                 url=None,
                 auth=None,
                 sender=None):
        self.parent = parent
        self.username = username
        self.password = password
        self.url = url
        self.auth = auth
        self.sender = sender

    def sendsms_template(self,
                         receiver=None,
                         sender=None,
                         opcode=None,
                         data=None,
                         quality=None,
                         messageId=None,
                         batchId=None,
                         urlbatch=None,
                         async=False,
                         **kwargs):
        def get_templated(field):
            value = datasource.get(field)

            if value:
                return templateReplace(value, datasource)

        receiver = receiver or get_templated('receiver')
        sender = sender or get_templated('sender')
        opcode = opcode or get_templated('opcode')
        sender = sender or get_templated('sender')
        quality = quality or get_templated('quality')
        messageId = messageId or get_templated('messageId')
        urlbatch = urlbatch or get_templated('urlbatch')
        data = data or get_templated('data')
        data = templateReplace(data, datasource)
        self.sendsms(receiver=receiver,
                     sender=sender,
                     opcode=opcode,
                     data=data,
                     quality=quality,
                     messageId=messageId,
                     batchId=batchId,
                     urlbatch=urlbatch,
                     async=async)
Пример #25
0
    def te_renderTemplate(self,
                          templateBuilder,
                          record_id=None,
                          extraData=None,
                          locale=None,
                          contentOnly=False,
                          **kwargs):
        record = Bag()
        if record_id:
            record = templateBuilder.data_tblobj.record(
                pkey=record_id,
                virtual_columns=templateBuilder.virtual_columns).output('bag')
        else:
            record = templateBuilder.data_tblobj.record(
                pkey='*sample*',
                ignoreMissing=True,
                virtual_columns=templateBuilder.virtual_columns).output(
                    'sample')
        if extraData:
            record.update(extraData)
        locale = locale or templateBuilder.locale
        formats = templateBuilder.formats or dict()
        masks = templateBuilder.masks or dict()
        editcols = templateBuilder.editcols or dict()

        df_templates = templateBuilder.df_templates or dict()
        dtypes = templateBuilder.dtypes or dict()

        record.setItem('_env_', Bag(self.db.currentEnv))
        #record.setItem('_template_', templateBuilder.doctemplate_info)
        htmlContent = templateReplace(templateBuilder.doctemplate,
                                      record,
                                      safeMode=True,
                                      noneIsBlank=False,
                                      locale=locale,
                                      formats=formats,
                                      masks=masks,
                                      editcols=editcols,
                                      df_templates=df_templates,
                                      dtypes=dtypes,
                                      localizer=self.localizer,
                                      urlformatter=self.externalUrl)
        if contentOnly:
            return htmlContent
        body = templateBuilder(htmlContent=htmlContent,
                               record=record,
                               page_debug='silver',
                               **kwargs)
        return body
Пример #26
0
 def te_renderChunk(self, record_id=None,template_address=None,templates=None,template_id=None,**kwargs):
     data,dataInfo = self.loadTemplate(template_address=template_address,asSource=True)
     if not data:
         return '<div class="chunkeditor_emptytemplate">Template not yet created</div>',dataInfo
     compiled = data['compiled']
     result = Bag()
     if not compiled:
         content = data['content']
         record = self.db.table(template_address.split(':')[0]).recordAs(record_id)
         result['rendered'] = templateReplace(content,record)
         result['template_data'] = data
         return result,dataInfo
     tplbuilder = self.te_getTemplateBuilder(compiled=compiled, templates=templates)
     result['rendered'] = self.te_renderTemplate(tplbuilder, record_id=record_id, extraData=Bag(dict(host=self.request.host)),contentOnly=True)
     result['template_data'] = data
     return result,dataInfo
Пример #27
0
 def print_record(self, record=None, thermo=None, storagekey=None,**kwargs):
     record.update(self.batch_parameters)
     htmlContent=templateReplace(self.compiledTemplate,record, 
                                 safeMode=True,noneIsBlank=False,
                                 locale=self.page.locale,
                                 formats=self.compiledTemplate.getItem('main?formats'),
                                 masks=self.compiledTemplate.getItem('main?masks'),
                                 dtypes=  self.compiledTemplate.getItem('main?dtypes'),
                                 localizer=self.page.localizer,
                                 urlformatter=self.page.externalUrl)
     result = self.htmlMaker(htmlContent=htmlContent,
                             filename='%s.html' %record['id'],
                             record=record, thermo=thermo, pdf=self.pdf_make,
                             **self.batch_parameters)
     if result:
         self.storeResult(storagekey, result, record, filepath=self.htmlMaker.filepath)        
Пример #28
0
 def te_compileBagForm(self,
                       table=None,
                       sourcebag=None,
                       varsbag=None,
                       parametersbag=None,
                       record_id=None,
                       templates=None):
     result = Bag()
     varsdict = dict()
     for varname, fieldpath in varsbag.digest('#v.varname,#v.fieldpath'):
         varsdict[varname] = '$%s' % fieldpath
     for k, v in sourcebag.items():
         if v:
             result[k] = templateReplace(v,
                                         varsdict,
                                         True,
                                         False,
                                         urlformatter=self.externalUrl)
     return result
Пример #29
0
 def doTable(self):
     html = []
     openpage = gnrstring.templateReplace('<table class="full_page $tableclass" id="maintable">',
                                          dict(tableclass=self.tableclass))
     html.append(openpage)
     
     if hasattr(self.source, 'serverfetch'):
         rowsource = self.fromServerCursor(50)
     else:
         rowsource = self.fromList()
         
     html.extend(rowsource)
     
     html.append('</tbody>')
     if self.tot_cb:
         html.append(self.buildTableRow(self.tot_cb(), totals=True))
         
     html.append('</table>')
     return '\n'.join(html)
Пример #30
0
    def doTable(self):
        html = []
        openpage = gnrstring.templateReplace(
            '<table class="full_page $tableclass" id="maintable">',
            dict(tableclass=self.tableclass))
        html.append(openpage)

        if hasattr(self.source, 'serverfetch'):
            rowsource = self.fromServerCursor(50)
        else:
            rowsource = self.fromList()

        html.extend(rowsource)

        html.append('</tbody>')
        if self.tot_cb:
            html.append(self.buildTableRow(self.tot_cb(), totals=True))

        html.append('</table>')
        return '\n'.join(html)
Пример #31
0
 def recordCaption(self, record, newrecord=False, rowcaption=None):
     """add???
     
     :param record: add???
     :param newrecord: boolean. add???. Default value is ``False``
     :param rowcaption: add???. Default value is ``None``
     :returns: add???
     """
     if newrecord:
         return '!!New %s' % self.name_long.replace('!!', '')
     else:
         fields, mask = self.rowcaptionDecode(rowcaption)
         if not fields:
             return ''
         fields = [f.lstrip('$') for f in fields]
         if not isinstance(record, Bag):
             fields = [self.db.colToAs(f) for f in fields]
         cols = [(c, gnrstring.toText(record[c])) for c in fields]
         if '$' in mask:
             caption = gnrstring.templateReplace(mask, dict(cols))
         else:
             caption = mask % tuple([v for k, v in cols])
         return caption
Пример #32
0
 def te_compileTemplate(self,table=None,datacontent=None,varsbag=None,parametersbag=None,record_id=None,templates=None,template_id=None):
     result = Bag()
     formats = dict()
     editcols = dict()
     masks = dict()
     df_templates = dict()
     dtypes = dict()
     columns = []
     virtual_columns = []
     varsdict = dict()
     if varsbag:
         tplvars =  varsbag.digest('#v.varname,#v.fieldpath,#v.virtual_column,#v.required_columns,#v.format,#v.mask,#v.editable,#v.df_template,#v.dtype')
         for varname,fldpath,virtualcol,required_columns,format,mask,editable,df_template,dtype in tplvars:
             fk=''
             if format:
                 fk=varname
                 formats[varname] = format
             if mask:
                 fk=varname
                 masks[varname] = mask
             if editable:
                 fk=varname
                 editcols[varname] = editable
             if df_template:
                 fk=varname
                 df_templates[varname] = df_template
             if dtype:
                 dtypes[varname] = dtype
             if fk:
                 fk='^%s'%fk
             varsdict[varname] = '$%s%s' %(fldpath,fk)
             columns.append(fldpath)
             if virtualcol:
                 virtual_columns.append(fldpath)
             if required_columns:
                 prefix = '.'.join(fldpath.split('.')[0:-1])
                 for c in required_columns.split(','):
                     if not c in virtual_columns:
                         virtual_columns.append('%s.%s' %(prefix,c.replace('$','')) if prefix else c)
     if parametersbag:
         tplpars = parametersbag.digest('#v.code,#v.format,#v.mask')
         for code,format,mask in tplpars:
             formats[code] = format
             masks[code] = mask
     template = templateReplace(datacontent, varsdict, True,False,conditionalMode=False)
     compiled = Bag()
     cmain = template
     if HT:
         doc = HT.parse(StringIO(template)).getroot()
         htmltables = doc.xpath('//table')
         for t in htmltables:
             attributes = t.attrib
             if 'row_datasource' in attributes:
                 subname = attributes['row_datasource']
                 tbody = t.xpath('tbody')[0]
                 tbody_lastrow = tbody.getchildren()[-1]
                 tbody.replace(tbody_lastrow,HT.etree.Comment('TEMPLATEROW:$%s' %subname))
                 subtemplate=HT.tostring(tbody_lastrow).replace('%s.'%subname,'').replace('%24','$')
                 compiled.setItem(subname.replace('.','_'),subtemplate)
         cmain = TEMPLATEROW.sub(lambda m: '\n%s\n'%m.group(1),HT.tostring(doc).replace('%24','$'))
     compiled.setItem('main', cmain,
                         maintable=table,locale=self.locale,virtual_columns=','.join(virtual_columns),
                         columns=','.join(columns),formats=formats,masks=masks,editcols=editcols,df_templates=df_templates,dtypes=dtypes)
     result.setItem('compiled',compiled)
     if record_id:
         result.setItem('preview',self.te_getPreview(compiled=compiled,record_id=record_id,templates=templates,template_id=template_id))
     return result
Пример #33
0
 def fillLetterheadSourceData(self, node, **kwargs):
     if node.label == 'html':
         node.value = templateReplace(node.value,
                                      self.letterhead_sourcedata)
Пример #34
0
 def get_templated(field):
     value = datasource.getItem('_meta_.%s' % field)
     if not value:
         value = datasource.getItem(field)
     if value:
         return templateReplace(value, datasource)
Пример #35
0
 def prepareRow(self,row):
     self.rowCell(value='%s::HTML' %templateReplace(self.row_tpl,Bag(self.currRowDataNode)))
Пример #36
0
def test_templateReplace():
    """docstring for test_templateReplace"""
    assert gnrstring.templateReplace('$foo loves $bar but she loves $aux and not $foo',
                                     {'foo': 'John', 'bar': 'Sandra',
                                      'aux': 'Steve'}) == 'John loves Sandra but she loves Steve and not John'
Пример #37
0
 def get_templated(field):
     value = datasource.get(field)
     
     if value:
         return templateReplace(value, datasource)
Пример #38
0
class MailHandler(GnrBaseService):
    """A class for mail management."""
    service_name = 'mail'
    
    def __init__(self, parent=None):
        self.parent = parent
        self.smtp_accounts = {}
        self.default_smtp_account = None
        self.pop_accounts = {}
        self.default_pop_account = None
        self.imap_accounts = {}
        self.default_imap_account = None
        
    def set_smtp_account(self, name, from_address=None, smtp_host=None, username=None,
                         password=None, port=None, ssl=False, default=False):
        """Set the smtp account
        
        :param name: the account's name
        :param from_address: the address that will appear in the recipients from field.
                             Default value is ``None``
        :param smtp_host: the smtp host to send this email. Default value is ``None``
        :param username: add???. Default value is ``None``
        :param password: the username's password (if a username is required for
                         authentication). Default value is ``None``
        :param port: if a non standard port is used then it can be overridden.
                     Default value is ``None``
        :param ssl: boolean. If ``True``, attempt to use the ssl port. Else standard smtp port is used.
                    Default value is ``None``
        :param default: boolean. add???. Default value is ``False``
        """
        self.smtp_accounts[name] = dict(from_address=from_address,
                                        smtp_host=smtp_host, username=username,
                                        password=password, port=port, ssl=ssl)
        if default:
            self.default_smtp_account = name
            
    def set_smtp_default_account(self, name):
        """Allow to use the saved account parameters for the subsequent SMTP mails
        
        :param name: the default account's name
        """
        self.default_smtp_account = name
        
    def set_pop_default_account(self, name):
        """Allow to use the saved account parameters for the subsequent POP mails
        
        :param name: the default account's name
        """
        self.default_pop_account = name
        
    def set_imap_default_account(self, name):
        """Allow to use the saved account parameters for the subsequent IMAP mails
        
        :param name: the default account's name
        """
        self.default_imap_account = name
        
    def get_account_params(self, account=None, from_address=None, smtp_host=None, port=None,
                           user=None, password=None, ssl=False, tls=False, **kwargs):
        """Set the account parameters
        
        :param account: if an account has been defined previously with :meth:`set_smtp_account`
                        then this account can be used instead of having to repeat all the mail
                        parameters contained. Default value is ``None``
        :param from_address: the address that will appear in the recipients from field.
                             Default value is ``None``
        :param smtp_host: the smtp host to send this email. Default value is ``None``
        :param port: if a non standard port is used then it can be overridden.
                     Default value is ``None``
        :param user: if a username is required for authentication.
                     Default value is ``None``
        :param password: the username's password (if a username is required for
                         authentication). Default value is ``None``
        :param ssl: boolean. If ``True``, attempt to use the ssl port. Else standard smtp port is used.
                    Default value is ``None``
        :param tls: boolean. Allow to communicate with an smtp server. Default value is ``False``.
                    You may choose three ways:
                    
                    1. no encryption
                    2. ssl -> all data is encrypted on a ssl layer
                    3. tls -> server and client begin communitation in a unsecure way and after a starttls command they start to encrypt data (this is the way you use to connect to gmail smtp)
        :returns: the account parameters
        """
        account = account or self.default_smtp_account
        if account:
            account_params = self.smtp_accounts[account]
        else:
            account_params = dict(smtp_host=smtp_host, port=port, user=user, password=password,
                                  ssl=ssl, tls=tls, from_address=from_address)
        return account_params
        
    def get_smtp_connection(self, account=None, smtp_host=None, port=None,
                            user=None, password=None, ssl=False, tls=False, **kwargs):
        """Get the smtp connection
        
        :param account: if an account has been defined previously with :meth:`set_smtp_account`
                        then this account can be used instead of having to repeat all the mail
                        parameters contained. Default value is ``None``
        :param smtp_host: the smtp host to send this email. Default value is ``None``
        :param port: if a non standard port is used then it can be overridden.
                     Default value is ``None``
        :param user: if a username is required for authentication.
                     Default value is ``None``
        :param password: the username's password (if a username is required for
                         authentication). Default value is ``None``
        :param ssl: boolean. If ``True``, attempt to use the ssl port. Else standard smtp port is used.
                    Default value is ``None``
        :param tls: allow to communicate with an smtp server. Default value is ``False``.
                    You may choose three ways:
                    
                    1. no encryption
                    2. ssl -> all data is encrypted on a ssl layer
                    3. tls -> server and client begin communitation in a unsecure way and after a starttls command they start to encrypt data (this is the way you use to connect to gmail smtp)
        :returns: the smtp connection
        """
        if ssl:
            smtp = getattr(smtplib, 'SMTP_SSL')
        else:
            smtp = getattr(smtplib, 'SMTP')
        if port:
            smtp_connection = smtp(host=str(smtp_host), port=str(port))
        else:
            smtp_connection = smtp(host=smtp_host)
        if tls:
            smtp_connection.starttls()
        if user:
            smtp_connection.login(user, password)
        return smtp_connection
        
    def handle_addresses(self, from_address=None, to_address=None, multiple_mode=None):
        """Handle the mail addresses
        
        :param from_address: the address that will appear in the recipients from field.
                             Default value is ``None``
        :param to_address: address where the email will be sent. Default value is ``None``
        :param multiple_mode: add???. Default value is ``None``
        :returns: lists of addresses
        """
        cc = bcc = None
        if isinstance(to_address, basestring):
            to_address = [address.strip() for address in to_address.replace(';', ',').split(',') if address]
        multiple_mode = (multiple_mode or '').lower().strip()
        if multiple_mode == 'to':
            to = [','.join(to_address)]
        elif multiple_mode == 'bcc': # jbe changed this from ccn to bcc
            to = [from_address]
            bcc = ','.join(to_address)
        elif multiple_mode == 'cc':
            to = [from_address]
            cc = ','.join(to_address)
        else:
            to = to_address
        return to, cc, bcc
        
    def build_base_message(self, subject, body, attachments=None, html=None, charset=None):
        """Add???
        
        :param subject: add???
        :param body: body of the email. If you pass ``html=True`` attribute,
                     then you can pass in the body the html tags
        :param attachments: path of the attachment to be sent with the email.
                            Default value is ``None``
        :param html: add???. Default value is ``None``
        :param charset: a different charser may be defined by its standard name.
                        Default value is ``None``.
        :returns: the message
        """
        charset = charset or 'us-ascii' # us-ascii is the email default, gnr default is utf-8.
                                        # This is used to prevent explicit "charset = None" to be passed
        attachments = attachments or []
        if not html and not attachments:
            msg = MIMEText(body, 'text', charset)
            msg['Subject'] = subject
            return msg
        if html:
            msg = MIMEMultipart('alternative')
        else:
            msg = MIMEMultipart()
        msg['Subject'] = subject
        for attachment_path in attachments:
            mime_type = mimetypes.guess_type(attachment_path)[0]
            mime_family, mime_subtype = mime_type.split('/')
            attachment_file = open(attachment_path, 'rb')
            email_attachment = mime_mapping[mime_family](attachment_file.read(), mime_subtype)
            msg.add_header('content-disposition', 'attachment', filename=os.path.basename(attachment_path))
            msg.attach(email_attachment)
            attachment_file.close()
        if html:
            msg.attach(MIMEText(clean_and_unescape(body), 'text', charset))
            msg.attach(MIMEText(body, 'html', charset))
        else:
            msg.attach(MIMEText(body, 'text', charset))
        return msg
        
    def sendmail_template(self, datasource, to_address=None, cc_address=None, bcc_address=None, subject=None,
                          from_address=None, body=None, attachments=None, account=None,
                          smtp_host=None, port=None, user=None, password=None,
                          ssl=False, tls=False, html=False, charset='utf-8', async=False, **kwargs):
        """Add???
        
        :param datasource: add???
        :param to_address: address where the email will be sent. Default value is ``None``
        :param cc_address: can be a comma deliminated str of email addresses or a list or tuple.
                           Default value is ``None``
        :param bcc_address: can be a comma deliminated str of email addresses or a list or tuple.
                            Default value is ``None``
        :param subject: add???. Default value is ``None``
        :param from_address: the address that will appear in the recipients from field.
                             Default value is ``None``
        :param body: body of the email. If you pass ``html=True`` attribute,
                     then you can pass in the body the html tags. Default value is ``None``
        :param attachments: path of the attachment to be sent with the email.
                            Default value is ``None``
        :param account: if an account has been defined previously with :meth:`set_smtp_account`
                        then this account can be used instead of having to repeat all the mail
                        parameters contained. Default value is ``None``
        :param smtp_host: the smtp host to send this email. Default value is ``None``
        :param port: if a non standard port is used then it can be overridden.
                     Default value is ``None``
        :param user: if a username is required for authentication.
                     Default value is ``None``
        :param password: the username's password (if a username is required for
                         authentication). Default value is ``None``
        :param ssl: boolean. If ``True``, attempt to use the ssl port. Else standard smtp port is used.
                    Default value is ``None``
        :param tls: allow to communicate with an smtp server. Default value is ``False``.
                    You may choose three ways:
                    
                    1. no encryption
                    2. ssl -> all data is encrypted on a ssl layer
                    3. tls -> server and client begin communitation in a unsecure way and after a starttls command they start to encrypt data (this is the way you use to connect to gmail smtp)
        
        :param html: boolean. If ``True``, html tags can be used in the body of the email. Appropriate headers are attached.
                     The default value is ``False``.
        :param charset: a different charser may be defined by its standard name.
                        Default value is ``utf-8``.
        :param async: boolean. If ``True``, then a separate process is spawned to send the email and control
                      is returned immediately to the calling function. The default value is ``False``.
        """
        
        def get_templated(field):
            value = datasource.get(field)
            
            if value:
                return templateReplace(value, datasource)
                
        to_address = to_address or get_templated('to_address')
        cc_address = cc_address or get_templated('cc_address')
        bcc_address = bcc_address or get_templated('bcc_address')
        from_address = from_address or get_templated('from_address')
        subject = subject or get_templated('subject')
        body = body or get_templated('body')
        body = templateReplace(body, datasource)
        self.sendmail(to_address, subject=subject, body=body, cc_address=cc_address, bcc_address=bcc_address,
                      attachments=attachments, account=account,
                      from_address=from_address, smtp_host=smtp_host, port=port, user=user, password=password,
                      ssl=ssl, tls=tls, html=html, charset=charset, async=async)
Пример #39
0
 def prepareRow(self, row):
     self.rowCell(value='%s::HTML' %
                  templateReplace(self.row_tpl, Bag(self.currRowDataNode)))
Пример #40
0
 def fillLetterheadSourceData(self,node,**kwargs):
     if node.label=='html':
         node.value = templateReplace(node.value,self.letterhead_sourcedata)
Пример #41
0
    def te_compileTemplate(self,
                           table=None,
                           datacontent=None,
                           varsbag=None,
                           parametersbag=None,
                           record_id=None,
                           templates=None,
                           template_id=None,
                           **kwargs):
        result = Bag()
        formats = dict()
        editcols = dict()
        masks = dict()
        df_templates = dict()
        dtypes = dict()
        columns = []
        virtual_columns = []
        varsdict = dict()
        if varsbag:
            tplvars = varsbag.digest(
                '#v.varname,#v.fieldpath,#v.virtual_column,#v.required_columns,#v.format,#v.mask,#v.editable,#v.df_template,#v.dtype,#v.fieldname'
            )
            for varname, fldpath, virtualcol, required_columns, format, mask, editable, df_template, dtype, fieldname in tplvars:
                varname = varname or fieldname
                fldpath = fldpath or varname
                fk = ''
                if format:
                    fk = varname
                    formats[varname] = format
                if mask:
                    fk = varname
                    masks[varname] = mask
                if editable:
                    fk = varname
                    editcols[varname] = editable
                if df_template:
                    fk = varname
                    df_templates[varname] = df_template
                if dtype:
                    dtypes[varname] = dtype
                if fk:
                    fk = '^%s' % fk
                if table:
                    varsdict[varname] = '$%s%s' % (fldpath, fk)

                columns.append((varsdict.get(varname)
                                or fldpath).replace('$@', '@'))
                if virtualcol:
                    virtual_columns.append(fldpath)
                if required_columns:
                    prefix = '.'.join(fldpath.split('.')[0:-1])
                    for c in required_columns.split(','):
                        if not c in virtual_columns:
                            virtual_columns.append(
                                '%s.%s' %
                                (prefix, c.replace('$', '')) if prefix else c)
        if parametersbag:
            tplpars = parametersbag.digest('#v.code,#v.format,#v.mask')
            for code, format, mask in tplpars:
                formats[code] = format
                masks[code] = mask
        template = templateReplace(datacontent,
                                   varsdict,
                                   True,
                                   False,
                                   conditionalMode=False)
        compiled = Bag()
        cmain = template
        if HT:
            doc = HT.parse(StringIO(template)).getroot()
            htmltables = doc.xpath('//table')
            for t in htmltables:
                attributes = t.attrib
                if 'row_datasource' in attributes:
                    subname = attributes['row_datasource']
                    tbody = t.xpath('tbody')[0]
                    tbody_lastrow = tbody.getchildren()[-1]
                    tbody.replace(
                        tbody_lastrow,
                        HT.etree.Comment('TEMPLATEROW:$%s' % subname))
                    subtemplate = HT.tostring(tbody_lastrow).replace(
                        '%s.' % subname, '').replace('%24', '$')
                    compiled.setItem(subname.replace('.', '_'), subtemplate)
            cmain = TEMPLATEROW.sub(lambda m: '\n%s\n' % m.group(1),
                                    HT.tostring(doc).replace('%24', '$'))
        compiled.setItem('main',
                         cmain,
                         maintable=table,
                         locale=self.locale,
                         virtual_columns=','.join(virtual_columns),
                         columns=','.join(columns),
                         formats=formats,
                         masks=masks,
                         editcols=editcols,
                         df_templates=df_templates,
                         dtypes=dtypes)
        result.setItem('compiled', compiled)
        if record_id:
            result.setItem(
                'preview',
                self.te_getPreview(compiled=compiled,
                                   record_id=record_id,
                                   templates=templates,
                                   template_id=template_id))
        return result
Пример #42
0
 def get_templated(field):
     value = datasource.getItem('_meta_.%s' % field)
     if not value:
         value = datasource.getItem(field)
     if value:
         return templateReplace(value, datasource)