def colwidth(self, width):
if width not in self._widthstyles:
w = Style(name="W{}".format(width), family="table-column")
w.addElement(TableColumnProperties(columnwidth=width))
self.doc.automaticstyles.addElement(w)
self._widthstyles[width] = w
return self._widthstyles[width]
def generate_ods(data):
"""
Generate a ODS file.
:param data: list-like of dict with the data.
:return:
"""
doc = OpenDocumentSpreadsheet()
table = Table()
tr = TableRow()
colautowidth = Style(name="co1", family="table-column")
colautowidth.addElement(TableColumnProperties(useoptimalcolumnwidth=True))
doc.automaticstyles.addElement(colautowidth)
for column in data[0].keys():
table.addElement(TableColumn(stylename=colautowidth))
tc = TableCell(valuetype="string", value=column)
tc.addElement(P(text=column))
tr.addElement(tc)
table.addElement(tr)
for row in data:
tr = TableRow()
for column in row.keys():
tc = TableCell(valuetype="string", value=row[column])
tc.addElement(P(text=row[column]))
tr.addElement(tc)
table.addElement(tr)
file = os.path.join(
tempfile.gettempdir(),
'SIGE' + datetime.now().strftime('%Y%m%d%H%M%S%f') + '.ods')
doc.spreadsheet.addElement(table)
print(doc.automaticstyles.childNodes[0].attributes)
doc.save(file)
return file
def create_blank_ods_with_styles():
"""Create a dmutils.ods.SpreadSheet pre-configured with some default styles, ready for population with data
appropriate for the subclass View. Modifications here (except adding styles) are likely breaking changes."""
spreadsheet = ods.SpreadSheet()
# Add the font we will use for the entire spreadsheet.
spreadsheet.add_font(FontFace(name="Arial", fontfamily="Arial"))
# Add some default styles for columns.
spreadsheet.add_style("col-default", "table-column", (
TableColumnProperties(breakbefore="auto"),
), parentstylename="Default")
spreadsheet.add_style("col-wide", "table-column", (
TableColumnProperties(columnwidth="150pt", breakbefore="auto"),
), parentstylename="Default")
spreadsheet.add_style("col-extra-wide", "table-column", (
TableColumnProperties(columnwidth="300pt", breakbefore="auto"),
), parentstylename="Default")
# Add some default styles for rows.
spreadsheet.add_style("row-default", "table-row", (
TableRowProperties(breakbefore="auto", useoptimalrowheight="false"),
), parentstylename="Default")
spreadsheet.add_style("row-tall", "table-row", (
TableRowProperties(breakbefore="auto", rowheight="30pt", useoptimalrowheight="false"),
), parentstylename="Default")
spreadsheet.add_style("row-tall-optimal", "table-row", (
TableRowProperties(breakbefore="auto", rowheight="30pt", useoptimalrowheight="true"),
), parentstylename="Default")
# Add some default styles for cells.
spreadsheet.add_style("cell-default", "table-cell", (
TableCellProperties(wrapoption="wrap", verticalalign="top"),
TextProperties(fontfamily="Arial", fontnameasian="Arial", fontnamecomplex="Arial", fontsize="11pt"),
), parentstylename="Default")
spreadsheet.add_style("cell-header", "table-cell", (
TableCellProperties(wrapoption="wrap", verticalalign="top"),
TextProperties(fontfamily="Arial", fontnameasian="Arial", fontnamecomplex="Arial", fontsize="11pt",
fontweight="bold"),
), parentstylename="Default")
return spreadsheet
def init(LOdoc, numfonts=1):
totalwid = 6800 #6.8inches
#compute column widths
f = min(numfonts,4)
ashare = 4*(6-f)
dshare = 2*(6-f)
bshare = 100 - 2*ashare - dshare
awid = totalwid * ashare // 100
dwid = totalwid * dshare // 100
bwid = totalwid * bshare // (numfonts * 100)
# create styles for table, for columns (one style for each column width)
# and for one cell (used for everywhere except where background changed)
tstyle = Style(name="Table1", family="table")
tstyle.addElement(TableProperties(attributes={'width':str(totalwid/1000.)+"in", 'align':"left"}))
LOdoc.automaticstyles.addElement(tstyle)
tastyle = Style(name="Table1.A", family="table-column")
tastyle.addElement(TableColumnProperties(attributes={'columnwidth':str(awid/1000.)+"in"}))
LOdoc.automaticstyles.addElement(tastyle)
tbstyle = Style(name="Table1.B", family="table-column")
tbstyle.addElement(TableColumnProperties(attributes={'columnwidth':str(bwid/1000.)+"in"}))
LOdoc.automaticstyles.addElement(tbstyle)
tdstyle = Style(name="Table1.D", family="table-column")
tdstyle.addElement(TableColumnProperties(attributes={'columnwidth':str(dwid/1000.)+"in"}))
LOdoc.automaticstyles.addElement(tdstyle)
ta1style = Style(name="Table1.A1", family="table-cell")
ta1style.addElement(TableCellProperties(attributes={'padding':"0.035in", 'border':"0.05pt solid #000000"}))
LOdoc.automaticstyles.addElement(ta1style)
# text style used with non-<em> text
t1style = Style(name="T1", family="text")
t1style.addElement(TextProperties(attributes={'color':"#999999" }))
LOdoc.automaticstyles.addElement(t1style)
# create styles for Title, Subtitle
tstyle = Style(name="Title", family="paragraph")
tstyle.addElement(TextProperties(attributes={'fontfamily':"Arial",'fontsize':"24pt",'fontweight':"bold" }))
LOdoc.styles.addElement(tstyle)
ststyle = Style(name="Subtitle", family="paragraph")
ststyle.addElement(TextProperties(attributes={'fontfamily':"Arial",'fontsize':"18pt",'fontweight':"bold" }))
LOdoc.styles.addElement(ststyle)
def __init__(self):
self.doc = OpenDocumentSpreadsheet()
#styles
self.itemRowStyle1 = Style(name="itemRowStyle", family="table-row")
self.itemRowStyle1.addElement(TableRowProperties(rowheight="7mm"))
self.doc.automaticstyles.addElement(self.itemRowStyle1)
self.itemRowStyle3 = Style(name="itemRowStyle", family="table-row")
self.itemRowStyle3.addElement(TableRowProperties(rowheight="30mm"))
self.doc.automaticstyles.addElement(self.itemRowStyle3)
self.colStyle30 = Style(name="colStyle30", family="table-column")
self.colStyle30.addElement(TableColumnProperties(columnwidth="25mm"))
self.doc.automaticstyles.addElement(self.colStyle30)
self.colStyle40 = Style(name="colStyle40", family="table-column")
self.colStyle40.addElement(TableColumnProperties(columnwidth="40mm"))
self.doc.automaticstyles.addElement(self.colStyle40)
self.colStyle50 = Style(name="colStyle50", family="table-column")
self.colStyle50.addElement(TableColumnProperties(columnwidth="50mm"))
self.doc.automaticstyles.addElement(self.colStyle50)
self.colStyle200 = Style(name="colStyle200", family="table-column")
self.colStyle200.addElement(TableColumnProperties(columnwidth="200mm"))
self.doc.automaticstyles.addElement(self.colStyle200)
self.cellStyle1 = Style(name="cellStyle1",family="table-cell", parentstylename='Standard', displayname="middle")
self.cellStyle1.addElement(ParagraphProperties(textalign="center"))
self.cellStyle1.addElement(TableCellProperties(verticalalign="middle"))
self.cellStyle1.addElement(TableCellProperties(wrapoption="wrap"))
self.doc.automaticstyles.addElement(self.cellStyle1)
self.hdrStyle = Style(name="hdrStyle",family="table-cell", parentstylename='Standard', displayname="middle")
self.hdrStyle.addElement(ParagraphProperties(textalign="center"))
self.hdrStyle.addElement(TextProperties(fontweight="bold"))
self.hdrStyle.addElement(TableCellProperties(verticalalign="middle"))
self.doc.automaticstyles.addElement(self.hdrStyle)
def inittable(textdoc):
# Create a style for the table content. One we can modify
# later in the word processor.
tablecontents = Style(name="Table Contents", family="paragraph")
tablecontents.addElement(
ParagraphProperties(numberlines="false", linenumber="0"))
tablecontents.addElement(TextProperties(fontweight="bold"))
textdoc.styles.addElement(tablecontents)
widewidth = Style(name="co1", family="table-column")
widewidth.addElement(
TableColumnProperties(columnwidth="9", breakbefore="auto"))
textdoc.automaticstyles.addElement(widewidth)
textdoc.styles.addElement(widewidth)
table = Table(name='test')
table.addElement(
TableColumn(stylename=widewidth, defaultcellstylename="ce1"))
return table, tablecontents, textdoc
PWENC = "utf-8"
textdoc = OpenDocumentText()
# Create a style for the table content. One we can modify
# later in the word processor.
tablecontents = Style(name="Table Contents", family="paragraph")
tablecontents.addElement(
ParagraphProperties(numberlines="false", linenumber="0"))
textdoc.styles.addElement(tablecontents)
# Create automatic styles for the column widths.
# We want two different widths, one in inches, the other one in metric.
# ODF Standard section 15.9.1
widthshort = Style(name="Wshort", family="table-column")
widthshort.addElement(TableColumnProperties(columnwidth="1.7cm"))
textdoc.automaticstyles.addElement(widthshort)
widthwide = Style(name="Wwide", family="table-column")
widthwide.addElement(TableColumnProperties(columnwidth="1.5in"))
textdoc.automaticstyles.addElement(widthwide)
# Start the table, and describe the columns
table = Table()
table.addElement(TableColumn(numbercolumnsrepeated=4, stylename=widthshort))
table.addElement(TableColumn(numbercolumnsrepeated=3, stylename=widthwide))
f = open('/etc/passwd')
for line in f:
rec = line.strip().split(":")
tr = TableRow()
def insert_table_(self, ar, column_names=None, table_width=180):
# logger.info("20160330 insert_table(%s)", ar)
ar.setup_from(self.ar)
columns, headers, widths = ar.get_field_info(column_names)
widths = map(int, widths)
tw = sum(widths)
# specifying relative widths doesn't seem to work (and that's
# a pity because absolute widths requires us to know the
# table_width).
use_relative_widths = False
if use_relative_widths:
width_specs = ["%d*" % (w * 100 / tw) for w in widths]
else:
width_specs = ["%dmm" % (table_width * w / tw) for w in widths]
doc = OpenDocumentText()
def add_style(**kw):
st = Style(**cleankw(kw))
doc.styles.addElement(st)
self.my_styles.append(st)
return st
table_style_name = str(ar.actor)
st = add_style(name=table_style_name, family="table",
parentstylename="Default")
st.addElement(
TableProperties(align="margins", maybreakbetweenrows="0"))
# create some *visible* styles
st = add_style(name="Table Contents", family="paragraph",
parentstylename="Default")
st.addElement(ParagraphProperties(numberlines="false",
linenumber="0"))
st = add_style(name="Number Cell", family="paragraph",
parentstylename="Table Contents")
st.addElement(ParagraphProperties(
numberlines="false",
textalign="end", justifysingleword="true",
linenumber="0"))
dn = "Table Column Header"
st = self.stylesManager.styles.getStyle(dn)
if st is None:
st = add_style(name=dn, family="paragraph",
parentstylename="Table Contents")
st.addElement(
ParagraphProperties(numberlines="false", linenumber="0"))
st.addElement(TextProperties(fontweight="bold"))
dn = "Bold Text"
st = self.stylesManager.styles.getStyle(dn)
if st is None:
st = add_style(name=dn, family="text", parentstylename="Default")
#~ st = add_style(name=dn, family="text")
st.addElement(TextProperties(fontweight="bold"))
if False:
dn = "L1"
st = self.stylesManager.styles.getStyle(dn)
if st is None:
st = ListStyle(name=dn)
doc.styles.addElement(st)
p = ListLevelProperties(
listlevelpositionandspacemode="label-alignment")
st.addElement(p)
#~ label-followed-by="listtab" text:list-tab-stop-position="1.27cm" fo:text-indent="-0.635cm" fo:margin-left="1.27cm"/>
p.addElement(ListLevelLabelAlignment(labelfollowedby="listtab",
listtabstopposition="1.27cm",
textindent="-0.635cm",
marginleft="1.27cm"
))
self.my_styles.append(st)
#~ list_style = add_style(name=dn, family="list")
bullet = text.ListLevelStyleBullet(
level=1, stylename="Bullet_20_Symbols", bulletchar=u"•")
#~ bullet = text.ListLevelStyleBullet(level=1,stylename="Bullet_20_Symbols",bulletchar=u"*")
#~ <text:list-level-style-bullet text:level="1" text:style-name="Bullet_20_Symbols" text:bullet-char="•">
st.addElement(bullet)
# create some automatic styles
def add_style(**kw):
st = Style(**cleankw(kw))
doc.automaticstyles.addElement(st)
self.my_automaticstyles.append(st)
return st
cell_style = add_style(name="Lino Cell Style", family="table-cell")
cell_style.addElement(TableCellProperties(
paddingleft="1mm", paddingright="1mm",
paddingtop="1mm", paddingbottom="0.5mm",
border="0.002cm solid #000000"))
header_row_style = add_style(
name="Lino Header Row", family="table-row",
parentstylename=cell_style)
header_row_style.addElement(
TableRowProperties(backgroundcolor="#eeeeee"))
total_row_style = add_style(
name="Lino Total Row", family="table-row",
parentstylename=cell_style)
total_row_style.addElement(
TableRowProperties(backgroundcolor="#ffffff"))
table = Table(name=table_style_name, stylename=table_style_name)
table_columns = TableColumns()
table.addElement(table_columns)
table_header_rows = TableHeaderRows()
table.addElement(table_header_rows)
table_rows = TableRows()
table.addElement(table_rows)
# create table columns and automatic table-column styles
for i, fld in enumerate(columns):
#~ print 20120415, repr(fld.name)
name = str(ar.actor) + "." + str(fld.name)
cs = add_style(name=name, family="table-column")
if use_relative_widths:
cs.addElement(
TableColumnProperties(relcolumnwidth=width_specs[i]))
else:
cs.addElement(
TableColumnProperties(columnwidth=width_specs[i]))
#~ cs.addElement(TableColumnProperties(useoptimalcolumnwidth='true'))
#~ k = cs.getAttribute('name')
#~ renderer.stylesManager.styles[k] = toxml(e)
#~ doc.automaticstyles.addElement(cs)
#~ self.my_automaticstyles.append(cs)
table_columns.addElement(TableColumn(stylename=name))
def fldstyle(fld):
#~ if isinstance(fld,ext_store.VirtStoreField):
#~ fld = fld.delegate
if isinstance(fld, NumberFieldElement):
return "Number Cell"
return "Table Contents"
def value2cell(ar, i, fld, val, style_name, tc):
# if i == 0:
# logger.info("20160330a value2cell(%s, %s)", fld.__class__, val)
txt = fld.value2html(ar, val)
# if i == 0:
# logger.info("20160330b value2cell(%s)", E.tostring(txt))
p = text.P(stylename=style_name)
html2odf(txt, p)
try:
tc.addElement(p)
except Exception as e:
dd.logger.warning("20120614 addElement %s %s %r : %s",
i, fld, val, e)
#~ print 20120614, i, fld, val, e
#~ yield P(stylename=tablecontents,text=text)
# create header row
#~ hr = TableRow(stylename=HEADER_ROW_STYLE_NAME)
hr = TableRow(stylename=header_row_style)
table_header_rows.addElement(hr)
for h in headers:
#~ for fld in fields:
#~ tc = TableCell(stylename=CELL_STYLE_NAME)
tc = TableCell(stylename=cell_style)
tc.addElement(text.P(
stylename="Table Column Header",
#~ text=force_text(fld.field.verbose_name or fld.name)))
text=force_text(h)))
hr.addElement(tc)
sums = [fld.zero for fld in columns]
for row in ar.data_iterator:
#~ for grp in ar.group_headers(row):
#~ raise NotImplementedError()
tr = TableRow()
has_numeric_value = False
for i, fld in enumerate(columns):
#~ tc = TableCell(stylename=CELL_STYLE_NAME)
tc = TableCell(stylename=cell_style)
#~ if fld.field is not None:
v = fld.field._lino_atomizer.full_value_from_object(row, ar)
stylename = fldstyle(fld)
if v is None:
tc.addElement(text.P(stylename=stylename, text=''))
else:
value2cell(ar, i, fld, v, stylename, tc)
nv = fld.value2num(v)
if nv != 0:
sums[i] += nv
has_numeric_value = True
#~ sums[i] += fld.value2num(v)
tr.addElement(tc)
if has_numeric_value or not ar.actor.hide_zero_rows:
table_rows.addElement(tr)
if not ar.actor.hide_sums:
if sums != [fld.zero for fld in columns]:
tr = TableRow(stylename=total_row_style)
table_rows.addElement(tr)
sums = {fld.name: sums[i] for i, fld in enumerate(columns)}
for i, fld in enumerate(columns):
tc = TableCell(stylename=cell_style)
stylename = fldstyle(fld)
p = text.P(stylename=stylename)
e = fld.format_sum(ar, sums, i)
html2odf(e, p)
tc.addElement(p)
#~ if len(txt) != 0:
#~ msg = "html2odf() returned "
#~ logger.warning(msg)
#~ txt = tuple(html2odf(fld.format_sum(ar,sums,i),p))
#~ assert len(txt) == 1
#~ tc.addElement(text.P(stylename=stylename,text=txt[0]))
tr.addElement(tc)
doc.text.addElement(table)
return toxml(table)
def create_doc_with_styles():
textdoc = OpenDocumentSpreadsheet()
# Create automatic styles for the column widths.
# ODF Standard section 15.9.1
nameColStyle = Style(name="nameColStyle", family="table-column")
nameColStyle.addElement(TableColumnProperties(columnwidth="8cm"))
textdoc.automaticstyles.addElement(nameColStyle)
tagColStyle = Style(name="tagColStyle", family="table-column")
tagColStyle.addElement(TableColumnProperties(columnwidth="5cm"))
tagColStyle.addElement(ParagraphProperties(textalign="left")) #??
textdoc.automaticstyles.addElement(tagColStyle)
rankColStyle = Style(name="rankColStyle", family="table-column")
rankColStyle.addElement(TableColumnProperties(columnwidth="1.5cm"))
rankColStyle.addElement(ParagraphProperties(textalign="center")) #??
textdoc.automaticstyles.addElement(rankColStyle)
valColStyle = Style(name="valColStyle", family="table-column")
valColStyle.addElement(TableColumnProperties(columnwidth="0.9cm"))
valColStyle.addElement(ParagraphProperties(textalign="center")) #??
textdoc.automaticstyles.addElement(valColStyle)
linkColStyle = Style(name="linkColStyle", family="table-column")
linkColStyle.addElement(TableColumnProperties(columnwidth="0.3cm"))
linkColStyle.addElement(ParagraphProperties(textalign="center")) #??
textdoc.automaticstyles.addElement(linkColStyle)
# Create a style for the table content. One we can modify
# later in the word processor.
tablecontents = Style(name="tablecontents", family="paragraph")
tablecontents.addElement(
ParagraphProperties(numberlines="false", linenumber="0"))
tablecontents.addElement(TextProperties(fontweight="bold"))
textdoc.styles.addElement(tablecontents)
TH = Style(name="THstyle",
family="table-cell",
parentstylename='Standard',
displayname="Table Header")
TH.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(TH)
C0 = Style(name="C0style",
family="table-cell",
parentstylename='Standard',
displayname="Color style 0")
C0.addElement(TableCellProperties(backgroundcolor="#00FF00"))
C0.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(C0)
Csep = Style(name="Csepstyle",
family="table-cell",
parentstylename='Standard',
displayname="Color style Sep ")
Csep.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(Csep)
C1 = Style(name="C1style",
family="table-cell",
parentstylename='Standard',
displayname="Color style 1")
C1.addElement(TableCellProperties(backgroundcolor="#00FF00"))
C1.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(C1)
C2 = Style(name="C2style",
family="table-cell",
parentstylename='Standard',
displayname="Color style 2")
C2.addElement(TableCellProperties(backgroundcolor="#FFFF00"))
C2.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(C2)
C3 = Style(name="C3style",
family="table-cell",
parentstylename='Standard',
displayname="Color style 3")
C3.addElement(TableCellProperties(backgroundcolor="#FFAA00"))
C3.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(C3)
C4 = Style(name="C4style",
family="table-cell",
parentstylename='Standard',
displayname="Color style 4")
C4.addElement(TableCellProperties(backgroundcolor="#FF0000"))
C4.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(C4)
C5 = Style(name="C5style",
family="table-cell",
parentstylename='Standard',
displayname="Color style 5")
C5.addElement(TableCellProperties(backgroundcolor="#FF0000"))
C5.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(C5)
CB = Style(name="CBstyle",
family="table-cell",
parentstylename='Standard',
displayname="Color style blue")
CB.addElement(TableCellProperties(backgroundcolor="#8888DD"))
CB.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(CB)
rankCellStyle = Style(name="rankCellStyle",
family="table-cell",
parentstylename='Standard',
displayname="rankCellStyle")
rankCellStyle.addElement(ParagraphProperties(textalign="center"))
textdoc.styles.addElement(rankCellStyle)
return textdoc
def generate_odf_plan_document(plan_pk, file_path):
# Neues Textdokument erstellen
document = OpenDocumentText()
#
# Styles definieren
#
center_bold = Style(name="Center Bold", family="paragraph")
center_bold.addElement(ParagraphProperties(textalign="center"))
center_bold.addElement(TextProperties(fontweight="bold"))
document.styles.addElement(center_bold)
center = Style(name="Center", family="paragraph")
center.addElement(ParagraphProperties(textalign="center"))
document.styles.addElement(center)
left = Style(name="Left", family="paragraph")
left.addElement(ParagraphProperties(numberlines="false", linenumber="0", textalign="left"))
document.styles.addElement(left)
bold_style = Style(name="Bold", family="text")
bold_style.addElement(TextProperties(fontweight="bold"))
document.styles.addElement(bold_style)
#
# Breite der Spaleten in den Tabellen setzen
#
width_short = Style(name="Wshort", family="table-column")
width_short.addElement(TableColumnProperties(columnwidth="3.0cm"))
document.automaticstyles.addElement(width_short)
width_medium = Style(name="Wmedium", family="table-column")
width_medium.addElement(TableColumnProperties(columnwidth="4.0cm"))
document.automaticstyles.addElement(width_medium)
width_wide = Style(name="Wwide", family="table-column")
width_wide.addElement(TableColumnProperties(columnwidth="10.59cm"))
document.automaticstyles.addElement(width_wide)
# Tabelle mit zwei schmalen und einer breiten Spalte erstellen
table = Table()
table.addElement(TableColumn(numbercolumnsrepeated=1, stylename=width_short))
table.addElement(TableColumn(numbercolumnsrepeated=1, stylename=width_medium))
table.addElement(TableColumn(numbercolumnsrepeated=1, stylename=width_wide))
# Generiert eine Zeile in der Tabelle
def generate_row(datetime, location, extra, acolytes):
# Datum und Uhrzeit formatieren
date_string = datetime.strftime("%d.%m.%Y")
time_string = datetime.strftime("%H:%M")
# Neue TableRow erstellen und einfügen
row = TableRow()
table.addElement(row)
# Datum - Zeit Zelle anlegen
date_time_cell = TableCell()
date_time_cell.addElement(P(stylename=center, text=date_string))
date_time_cell.addElement(P(stylename=center_bold, text=time_string))
# Ort - Information Zelle anlegen
location_extra_cell = TableCell()
location_extra_cell.addElement(P(stylename=center_bold, text=location))
location_extra_cell.addElement(P(stylename=center, text=extra))
# Messdiener Zelle anlegen
acolytes_cell = TableCell()
# Messdiener nach Rolle sortiert auflisten
for role_name in acolytes:
p = P(stylename=left)
p.addElement(Span(stylename=bold_style, text=f"{role_name}: "))
p.addText(text=', '.join(acolytes[role_name]))
acolytes_cell.addElement(p)
# Zellen zur TableRow hinzufügen
row.addElement(date_time_cell)
row.addElement(location_extra_cell)
row.addElement(acolytes_cell)
# TableRow zurückgeben
return row
# Durch die Messen nach Zeit sortiert iterieren
for mass in Mass.objects.filter(plan=plan_pk).order_by('time'):
# Acolyte dict mit einer leeren Liste als default value anlegen
acolytes_list = defaultdict(list)
# Durch die MassAcolyteRoles nach Rolle sortiert iterieren
for mar in mass.massacolyterole_set.order_by('role__roleName'):
# Wenn Messdiener keine Rolle hat "Messdiener" als Rolle eintragen
role = "Messdiener"
# Wenn Messdiener Rolle hat, dann zur Liste der Messdiener dieser Rolle hinzufügen
if mar.role is not None:
role = mar.role.roleName
# Acolyte Namen setzen. Wenn extra Wert hat, dann in Klammern dahinter setzen
acolyte_name = f"{mar.acolyte.firstName} {mar.acolyte.lastName}"
if mar.acolyte.extra:
acolyte_name = f"{mar.acolyte.firstName} {mar.acolyte.lastName} ({mar.acolyte.extra})"
acolytes_list[role].append(acolyte_name)
# Zeit der Messe zur lokalen Zeit konvertieren
utc = mass.time.replace(tzinfo=pytz.UTC)
localtime = utc.astimezone(timezone.get_current_timezone())
# Row generieren und zur Tabelle hinzufügen
table.addElement(generate_row(
localtime,
mass.location.locationName,
mass.extra,
acolytes_list
))
# Leere Row für die Übersicht einfügen
table.addElement(TableRow())
# Tabelle zum Dokument hinzufügen
document.text.addElement(table)
# Dokument speichern
document.save(file_path)
def save(self, filename, i_max = None, j_max = None): ''' save table in ods format ''' if not i_max: i_max = self.table.i_max if not j_max: j_max = self.table.j_max # update cells text self.table.updateTable(i_max, j_max) # create new odf spreadsheet odfdoc = OpenDocumentSpreadsheet() # set direction style rtl = Style(name = "dir", family = "table") if self.table.direction == 'rtl': rtl.addElement(TableProperties(writingmode="rl-tb")) odfdoc.automaticstyles.addElement(rtl) # create the table table = Table(name = "sheet 1", stylename = 'dir') # default style ts = Style(name = "ts", family = "table-cell") ts.addElement(TextProperties(fontfamily = SodsCell().font_family, fontsize = SodsCell().font_size)) odfdoc.styles.addElement(ts) # create columns for j in range(1, j_max): colname = "col" + str(j) c = self.table.getCellAt(0, j) width = c.column_width cs = Style(name = colname, family = "table-column") cs.addElement(TableColumnProperties(columnwidth = width, breakbefore = "auto")) odfdoc.automaticstyles.addElement(cs) table.addElement(TableColumn(stylename = colname, defaultcellstylename = "ts")) # make sure values are up to date # loop and update the cells value for i in range(1, i_max): # create new ods row tr = TableRow() table.addElement(tr) # create default data styles for dates and numbers ncs = NumberStyle(name="ncs") ncs.addElement(Number(decimalplaces="2", minintegerdigits="1", grouping="true")) odfdoc.styles.addElement(ncs) ncs2 = NumberStyle(name="ncs2") ncs2.addElement(Number(decimalplaces="0", minintegerdigits="1", grouping="false")) odfdoc.styles.addElement(ncs2) dcs = DateStyle(name="dcs") dcs.addElement(Year(style='long')) dcs.addElement(Text(text = '-')) dcs.addElement(Month(style='long')) dcs.addElement(Text(text = '-')) dcs.addElement(Day(style='long')) odfdoc.styles.addElement(dcs) for j in range(1, j_max): # update the cell text and condition cell = self.table.encodeColName(j) + str(i) c = self.table.getCellAt(i, j) # chose datastylename if c.value_type == 'date': datastylename = "dcs" else: if c.format == "": datastylename = "ncs2" if c.format == "#,##0.00": datastylename = "ncs" # get cell style id if (c.condition): style_id = (datastylename + c.color + c.font_size + c.font_family + c.background_color + c.border_top + c.border_bottom + c.border_left + c.border_right + c.condition_color + c.condition_background_color) else: style_id = (datastylename + c.color + c.font_size + c.font_family + c.background_color + c.border_top + c.border_bottom + c.border_left + c.border_right) # set ods style style_name = self.getStyle(c, cell, datastylename, style_id, odfdoc) # create new ods cell if (c.formula and c.formula[0] == '=' and c.formula[:4] != '=uni'): if self.table.isFloat(c.value): tc = TableCell(valuetype = c.value_type, formula = c.formula, value = float(c.value), stylename = style_name) else: tc = TableCell(valuetype = c.value_type, formula = c.formula, value = 0, stylename = style_name) elif (c.value_type == 'date'): tc = TableCell(valuetype = c.value_type, datevalue = c.date_value, stylename = style_name) elif (c.value_type == 'float') and self.table.isFloat(c.value): tc = TableCell(valuetype = c.value_type, value = float(c.value), stylename = style_name) else: tc = TableCell(valuetype = 'string', stylename = style_name) # set ods text tc.addElement(P(text = str(escape(c.text), 'utf-8'))) tr.addElement(tc) odfdoc.spreadsheet.addElement(table) odfdoc.save(filename)
tr.addElement(tc)
tc.addElement(text.P(text=input_text,stylename=style))
textdoc = load("my_template.odt")
header1 = textdoc.getStyleByName('主標題')
header2 = textdoc.getStyleByName('子標題')
normal_style = textdoc.getStyleByName('本文')
bold_style = textdoc.getStyleByName('強調')
center = textdoc.getStyleByName('置中本文')
centerbold = textdoc.getStyleByName('置中粗體')
center_huge = textdoc.getStyleByName('置中加大')
ver_center = textdoc.getStyleByName('垂直置中')
tbc2 = Style(name="tbc2", family="table-column", parentstylename=normal_style)
tbc2.addElement(TableColumnProperties(columnwidth="2cm"))
textdoc.automaticstyles.addElement(tbc2)
tbc5 = Style(name="tbc5", family="table-column", parentstylename=normal_style)
tbc5.addElement(TableColumnProperties(columnwidth="5cm"))
textdoc.automaticstyles.addElement(tbc5)
mmTable = Table()
mmTable.addElement(TableColumn(defaultcellstylename=ver_center,numbercolumnsrepeated=1,stylename=tbc2))
mmTable.addElement(TableColumn(defaultcellstylename=ver_center,numbercolumnsrepeated=1,stylename=tbc5))
mmTable.addElement(TableColumn(defaultcellstylename=ver_center,numbercolumnsrepeated=1,stylename=tbc2))
mmTable.addElement(TableColumn(defaultcellstylename=ver_center,numbercolumnsrepeated=1,stylename=tbc5))
tr = TableRow()
mmTable.addElement(tr)
put_tc("會議時間",center,tr)
put_tc('2020/4/28',ver_center,tr,3)
tr = TableRow()
''' output = OpenDocumentSpreadsheet() middle_center = Style(name="middle_center", family="table-cell") middle_center.addElement(TableCellProperties(verticalalign="middle")) middle_center.addElement(ParagraphProperties(textalign="center")) output.styles.addElement(middle_center) middle_left = Style(name="middle_left", family="table-cell") middle_left.addElement(TableCellProperties(verticalalign="middle")) middle_left.addElement(ParagraphProperties(textalign="left")) output.styles.addElement(middle_left) date_style = Style(name="date", family="table-column") date_style.addElement(TableColumnProperties(columnwidth="5cm")) output.automaticstyles.addElement(date_style) time_style = Style(name="time", family="table-column") time_style.addElement(TableColumnProperties(columnwidth="1.5cm")) output.automaticstyles.addElement(time_style) examinee_style = Style(name="examinee", family="table-column") examinee_style.addElement(TableColumnProperties(columnwidth="7cm")) output.automaticstyles.addElement(examinee_style) examiner_style = Style(name="examiner", family="table-column") examiner_style.addElement(TableColumnProperties(columnwidth="4cm")) output.automaticstyles.addElement(examiner_style) table = Table()
def save(telephoneDir,
subdivision=0,
collaborator=None,
number=None,
telephoneType=None):
collaborators = list(sorted(telephoneDir.subdivision))
subdivisions = list(sorted(telephoneDir.subdivision.iterSubdivision()))
telephoneTypes = list(sorted(telephoneDir.telephones.telephoneTypes))
s = subdivisions[subdivision]
lambdaSubdivision = lambda rec: rec.collaborator in s
if not collaborator:
lambdaCollaborator = lambda rec: True
else:
l = len(collaborator)
lambdaCollaborator = lambda rec: str(rec.collaborator)[
0:l] == collaborator
if not number:
lambdaNumber = lambda rec: True
else:
l = len(number)
lambdaNumber = lambda rec: str(rec.telephone.number)[0:l] == number
if not telephoneType:
lambdaTelephoneType = lambda rec: True
else:
t = telephoneTypes[telephoneType]
lambdaTelephoneType = lambda rec: rec.telephone.type == t
root = Template(file=os.path.join(os.curdir, 'index.tmpl'))
telephoneDir = filter(lambda telephone: lambdaSubdivision(telephone) and \
lambdaCollaborator(telephone) and \
lambdaNumber(telephone) and \
lambdaTelephoneType(telephone), sorted(telephoneDir))
textdoc = OpenDocumentText()
tablecontents = Style(name="Table Contents", family="paragraph")
tablecontents.addElement(
ParagraphProperties(numberlines="false", linenumber="0"))
textdoc.styles.addElement(tablecontents)
textdoc.text.addElement(
P(stylename=tablecontents, text=s.name.decode("utf-8")))
style2 = Style(name="style2", family="table-column")
style2.addElement(TableColumnProperties(columnwidth="2cm"))
textdoc.automaticstyles.addElement(style2)
table = Table(name=u"Телефонный справочник")
table.addElement(TableColumn(numbercolumnsrepeated=3, stylename=style2))
def row(rec):
tr = TableRow()
table.addElement(tr)
for r in rec:
tc = TableCell()
tr.addElement(tc)
p = P(stylename=tablecontents, text=r)
tc.addElement(p)
for rec in telephoneDir:
row((str(rec.collaborator).decode("utf-8"), rec.telephone.number,
rec.telephone.type.name.decode("utf-8")))
textdoc.text.addElement(table)
textdoc.save("telephonedir.odt")
def get(self, request, queryset, annee=None):
creneaux_ods = OpenDocumentSpreadsheet()
# Styles
style_entete = Style(parent=creneaux_ods.automaticstyles,
name='cell_entete', family='table-cell')
TextProperties(parent=style_entete, fontweight='bold')
style_col_colleur = Style(parent=creneaux_ods.automaticstyles,
name='col_colleur', family='table-column')
TableColumnProperties(parent=style_col_colleur, columnwidth='5cm')
style_col_matiere = Style(parent=creneaux_ods.automaticstyles,
name='col_matiere', family='table-column')
TableColumnProperties(parent=style_col_matiere, columnwidth='5cm')
style_col_standard = Style(parent=creneaux_ods.automaticstyles,
name='col_standard', family='table-column')
TableColumnProperties(parent=style_col_standard, columnwidth='2cm')
table = Table(name="Créneaux de colles",
parent=creneaux_ods.spreadsheet)
# Définition des colonnes
table.addElement(TableColumn(stylename=style_col_colleur)) # Colleur
table.addElement(TableColumn(stylename=style_col_standard)) # Classe
table.addElement(TableColumn(stylename=style_col_matiere)) # Matière
table.addElement(TableColumn(stylename=style_col_standard)) # Jour
table.addElement(TableColumn(stylename=style_col_standard)) # Début
table.addElement(TableColumn(stylename=style_col_standard)) # Fin
table.addElement(TableColumn(stylename=style_col_standard)) # Salle
# En-tête de tableau
# Container pour les lignes d'en-tête
th = TableHeaderRows(parent=table)
# Ligne d'en-tête
tr = TableRow(parent=th)
P(parent=TableCell(parent=tr, valuetype='string',
stylename=style_entete), text="Colleur")
P(parent=TableCell(parent=tr, valuetype='string',
stylename=style_entete), text="Classe")
P(parent=TableCell(parent=tr, valuetype='string',
stylename=style_entete), text="Matière")
P(parent=TableCell(parent=tr, valuetype='string',
stylename=style_entete), text="Jour")
P(parent=TableCell(parent=tr, valuetype='string',
stylename=style_entete), text="Début")
P(parent=TableCell(parent=tr, valuetype='string',
stylename=style_entete), text="Fin")
P(parent=TableCell(parent=tr, valuetype='string',
stylename=style_entete), text="Salle")
for creneau in queryset:
tr = TableRow(parent=table)
P(parent=TableCell(parent=tr, valuetype='string'), text=str(creneau.colleur))
P(parent=TableCell(parent=tr, valuetype='string'), text=str(creneau.classe))
P(parent=TableCell(parent=tr, valuetype='string'), text=str(creneau.matiere))
P(parent=TableCell(parent=tr, valuetype='string'), text=str(creneau.get_jour_display()))
P(parent=TableCell(parent=tr, valuetype='string'), text=str(creneau.debut))
P(parent=TableCell(parent=tr, valuetype='string'), text=str(creneau.fin))
P(parent=TableCell(parent=tr, valuetype='string'), text=str(creneau.salle))
return OdfResponse(creneaux_ods,
filename="creneaux-{annee}.ods".format(annee=annee))
textdoc = OpenDocumentSpreadsheet()
# Create a style for the table content. One we can modify
# later in the word processor.
tablecontents = Style(parent=textdoc.styles,
name='Table Contents',
family='paragraph')
ParagraphProperties(parent=tablecontents, numberlines='false', linenumber='0')
TextProperties(parent=tablecontents, fontweight='bold')
# Create automatic styles for the column widths.
# We want two different widths, one in inches, the other one in metric.
# ODF Standard section 15.9.1
widthshort = Style(parent=textdoc.automaticstyles,
name='Wshort',
family='table-column')
TableColumnProperties(parent=widthshort, columnwidth='1.7cm')
widthwide = Style(parent=textdoc.automaticstyles,
name='Wwide',
family='table-column')
TableColumnProperties(parent=widthwide, columnwidth='1.5in')
# Start the table, and describe the columns
table = Table(parent=textdoc.spreadsheet, name='Password')
TableColumn(parent=table, numbercolumnsrepeated=4, stylename=widthshort)
TableColumn(parent=table, numbercolumnsrepeated=3, stylename=widthwide)
with open('/etc/passwd') as f:
for line in f:
rec = line.strip().split(':')
tr = TableRow(parent=table)
def initializeDocument(self):
self.textdoc = OpenDocumentText()
# Create a style for the table content. One we can modify
# later in the word processor.
self.tablecontents = Style(name="Table Contents", family="paragraph")
self.tablecontents.addElement(
ParagraphProperties(numberlines="false", linenumber="0"))
self.textdoc.styles.addElement(self.tablecontents)
# ----------------- define a few styles --------------------
# a Bold style
self.BoldStyle = Style(name="Bold", family="paragraph")
self.BoldProp = TextProperties(fontweight="bold")
self.BoldStyle.addElement(self.BoldProp)
self.textdoc.automaticstyles.addElement(self.BoldStyle)
# for Critical findings
self.CriticalStyle = Style(name="Critical Findings",
family="paragraph")
self.CriticalStyleProp = TextProperties(fontweight="bold",
color="#FF0000")
self.CriticalStyle.addElement(self.CriticalStyleProp)
self.textdoc.automaticstyles.addElement(self.CriticalStyle)
# for High findings
self.HighStyle = Style(name="High Findings", family="paragraph")
self.HighStyleProp = TextProperties(fontweight="bold", color="#FF2400")
self.HighStyle.addElement(self.HighStyleProp)
self.textdoc.automaticstyles.addElement(self.HighStyle)
# for Moderate findings
self.ModerateStyle = Style(name="Moderate Findings",
family="paragraph")
self.ModerateStyleProp = TextProperties(fontweight="bold",
color="#FF7F00")
self.ModerateStyle.addElement(self.ModerateStyleProp)
self.textdoc.automaticstyles.addElement(self.ModerateStyle)
# for Low findings
self.LowStyle = Style(name="Low Findings", family="paragraph")
self.LowStyleProp = TextProperties(fontweight="bold", color="#007FFF")
self.LowStyle.addElement(self.LowStyleProp)
self.textdoc.automaticstyles.addElement(self.LowStyle)
# for 'None' or 'Info' or 'Note' findings
self.NoteStyle = Style(name="Note Findings", family="paragraph")
self.NoteStyleProp = TextProperties(fontweight="bold")
self.NoteStyle.addElement(self.NoteStyleProp)
self.textdoc.automaticstyles.addElement(self.NoteStyle)
# nessus plugins can give widely inconsistent ratings: serious/high, medium/moderate, info/note/none...
self.riskFactorsDict = {
'critical': self.CriticalStyle,
'high': self.HighStyle,
'serious': self.HighStyle,
'medium': self.ModerateStyle,
'moderate': self.ModerateStyle,
'low': self.LowStyle,
'info': self.NoteStyle,
'note': self.NoteStyle,
'none': self.NoteStyle
}
# Create automatic styles for the column widths.
# We want two different widths, one in inches, the other one in metric.
# ODF Standard section 15.9.1
widthshort = Style(name="Wshort", family="table-column")
widthshort.addElement(TableColumnProperties(columnwidth="1.7cm"))
self.textdoc.automaticstyles.addElement(widthshort)
widthwide = Style(name="Wwide", family="table-column")
widthwide.addElement(TableColumnProperties(columnwidth="1.5in"))
self.textdoc.automaticstyles.addElement(widthwide)
# hard-code columns styles, per column
widthwide = Style(name="Wwide", family="table-column")
widthwide.addElement(TableColumnProperties(columnwidth="1.5in"))
self.textdoc.automaticstyles.addElement(widthwide)
# Start the table and describe the columns
self.table = Table()
if self.orderType == 'p':
self.table.addElement(
TableColumn(numbercolumnsrepeated=7, stylename=widthwide))
# populate columns with headers...
tr = TableRow()
self.table.addElement(tr)
# declare necessary vars
tc1 = TableCell()
tc2 = TableCell()
tc3 = TableCell()
tc4 = TableCell()
tc5 = TableCell()
tc6 = TableCell()
tc7 = TableCell()
addElem = lambda cell, text, s=self: cell.addElement(
ODFParagraph(stylename=self.BoldStyle,
text=unicode(text, ODFTable.PWENC)))
# Add Column 1: Finding Number
addElem(tc1, 'Finding Number')
tr.addElement(tc1)
# Add Column 2: Vulnerability Name
addElem(tc2, 'Vulnerability Name')
tr.addElement(tc2)
# Add Column 3: NIST 800-53 Mapping
addElem(tc3, '800-53 Mapping')
tr.addElement(tc3)
# Add Column 4: Description
addElem(tc4, 'Description')
tr.addElement(tc4)
# Add Column 5: Recommendation
addElem(tc5, 'Recommendation')
tr.addElement(tc5)
# Add Column 6: CVE
addElem(tc6, 'CVE')
tr.addElement(tc6)
# Add Column 6: Hosts Affected
addElem(tc7, 'IP Address (Sample of hosts effected)')
tr.addElement(tc7)
def colloscope_odf(request, classe):
"""
Affichage du colloscope d'une classe au format OpenDocument
"""
semaines = classe.semaine_set.order_by('debut')
creneaux = classe.creneau_set.order_by('enseignement', 'jour', 'debut')
colles = classe.colle_set.filter(semaine__in=semaines,
creneau__in=creneaux)
# On crée le dictionnaire qui à chaque créneau puis à chaque semaine
# associe les groupes de colle
colloscope = defaultdict(lambda: defaultdict(list))
for colle in colles:
colloscope[colle.creneau][colle.semaine].append(colle)
ods = OpenDocumentSpreadsheet()
# Styles
style_entete = Style(parent=ods.automaticstyles,
name='cell_entete', family='table-cell')
TextProperties(parent=style_entete, fontweight='bold')
style_col_semaine = Style(parent=ods.automaticstyles,
name='col_semaine', family='table-column')
TableColumnProperties(parent=style_col_semaine, columnwidth='1cm')
style_col_matiere = Style(parent=ods.automaticstyles,
name='col_matiere', family='table-column')
TableColumnProperties(parent=style_col_matiere, columnwidth='5cm')
style_col_colleur = Style(parent=ods.automaticstyles,
name='col_colleur', family='table-column')
TableColumnProperties(parent=style_col_colleur, columnwidth='5cm')
style_col_salle = Style(parent=ods.automaticstyles,
name='col_salle', family='table-column')
TableColumnProperties(parent=style_col_salle, columnwidth='2cm')
table = Table(name=str(classe), parent=ods.spreadsheet)
# Ajout des colonnes d'en-tête fixes
entetes_fixes = ("ID", "Matière", "Colleur", "Jour", "Horaire", "Salle")
table.addElement(TableColumn(stylename=style_col_semaine)) # ID
table.addElement(TableColumn(stylename=style_col_matiere)) # Matière
table.addElement(TableColumn(stylename=style_col_colleur)) # Colleur
table.addElement(TableColumn()) # Jour
table.addElement(TableColumn()) # Horaire
table.addElement(TableColumn(stylename=style_col_salle)) # Salle
# Ajout des colonnes d'en-tête des semaines
for _ in semaines:
table.addElement(TableColumn(stylename=style_col_semaine))
# Container pour les lignes d'en-tête
th = TableHeaderRows(parent=table)
# Ligne d'en-tête avec les semestres au-dessus des semaines
tr = TableRow(parent=th)
for entete in entetes_fixes:
P(parent=TableCell(parent=tr, valuetype='string',
numberrowsspanned=2, numbercolumnsspanned=1,
stylename=style_entete), text=entete)
# On doit savoir combien de semaines se trouvent sur chaque période
# pour afficher les en-têtes sur le bon nombre de colonnes
nb_semaines = dict([
(
periode[0],
0,
)
for periode in constantes.PERIODE_CHOICES
])
for semaine in semaines:
nb_semaines[semaine.periode] += 1
# Insertion des titres des périodes
for periode_id, periode_nom in constantes.PERIODE_CHOICES:
if nb_semaines[periode_id] > 0:
P(parent=TableCell(parent=tr, valuetype='string',
numbercolumnsspanned=nb_semaines[periode_id],
numberrowsspanned=1,
stylename=style_entete), text=periode_nom.capitalize())
CoveredTableCell(parent=tr,
numbercolumnsrepeated=nb_semaines[periode_id] - 1)
tr = TableRow(parent=th)
# Ligne d'en-tête avec seulement les semaines
# On doit placer des cellules vides pour les case d'en-tête situées
# avant les semaines
CoveredTableCell(parent=tr, numbercolumnsrepeated=len(entetes_fixes))
# Puis on ajoute les semaines
for semaine in semaines:
P(parent=TableCell(parent=tr, valuetype='string',
stylename=style_entete), text=semaine.numero)
# Colles par créneau
for creneau in creneaux:
tr = TableRow(parent=table)
P(parent=TableCell(parent=tr, valuetype='float', value=creneau.pk),
text=creneau.pk)
P(parent=TableCell(parent=tr, valuetype='string'),
text=creneau.matiere)
P(parent=TableCell(parent=tr, valuetype='string'),
text=creneau.colleur)
P(parent=TableCell(parent=tr, valuetype='string'),
text=creneau.get_jour_display())
P(parent=TableCell(parent=tr, valuetype='time',
timevalue=creneau.debut.strftime("PT%HH%MM%SS")),
text=creneau.debut.strftime("%H:%M"))
P(parent=TableCell(parent=tr, valuetype='string'),
text=creneau.salle)
for semaine in semaines:
groupes_texte = ','.join([str(c.groupe) for c in
colloscope[creneau][semaine] if c.groupe])
cell = TableCell(parent=tr)
if groupes_texte:
cell.valuetype="string"
P(parent=cell, text=groupes_texte)
return OdfResponse(ods, filename="colloscope_{}.ods".format(classe.slug))
def par_classe(classes, fileout):
ods = OpenDocumentSpreadsheet()
style_civilite = Style(parent=ods.automaticstyles,
name='col_civilite',
family='table-column')
TableColumnProperties(parent=style_civilite, columnwidth='1cm')
style_nom = Style(parent=ods.automaticstyles,
name='col_nom',
family='table-column')
TableColumnProperties(parent=style_nom, columnwidth='4.5cm')
style_date = Style(parent=ods.automaticstyles,
name='col_date',
family='table-column')
TableColumnProperties(parent=style_date, columnwidth='3.2cm')
style_internat = Style(parent=ods.automaticstyles,
name='col_internat',
family='table-column')
TableColumnProperties(parent=style_internat, columnwidth='3.2cm')
style_classe = Style(parent=ods.automaticstyles,
name='col_classe',
family='table-column')
TableColumnProperties(parent=style_classe, columnwidth='3.2cm')
style_etat_voeu = Style(parent=ods.automaticstyles,
name='col_etat_voeu',
family='table-column')
TableColumnProperties(parent=style_etat_voeu, columnwidth='4cm')
style_titre = Style(parent=ods.automaticstyles,
name='cell_titre',
family='table-cell')
TextProperties(parent=style_titre, fontweight='bold', fontsize='14pt')
ParagraphProperties(parent=style_titre, textalign='center')
style_ligne_titre = Style(parent=ods.automaticstyles,
name='ligne_titre',
family='table-row')
TableRowProperties(parent=style_ligne_titre, rowheight='8mm')
style_entete = Style(parent=ods.automaticstyles,
name='cell_entete',
family='table-cell')
TextProperties(parent=style_entete, fontweight='bold')
number_style_date_format = odf.number.DateStyle(parent=ods.automaticstyles,
name='date_number')
odf.number.Day(parent=number_style_date_format, style='long')
odf.number.Text(parent=number_style_date_format, text="/")
odf.number.Month(parent=number_style_date_format, style='long')
odf.number.Text(parent=number_style_date_format, text="/")
odf.number.Year(parent=number_style_date_format, style='long')
style_date_format = Style(parent=ods.automaticstyles,
name='cell_date',
family='table-cell',
datastylename=number_style_date_format)
for classe in classes:
table = Table(name=str(classe))
table.addElement(TableColumn(stylename=style_civilite)) # Sexe
table.addElement(TableColumn(stylename=style_nom)) # Nom
table.addElement(TableColumn(stylename=style_nom)) # Prénom
table.addElement(
TableColumn(stylename=style_date)) # Date de naissance
table.addElement(TableColumn(stylename=style_internat)) # Internat
table.addElement(TableColumn(stylename=style_etat_voeu)) # État vœu
table.addElement(TableColumn(stylename=style_nom)) # E-mail
table.addElement(TableColumn(stylename=style_nom)) # Téléphone
table.addElement(TableColumn(stylename=style_nom)) # Mobile
# En-tête de la feuille
tr = TableRow(parent=table, stylename=style_ligne_titre)
cell = TableCell(parent=tr,
numbercolumnsspanned=9,
numberrowsspanned=1,
valuetype='string',
stylename=style_titre)
cell.addElement(P(text=str(classe)))
CoveredTableCell(parent=tr, numbercolumnsrepeated=8)
tr = TableRow(parent=table)
TableCell(parent=tr) # Sexe
P(parent=TableCell(parent=tr,
valuetype='string',
stylename=style_entete),
text="Nom")
P(parent=TableCell(parent=tr,
valuetype='string',
stylename=style_entete),
text="Prénom")
P(parent=TableCell(parent=tr,
valuetype='string',
stylename=style_entete),
text="Date de naissance")
P(parent=TableCell(parent=tr,
valuetype='string',
stylename=style_entete),
text="Internat")
P(parent=TableCell(parent=tr,
valuetype='string',
stylename=style_entete),
text="État Parcoursup")
P(parent=TableCell(parent=tr,
valuetype='string',
stylename=style_entete),
text="E-mail")
P(parent=TableCell(parent=tr,
valuetype='string',
stylename=style_entete),
text="Téléphone")
P(parent=TableCell(parent=tr,
valuetype='string',
stylename=style_entete),
text="Mobile")
for etudiant in classe.admissions().order_by('nom'):
tr = TableRow()
table.addElement(tr)
TableCell(parent=tr, valuetype='string').addElement(
P(text=etudiant.get_sexe_display()))
TableCell(parent=tr,
valuetype='string').addElement(P(text=etudiant.nom))
TableCell(parent=tr,
valuetype='string').addElement(P(text=etudiant.prenom))
cell = TableCell(valuetype='date',
datevalue=str(etudiant.date_naissance),
stylename=style_date_format)
cell.addElement(P(text=etudiant.date_naissance))
tr.addElement(cell)
cell = TableCell(valuetype='string')
if etudiant.proposition_actuelle.internat:
cell.addElement(P(text="Interne"))
tr.addElement(cell)
TableCell(parent=tr, valuetype='string').addElement(
P(text=etudiant.proposition_actuelle.get_etat_display()))
TableCell(parent=tr,
valuetype='string').addElement(P(text=etudiant.email))
TableCell(parent=tr, valuetype='string').addElement(
P(text=etudiant.telephone))
TableCell(parent=tr, valuetype='string').addElement(
P(text=etudiant.telephone_mobile))
ods.spreadsheet.addElement(table)
# Liste générale pour l'infirmerie
table = Table(name="Infirmerie")
ods.spreadsheet.addElement(table)
table.addElement(TableColumn(stylename=style_civilite)) # Sexe
table.addElement(TableColumn(stylename=style_nom)) # Nom
table.addElement(TableColumn(stylename=style_nom)) # Prénom
table.addElement(TableColumn(stylename=style_classe)) # Classe
table.addElement(TableColumn(stylename=style_date)) # Date de naissance
table.addElement(TableColumn(stylename=style_internat)) # Internat
# En-tête de la feuille
tr = TableRow(parent=table, stylename=style_ligne_titre)
cell = TableCell(parent=tr,
numbercolumnsspanned=9,
numberrowsspanned=1,
valuetype='string',
stylename=style_titre)
cell.addElement(P(text="Liste de tous les étudiants admis"))
tr = TableRow(parent=table)
TableCell(parent=tr) # Sexe
P(parent=TableCell(parent=tr, valuetype='string', stylename=style_entete),
text="Nom")
P(parent=TableCell(parent=tr, valuetype='string', stylename=style_entete),
text="Prénom")
P(parent=TableCell(parent=tr, valuetype='string', stylename=style_entete),
text="Classe")
P(parent=TableCell(parent=tr, valuetype='string', stylename=style_entete),
text="Date de naissance")
P(parent=TableCell(parent=tr, valuetype='string', stylename=style_entete),
text="Internat")
for etudiant in Etudiant.objects.filter(
proposition_actuelle__isnull=False,
proposition_actuelle__date_demission__isnull=True).order_by(
'nom', 'prenom'):
tr = TableRow(parent=table)
TableCell(parent=tr, valuetype='string').addElement(
P(text=etudiant.get_sexe_display()))
TableCell(parent=tr,
valuetype='string').addElement(P(text=etudiant.nom))
TableCell(parent=tr,
valuetype='string').addElement(P(text=etudiant.prenom))
TableCell(parent=tr, valuetype='string').addElement(
P(text=str(etudiant.proposition_actuelle.classe)))
cell = TableCell(valuetype='date',
datevalue=str(etudiant.date_naissance),
stylename=style_date_format)
cell.addElement(P(text=etudiant.date_naissance))
tr.addElement(cell)
cell = TableCell(valuetype='string')
if etudiant.proposition_actuelle.internat:
cell.addElement(P(text="Interne"))
tr.addElement(cell)
ods.write(fileout)
def write_sheet():
wide = Style(name="Wide", family="table-column")
wide.addElement(TableColumnProperties(columnwidth="10cm"))
ods.automaticstyles.addElement(wide)
table.addElement(TableColumn(stylename='Wide'))
ods.spreadsheet.addElement(table)
def addTableColumnStyle(self, id, name, properties={}):
style = Style(name=name, family="table-column")
style.addElement(TableColumnProperties(**properties))
setattr(self, id, style)
self.document.automaticstyles.addElement(style)
def save(telephoneDir, subdivision, collaborator, number, telephoneType):
textdoc = OpenDocumentSpreadsheet()
tablecontents = Style(name="Table Contents", family="paragraph")
tablecontents.addElement(
ParagraphProperties(numberlines="false", linenumber="0"))
textdoc.styles.addElement(tablecontents)
style2 = Style(name="style2", family="table-column")
style2.addElement(TableColumnProperties(columnwidth="2cm"))
textdoc.automaticstyles.addElement(style2)
style6 = Style(name="style6", family="table-column")
style6.addElement(TableColumnProperties(columnwidth="6cm"))
textdoc.automaticstyles.addElement(style6)
table = Table(name=u"Подразделения")
table.addElement(TableColumn(numbercolumnsrepeated=2, stylename=style6))
def row(rec):
tr = TableRow()
table.addElement(tr)
for r in rec:
tc = TableCell()
tr.addElement(tc)
p = P(stylename=tablecontents, text=r)
tc.addElement(p)
row((u"подразделение", u"головное подразделение"))
row((telephoneDir.subdivision.name.decode("utf-8"), ""))
def write(subdivision):
for s in subdivision.subdivisions:
row((s.name.decode("utf-8"), subdivision.name.decode("utf-8")))
write(s)
write(telephoneDir.subdivision)
textdoc.spreadsheet.addElement(table)
table = Table(name=u"Телефонный справочник")
table.addElement(TableColumn(numbercolumnsrepeated=2, stylename=style2))
table.addElement(TableColumn(numbercolumnsrepeated=4, stylename=style6))
row((u"телефон", u"код сотр.", u"фамилия", u"имя", u"отчество",
u"подразделение", u"тип тел."))
def find(c, subdivision):
if c in subdivision.collaborators:
return subdivision.name.decode("utf-8")
else:
for s in subdivision.subdivisions:
r = find(c, s)
if r:
return r
subdivision = int(subdivision)
telephoneType = int(telephoneType)
collaborator = collaborator.encode('utf-8')
number = number.encode('utf-8')
if not subdivision:
lambdaSubdivision = lambda rec: True
else:
subdivisions = list(sorted(telephoneDir.subdivision.iterSubdivision()))
subdivisions.insert(0, 'все')
s = subdivisions[subdivision]
lambdaSubdivision = lambda rec: rec.collaborator in s
if not collaborator:
lambdaCollaborator = lambda rec: True
else:
lambdaCollaborator = lambda rec: str(rec.collaborator)[0:len(
collaborator)] == collaborator
if not number:
lambdaNumber = lambda rec: True
else:
lambdaNumber = lambda rec: str(rec.telephone.number)[0:len(number)
] == number
if not telephoneType:
lambdaTelephoneType = lambda rec: True
else:
telephoneTypes = list(sorted(telephoneDir.telephones.telephoneTypes))
telephoneTypes.insert(0, 'все')
t = telephoneTypes[telephoneType]
lambdaTelephoneType = lambda rec: rec.telephone.type == t
tmpDir = list(sorted(telephoneDir))
tmpDir = filter(lambda telephone: lambdaSubdivision(telephone) and \
lambdaCollaborator(telephone) and \
lambdaNumber(telephone) and \
lambdaTelephoneType(telephone), tmpDir)
print subdivision, telephoneType, collaborator, number
for r in tmpDir:
row((r.telephone.number, r.collaborator.code,
r.collaborator.family.decode("utf-8"),
r.collaborator.name.decode("utf-8"),
r.collaborator.patronym.decode("utf-8"),
find(r.collaborator, telephoneDir.subdivision),
r.telephone.type.name.decode("utf-8")))
textdoc.spreadsheet.addElement(table)
textdoc.save("telephonedir.ods")
# Page break style.
s = Style(name="PageBreak", parentstylename="Standard", family="paragraph")
s.addElement(ParagraphProperties(breakbefore="page"))
doc.automaticstyles.addElement(s)
# Bold text.
s = Style(name="TextBold", family="text")
s.addElement(
TextProperties(fontweight="bold",
fontweightasian="bold",
fontweightcomplex="bold"))
doc.automaticstyles.addElement(s)
s = Style(name="AutoWidth", family="table-column")
s.addElement(TableColumnProperties(useoptimalcolumnwidth="true"))
doc.automaticstyles.addElement(s)
s = Style(name="NameWidth", family="table-column")
s.addElement(TableColumnProperties(columnwidth="1cm"))
doc.automaticstyles.addElement(s)
s = Style(name="TableAutoWidth", family="table-column")
s.addElement(TableColumnProperties(useoptimalcolumnwidth='true'))
doc.styles.addElement(s)
# TOC.
toc = TableOfContent(name='toc')
toc.addElement(TableOfContentSource(outlinelevel='2', useindexmarks='false'))
doc.text.addElement(toc)
page_break(doc)
from odf.style import Style, TextProperties, TableColumnProperties, Map
from odf.number import NumberStyle, CurrencyStyle, CurrencySymbol, Number, Text
from odf.text import P
from odf.table import Table, TableColumn, TableRow, TableCell
textdoc = OpenDocumentSpreadsheet()
# Create a style for the table content. One we can modify
# later in the spreadsheet.
tablecontents = Style(name="Large number", family="table-cell")
tablecontents.addElement(TextProperties(fontfamily="Arial", fontsize="15pt"))
textdoc.styles.addElement(tablecontents)
# Create automatic styles for the column widths.
widewidth = Style(name="co1", family="table-column")
widewidth.addElement(
TableColumnProperties(columnwidth="2.8cm", breakbefore="auto"))
textdoc.automaticstyles.addElement(widewidth)
# Create the styles for $AUD format currency values
ns1 = CurrencyStyle(name="positive-AUD", volatile="true")
ns1.addElement(CurrencySymbol(language="en", country="AU", text=u"$"))
ns1.addElement(Number(decimalplaces="2", minintegerdigits="1",
grouping="true"))
textdoc.styles.addElement(ns1)
# Create the main style.
ns2 = CurrencyStyle(name="main-AUD")
ns2.addElement(TextProperties(color="#ff0000"))
ns2.addElement(Text(text=u"-"))
ns2.addElement(CurrencySymbol(language="en", country="AU", text=u"$"))
ns2.addElement(Number(decimalplaces="2", minintegerdigits="1",
ranks=loadRanks(rfname)
tagsr= None
if tm1roundtrip:
tagsr=loadTags(tm1roundtrip)
tagsp= None
if tm1print:
tagsp=loadTags(tm1print)
print "targetApps: ",targetApps
textdoc = OpenDocumentSpreadsheet()
# Create automatic styles for the column widths.
# ODF Standard section 15.9.1
nameColStyle = Style(name="nameColStyle", family="table-column")
nameColStyle.addElement(TableColumnProperties(columnwidth="6cm"))
textdoc.automaticstyles.addElement(nameColStyle)
tagColStyle = Style(name="tagColStyle", family="table-column")
tagColStyle.addElement(TableColumnProperties(columnwidth="5cm"))
tagColStyle.addElement(ParagraphProperties(textalign="left")) #??
textdoc.automaticstyles.addElement(tagColStyle)
rankColStyle = Style(name="rankColStyle", family="table-column")
rankColStyle.addElement(TableColumnProperties(columnwidth="1.5cm"))
rankColStyle.addElement(ParagraphProperties(textalign="center")) #??
textdoc.automaticstyles.addElement(rankColStyle)
valColStyle = Style(name="valColStyle", family="table-column")
valColStyle.addElement(TableColumnProperties(columnwidth="0.9cm"))
valColStyle.addElement(ParagraphProperties(textalign="center")) #??