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

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


class PatternQuery(SlickGridQuery):
    model = Pattern
    sort_field = 'name'
    select_related = ['type__lexical_class']

    filter_field_translation = {
        'lexical_class': 'type__lexical_class__symbol',
        'type': 'type__symbol',
    }

    def apply_mask(self, patterns):
        return patterns.filter(name__istartswith=self.mask)

    def response_row(self, pattern):
        return {
            'id': pattern.id,
            'name': pattern.name,
            'type': pattern.type.symbol,
            'lexical_class': pattern.type.lexical_class.symbol,
            'example': pattern.example + u'·' + pattern.basic_form_ending,
        }

# 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 search_index(request, sort_rules, filter, search=''):
    query = PatternQuery(
        filter=filter, sort_rules=sort_rules, mask=search, user=request.user)
    return {'index': query.search_index()}

@ajax(method='get')
def get_patterns(request, from_page, to_page, rows, sort_rules, filter,
                 mask=''):
    request.session['pattern-sort_rules'] = sort_rules
    request.session['pattern-filter'] = filter
    query = PatternQuery(
        filter=filter, sort_rules=sort_rules, mask=mask, user=request.user)
    rows, count = query.get_page(from_page, to_page, rows)
    return {
        'rows': rows,
        'count': count,
        'page': from_page,
    }

@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, columns):
    request.session['pattern-columns'] = columns
    return {}