ajax_pattern_view.py 5.87 KB
#-*- coding:utf-8 -*-

from common.util import json_encode
from dictionary.models import Pattern, Ending, BaseFormLabel, PatternType, \
    editable_qualifiers, readonly_vocabularies
from dictionary.forms import PatternEditForm, PatternTypeForm, QualifierForm
from dictionary.ajax_slickgrid import SlickGridAjax, SlickGridQuery
from common.decorators import render, ajax, AjaxError, render_template


class PatternGrid(SlickGridAjax):
    model = Pattern
    search_field = 'name'

    @staticmethod
    def filter_special_case(filter, lookup, negated, queryset):
        field = filter['field']
        if field == 'part_of_speech':
            field = 'type__lexical_class__symbol'
        elif field == 'type':
            field = 'type__symbol'
        return False, field, queryset

    @staticmethod
    def apply_mask(patterns, mask, sort_rules):
        return patterns.filter(name__istartswith=mask)

    @staticmethod
    def response_row(pattern):
        return [
            pattern.name,
            pattern.type.symbol,
            pattern.type.lexical_class.symbol,
        ]


# Zapytanie o indeks wiersza o pewnym id przy danym sortowaniu
@ajax(method='get')
def find_id(request, id, sort_rules, mask, filters=None):
    query = SlickGridQuery(
        filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
    return PatternGrid.find_id(id, query)


# Zapytanie o id oraz indeks wiersza przy danym sortowaniu
# pierwszego wiersza, którego hasło rozpoczyna się od mask.
# 'selected_id' < 0, jeśli takiego nie ma
@ajax(method='get')
def get_location(request, sort_rules, filters=None, mask=''):
    query = SlickGridQuery(
        filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
    return PatternGrid.get_location(query)


@ajax(method='get')
def get_patterns(request, page, rows, sort_rules, filters=None, mask='',
                 target_page=0, totalrows=0):
    request.session['pattern-sort_rules'] = json_encode(sort_rules)
    request.session['pattern-filters'] = json_encode(filters)
    page = target_page or page
    limit = totalrows or rows
    query = SlickGridQuery(
        filters=filters, sort_rules=sort_rules, mask=mask, user=request.user)
    return PatternGrid.get_page(page, limit, query)


@render_template('pattern_edit_form.html')
@ajax(method='get', template='pattern_edit_form.html')
def pattern_edit_form(request, id):
    if not request.user.has_perm('dictionary.view_pattern'):
        raise AjaxError('access denied')
    to_return = {}
    p = Pattern.objects.get(pk=id)
    editable = request.user.has_perm('dictionary.change_pattern')
    to_return['pattern'] = p
    to_return['form'] = PatternEditForm(instance=p, editable=editable)
    to_return['type_form'] = PatternTypeForm(instance=p.type, editable=editable)
    to_return['editable'] = editable
    bfls = p.type.base_form_labels()
    ending_groups = dict((bfl, []) for bfl in bfls)
    endings = p.endings.order_by('base_form_label', 'index')
    for e in endings:
        ro_qualifers = e.qualifiers.filter(
            vocabulary__in=readonly_vocabularies(request.user))
        q_form = QualifierForm(
            qualified=e, user=request.user, editable=editable,
            prefix='end%s' % e.pk)
        ending_groups[e.base_form_label].append((e, ro_qualifers, q_form))
    to_return['ending_groups'] = ending_groups
    return to_return


# mogłoby iść przez js_vars...
@render('ending_row.html')
@ajax(method='get', encode_result=False)
def new_ending_row(request, pattern_id):
    p = Pattern.objects.get(id=pattern_id)
    ending = {'string': '', 'id': 'add-NUM'}
    form = QualifierForm(user=request.user, prefix='add-NUM')
    return {'ending': ending, 'editable': True, 'form': form, 'pattern': p}


@ajax(method='post')
def update_pattern(request, form_data):
    if not request.user.has_perm('dictionary.change_pattern'):
        raise AjaxError('access denied')
    form_dict = dict((x['name'], x['value']) for x in form_data)
    p = Pattern.objects.get(pk=form_dict['id'])
    form = PatternEditForm(data=form_dict, instance=p)
    type_form = PatternTypeForm(data=form_dict)
    if type_form.is_valid():
        type_qs = PatternType.objects.filter(
            symbol=type_form.cleaned_data['symbol'],
            lexical_class=type_form.cleaned_data['lexical_class'])
    else:
        raise AjaxError('invalid data')
    if form.is_valid() and len(type_qs) == 1:
        form.save()
        p.type = type_qs[0]
        p.save()
        for ending_pk in form_dict['deleted']:
            Ending.objects.get(pk=int(ending_pk)).delete()
        qualifiers = editable_qualifiers(request.user)
        for bfl_endings in form_dict['ending_list']:
            endings_data = bfl_endings['endings']
            bfl = BaseFormLabel.objects.get(
                symbol=bfl_endings['base_form_label'])
            endings = []
            for index, ending_data in zip(range(1, len(endings_data) + 1),
                    endings_data):
                quals = set(int(q) for q in ending_data['qualifiers'])
                if ending_data['id'] == 'add':
                    ending = Ending.objects.create(
                        pattern=p, base_form_label=bfl,
                        string=ending_data['string'],
                        index=index)
                else:
                    ending = Ending.objects.get(pk=int(ending_data['id']))
                    ending.index = index
                    ending.string = ending_data['string']
                    ending.save()
                for qualifier in qualifiers:
                    qualifier.set_for(ending, qualifier.pk in quals)
                endings.append(ending)
    else:
        raise AjaxError('invalid data')
    return {}


@ajax(method='post')
def save_columns(request, col_model, col_names, remap):
    request.session['pattern-colModel'] = col_model
    request.session['pattern-colNames'] = col_names
    request.session['pattern-remap'] = remap
    return {}