anyblok_attachment.bloks.attachment.AttachmentBlok(registry)Bases: anyblok.blok.Blok
Add attachment in AnyBlok
author = 'Suzanne Jean-Sébastien'conditional_by = []conflicting_by = []import_declaration_module()Do the python import for the Declaration of the model or other
name = 'attachment'optional_by = []reload_declaration_module(reload)required = ['anyblok-core', 'anyblok-mixins']required_by = ['report']version = '1.0.0'The document historize the version:
doc = registry.Attachment.Document.insert(...)
assert doc.type == 'latest'
assert doc.previous_version is None
doc.data = {'other': 'data'}
assert doc.previous_version is not None
assert doc.previous_version.type == 'historized'
You can get:
All document:
registry.Attachment.Document.query().all()
Only the latest:
registry.Attachment.Document.Latest.query().all()
Only the historized:
registry.Attachment.Document.History.query().all()
Note
If one entry changed and a file is available then a historied version will be autmaticly created.
The historized version get the latest version of the document and a new version is added to the document
anyblok_attachment.bloks.attachment.attachment.AttachmentBases: object
Name space for the attachment models
AnyBlok registration:
anyblok_attachment.bloks.attachment.document.DocumentBases: object
AnyBlok registration:
| Fields | |
|---|---|
| version |
|
| previous_doc_uuid |
|
| hash |
|
| file_added_at |
|
| historied_at |
|
| previous_doc_version |
|
| uuid |
|
| type |
|
| filename |
|
| next_version |
|
| previous_versions |
|
| file |
|
| created_at |
|
| filesize |
|
| contenttype |
|
| previous_version |
|
| data |
|
anyblok_attachment.bloks.attachment.document.LatestBases: anyblok.model.Document, anyblok.mixin.ForbidDelete
AnyBlok registration:
anyblok.model.Documentanyblok.mixin.ForbidDeleteanyblok_attachment.bloks.attachment.document.HistoryBases: anyblok.model.Document, anyblok.mixin.ReadOnly
AnyBlok registration:
anyblok.model.Documentanyblok.mixin.ReadOnlyanyblok_attachment.bloks.attachment.mixin.LatestDocumentBases: object
AnyBlok registration:
| Fields | |
|---|---|
| latest_document_uuid |
|
| latest_document |
|
anyblok_attachment.bloks.attachment.mixin.VersionedDocumentBases: object
AnyBlok registration:
| Fields | |
|---|---|
| versioned_document_version |
|
| versioned_document_uuid |
|
| versioned_document |
|
anyblok_attachment.bloks.attachment.exceptions.NoFileExceptionDocument has not got file entry
anyblok_attachment.bloks.attachment.exceptions.ProtectedFieldExceptionTry to update protected field
anyblok_attachment.bloks.wkhtml2pdf.WkHtml2PdfBlok(registry)Bases: anyblok.blok.Blok
Add attachment in AnyBlok
author = 'Suzanne Jean-Sébastien'conditional_by = []conflicting_by = []import_declaration_module()Do the python import for the Declaration of the model or other
name = 'wkhtml2pdf'optional_by = []reload_declaration_module(reload)required = ['anyblok-core']required_by = []version = '1.0.0'Define tools to convert HTML to PDF with wkhtmltopdf.
To use WkHtml2Pdf in your template is easy:
@register(Model.Attachment.Template)
class MyTemplate(Mixin.WkHtml2Pdf):
... # template configuration
def render(self, data):
html_content = ...
return self.wkhtml2pdf(html_content)
You may define one or more configuration:
page_A4 = registry.Attachment.WkHtml2Pdf.Page.insert(
label="A4", size="A4")
page_postal_label = registry.Attachment.WkHtml2Pdf.Page.insert(
label="Postal carrier 1", height=80, width=120)
wkhtml2pdf = registry.Attachment.WkHtml2Pdf.insert(
label="A4", page=page_A4, margin_top=20)
template = registry.Attachment.Template.insert(
...,
wkhtml2pdf_configuration=wkhtml2pdf
)
doc = registry.Attachment.Document.insert(
template=template, data=...)
doc.get_file()
anyblok_attachment.bloks.wkhtml2pdf.model.WkHtml2PdfBases: object
AnyBlok registration:
| Fields | |
|---|---|
| label |
|
| margin_bottom |
|
| images |
|
| encoding |
|
| id |
|
| load_media_error_handling |
|
| background |
|
| javascript |
|
| created_at |
|
| load_error_handling |
|
| minimu_font_size |
|
| margin_left |
|
| collate |
|
| margin_right |
|
| copies |
|
| local_file_access |
|
| lowquality |
|
| dpi |
|
| javascript_delay |
|
| updated_at |
|
| page_offset |
|
| margin_top |
|
| page |
|
| grayscale |
|
| orientation |
|
cast_html2pdf(prefix, html_content)Cast html document to a pdf document
| Parameters: |
|
|---|---|
| Return type: | bytes |
| Exception: | WkHtml2PdfException |
anyblok_attachment.bloks.wkhtml2pdf.model.PageBases: object
Define the Page size
AnyBlok registration:
| Fields | |
|---|---|
| label |
|
| height |
|
| created_at |
|
| updated_at |
|
| size |
|
| width |
|
anyblok_attachment.bloks.wkhtml2pdf.mixin.WkHtml2PdfBases: object
AnyBlok registration:
| Fields | |
|---|---|
| wkhtml2pdf_configuration |
|
check_if_file_must_be_generated(document)Overwrite to check also if the configuration have changed
anyblok_attachment.bloks.wkhtml2pdf.exceptions.WkHtml2PdfExceptionOnly id the page configuration is wrong
anyblok_attachment.bloks.wkhtml2pdf.exceptions.PageValidityExceptionOnly id the page configuration is wrong
anyblok_attachment.bloks.report.ReportBlok(registry)Bases: anyblok.blok.Blok
Add attachment in AnyBlok
author = 'Suzanne Jean-Sébastien'conditional_by = []conflicting_by = []import_declaration_module()Do the python import for the Declaration of the model or other
name = 'report'optional_by = []reload_declaration_module(reload)required = ['attachment']required_by = ['report-format']version = '1.0.0'The main goal is to create document in function of template
Add a new template:
template = registry.Attachment.Template.insert(...)
Add a Document without file but with a Template:
document = registry.Attachment.Document.insert(template=template, ...)
document.generate_file()
Warning
the get_file method may re-create the document with historization if the data have been changed
Model.Attachment.Parser¶It is an unSQL model, the goal is to transform the data from Model.Attachment.Document to Json format to create the file:
@register(Model.Attachment.Parser)
class MyParser(Model.Attachment.Parser):
@classmethod
def serialize(cls, data):
# return serialize data
@classmethod
def check_if_file_must_be_generated(cls, template, document):
# return a Boolean to know if the file must be regenerate
Model.Attachment.Template¶The template describe how to generate the document file in function of of the data in the document.
The Model.Attachment.Template can be used directly an Template type class must be add with polymorphism:
@register(Model.Attachment)
class Template:
def get_template_type(self):
res = super(MyTemplateType, self).get_template_type()
res.update({'MyTemplateType': 'My type label'})
return res
@register(Model.Attachment.Template)
class MyTemplateType(Model.Attachment.Template):
TYPE = 'MyTypeOfTemplate'
uuid = UUID(primary_key=True, nullable=False, binary=False,
foreign_key=Model.Attachment.Template.use('uuid').options(ondelete='cascade'))
# other field need for the template
def render(self):
# generate a file
return file
or on the same table:
@register(Model.Attachment)
class Template:
def get_template_type(self):
res = super(MyTemplateType, self).get_template_type()
res.update({'MyTemplateType': 'My type label'})
return res
@register(Model.Attachment.Template,
tablename=Model.Attachment.Template)
class MyTemplateType(Model.Attachment.Template):
TYPE = 'MyTypeOfTemplate'
def render(self):
# generate a file
return file
anyblok_attachment.bloks.report.common.format_path(path)Return the absolute path in function of the blok
| Parameters: | path – the path to format |
|---|---|
| Returns: | the absolute path |
| Exception: | PathException |
anyblok_attachment.bloks.report.parser.Parser(model)Bases: object
Base parser to serialize the data for templating
AnyBlok registration:
check_if_file_must_be_generated(template, document)Return a boolean to know if the file must be generate or not
| Parameters: |
|
|---|---|
| Returns: | bool |
serialize(model, data)Serialize the data to be understanding by template
| Parameters: |
|
|---|---|
| Returns: | json dict |
anyblok_attachment.bloks.report.template.TemplateBases: object
Base Model template to define the main configuration between templating system
AnyBlok registration:
| Fields | |
|---|---|
| type |
|
| filename |
|
| parser_model |
|
| template_from |
|
| created_at |
|
| updated_at |
|
| parser_from |
|
| model |
|
| template_path |
|
| uuid |
|
check_if_file_must_be_generated(document)Return True if the file must generate
| Parameters: | document – attachment document instance |
|---|---|
| Return type: | bool |
create_file_for(document)Create a file and add it in the attachment document
| Parameters: | document – attachment document instance |
|---|
get_parser()return the template file to compute
get_parser_from()Give the location of the parser
get_template()return the template file to compute
get_template_from()Give the location of the template
get_template_type()Give the tempate type
render(data)Return the file create by the templating engine
| Parameters: | data – the serialized data |
|---|
update_document(document, file_, data)Update the document to fill file and content
| Parameters: |
|
|---|
anyblok_attachment.bloks.report.document.DocumentBases: object
AnyBlok registration:
| Fields | |
|---|---|
| template |
|
anyblok_attachment.bloks.report.document.LatestBases: object
AnyBlok registration:
anyblok_attachment.bloks.report.exceptions.TemplateExceptionSimple exception if miss Template data
anyblok_attachment.bloks.report.exceptions.PathExceptionSimple exception if it is not a valid path for Template
anyblok_attachment.bloks.report.exceptions.RenderExceptionSimple exception for all error in the render method
anyblok_attachment.bloks.format.ReportBlok(registry)Bases: anyblok.blok.Blok
Add attachment in AnyBlok
author = 'Suzanne Jean-Sébastien'conditional_by = []conflicting_by = []import_declaration_module()Do the python import for the Declaration of the model or other
name = 'report-format'optional_by = []reload_declaration_module(reload)required = ['report']required_by = []version = '1.0.0'Simple python templating formatage
template file exemple:
<!doctype html>
<html>
<head>
<title>{title}</title>
</head>
<body>
{description}
</body>
</html>
add the documment and create file:
template = registry.Attachment.Template.Format.insert(
template_path='path/of/the/python.template',
contenttype='text/html',
filename='mypage.html')
document = registry.Attachment.Document.insert(
template=template,
data={'title': 'My page', 'description': 'Hello world !!'}
)
document.get_file()
>>>:
{
'contenttype': 'text/html',
'file': b'<!doctype html>\n<html>\n <head>\n <title>My page</title>'
b'\n </head>\n <body>\n Hello world !!\n </body>\n<'
b'/html>\n',
'file_added_at': datetime.datetime(2018, 1, 4, 9, 22, 56, 922346, tzinfo=<DstTzInfo 'CET' CET+1:00:00 STD>),
'filename': 'mypage.html',
'filesize': 131,
'hash': b'\xf0\xe2?\xebk\xb4\x15\x0f\xb2\x9cT\x08\xee#\x02\xe2\xbe\xa16\x8d'
b'\xc8\xcda\x91;\xba2\x9c\x9dUF\x10'}
}
anyblok_attachment.bloks.format.template.TemplateBases: object
AnyBlok registration:
anyblok_attachment.bloks.format.template.FormatBases: anyblok.model.Template
Simple python format templating
AnyBlok registration:
anyblok.model.Template| Fields | |
|---|---|
| contenttype |
|
| uuid |
|