ajax_table_view.py 7.03 KB
# -*- coding: utf-8 -*-
from common.decorators import render_ajax, ajax
from common.util import FakeQueryset
from dictionary.forms import CellRestrictionsForm, BaseFormLabelForm, \
    CSSClassForm, TemplatePreviewForm, AttributeValuesForm, GenderForm, \
    TemplatePreviewGenderForm, LexemeClosedAttributeForm
from dictionary.models import TableTemplate, BaseFormLabel, PatternType, \
    TableCell, TableHeader, ExportCell, Gender, LexemeAttributeValue


def tt_params(tt):
    pt_queryset = tt.pattern_types.all()
    p_types = FakeQueryset(pt_queryset)
    parts_of_speech = list(tt.parts_of_speech.all())
    color_scheme = parts_of_speech[0].color_scheme
    bfls = BaseFormLabel.objects.filter(patterntype__in=p_types).distinct()
    return bfls, color_scheme, p_types


@render_ajax(template='table_edit_form.html', method='get')
def table_edit_form(request, template_id):
    tt = TableTemplate.objects.get(id=template_id)
    tt_attrs = tt.cell_attributes.prefetch_related('values')

    def cr_form(x):
        return CellRestrictionsForm(
            x.pattern_types.all(), p_types, prefix=prefix)

    def gender_form(x):
        return GenderForm(x.genders.all(), prefix=prefix)

    def attr_forms(x):
        vals = x.attribute_values.all()
        return [
            AttributeValuesForm(
                attr, [v for v in vals if v.attribute == attr],
                prefix='%s_%s' % (prefix, attr.id))
            for attr in tt_attrs]

    form_rows = []
    bfls, color_scheme, p_types = tt_params(tt)
    table_cells = tt.table_cells.prefetch_related(
        'pattern_types', 'attribute_values', 'genders')
    export_cells = tt.export_cells.prefetch_related(
        'pattern_types', 'attribute_values', 'genders').select_related(
        'base_form_label')
    headers = tt.headers.prefetch_related(
        'pattern_types', 'attribute_values', 'genders')
    for tc in table_cells:
        prefix = u'tc%s' % tc.id
        bfl_form = BaseFormLabelForm(
            bfls, tc.base_form_label_id, prefix=prefix)
        g_form = gender_form(tc) if tt.takes_gender else None
        form_rows.append((
            (tc.row, tc.col, tc.rowspan, tc.colspan, tc.index),
            ('table', bfl_form, tc.prefix, tc.suffix),
            cr_form(tc),
            g_form,
            attr_forms(tc),
        ))
    for ec in export_cells:
        prefix = u'ec%s' % ec.id
        bfl_form = BaseFormLabelForm(
            bfls, ec.base_form_label_id, prefix=prefix)
        g_form = gender_form(ec) if tt.takes_gender else None
        form_rows.append((
            ec.tag_template,
            ('export', bfl_form, ec.prefix, ec.suffix),
            cr_form(ec),
            g_form,
            attr_forms(ec),
            ec.base_form_label.index,
        ))
    for header in headers:
        prefix = u'th%s' % header.id
        class_form = CSSClassForm(
            header.css_class, prefix=prefix)
        g_form = gender_form(header) if tt.takes_gender else None
        form_rows.append((
            (header.row, header.col, header.rowspan, header.colspan),
            ('header', header.label, class_form),
            cr_form(header),
            g_form,
            attr_forms(header),
        ))
    if export_cells:
        form_rows.sort(key=lambda row: (row[-1], row[0], row[1][2:]))
        export = True
    else:
        form_rows.sort()
        export = False
    return {
        'form_rows': form_rows,
        'color_scheme': color_scheme,
        'export': export,
        'template_attrs': tt_attrs,
        'takes_gender': tt.takes_gender,
    }


@render_ajax(template='table_edit_row.html', method='get')
def new_template_row(request, template_id, row_type, num):
    tt = TableTemplate.objects.get(id=template_id)
    bfls, color_scheme, p_types = tt_params(tt)
    prefix = 'new%s' % num
    if row_type == 'export':
        coord = ''
    elif row_type == 'table':
        coord = ('', '', '', '', '')
    else:
        coord = ('', '', '', '')
    if row_type != 'header':
        bfl_form = BaseFormLabelForm(bfls, prefix=prefix)
        params = [row_type, bfl_form, '', '']
    else:
        class_form = CSSClassForm(prefix=prefix)
        params = [row_type, '', class_form]
    form = CellRestrictionsForm(p_types, p_types, prefix=prefix)
    return {
        'coord': coord,
        'params': params,
        'cr_form': form,
        'gender_form': GenderForm(),
        'attr_forms': [
            AttributeValuesForm(attr) for attr in tt.cell_attributes.all()],
        'takes_gender': tt.takes_gender,
    }


@render_ajax(template='template_preview_form.html', method='get')
def template_preview_form(request, template_id):
    tt = TableTemplate.objects.get(id=template_id)
    p_types = tt.pattern_types.all()
    form = TemplatePreviewForm(p_types)
    if tt.takes_gender:
        gender_form = TemplatePreviewGenderForm()
    else:
        gender_form = None
    attr_forms = [
        LexemeClosedAttributeForm(attr) for attr in tt.cell_attributes.all()]
    return {'form': form, 'gender_form': gender_form, 'attr_forms': attr_forms}


@render_ajax(template='table_preview.html', method='get')
def template_preview(request, template_id, pattern_type_id, gender_id,
                     attr_data):
    tt = TableTemplate.objects.get(id=template_id)
    pt = PatternType.objects.get(id=pattern_type_id)
    if gender_id:
        gender = Gender.objects.get(id=gender_id)
    else:
        gender = None
    attr_vals = LexemeAttributeValue.objects.filter(id__in=attr_data)
    table = tt.render_with_pattern_type(pt, gender, attr_vals, span=True)
    part_of_speech = tt.parts_of_speech.all()[0]
    return {'table': table, 'color_scheme': part_of_speech.color_scheme}


@ajax(method='post')
def save_template(request, template_id, table_cells, headers, export_cells):
    def add_restrictions(x):
        x.pattern_types = pts
        if genders:
            x.genders = genders
        x.attribute_values = attr_vals

    tt = TableTemplate.objects.get(id=template_id)
    tt.table_cells.all().delete()
    tt.headers.all().delete()
    tt.export_cells.all().delete()
    for tc_data in table_cells:
        row, col, rspan, cspan, index, bfl, prefix, suffix, pts, \
            genders, attr_vals = tc_data
        tc = TableCell(
            table_template=tt,
            row=row, col=col, rowspan=rspan, colspan=cspan, index=index,
            base_form_label_id=bfl, prefix=prefix, suffix=suffix)
        tc.save()
        add_restrictions(tc)
    for h_data in headers:
        row, col, rspan, cspan, label, css_class, pts, genders, \
            attr_vals = h_data
        th = TableHeader(
            table_template=tt,
            row=row, col=col, rowspan=rspan, colspan=cspan, label=label,
            css_class=css_class)
        th.save()
        add_restrictions(th)
    for ec_data in export_cells:
        bfl, prefix, suffix, tag_template, pts, genders, \
            attr_vals = ec_data
        ec = ExportCell(
            table_template=tt,
            base_form_label_id=bfl, prefix=prefix, suffix=suffix,
            tag_template=tag_template)
        ec.save()
        add_restrictions(ec)
    return {}