SGJP / Kuznia

#-*- coding:utf-8 -*-

import json
from django.contrib.auth.models import User
from django.core.cache import cache
from django.db.models import Max
from dictionary.ajax_lexeme_slickgrid import LexemeQuery
from dictionary.models import Lexeme, LexemeInflectionPattern, PartOfSpeech, \
    Pattern, InflectionCharacteristic, Vocabulary, Qualifier, \
    prepare_table, ClassificationValue, CrossReference, TableTemplate, get_root, \
    InputLexeme, CrossReferenceType, filter_visible, \
    editable_vocabularies, visible_qualifiers, LexemeAttributeValue
from dictionary.forms import LexemeEditForm, LIPEditForm, ClassificationForm, \
    CrossReferenceForm, ActionFieldForm, ACTION_FIELDS, LexemeOpenAttributeForm, \
    LexemeClosedAttributeForm, LexemeMultipleAttributeForm
from common.decorators import render, ajax, AjaxError, render_template
from common.util import error_messages


@ajax(method='get', template='inflection_tables.html')
def get_inflection_tables(request, variant, lexeme_id):
    lexeme = Lexeme.all_objects.get(pk=lexeme_id) # może być nowy
    if not lexeme.perm(request.user, 'view'):
        raise AjaxError('access denied')
    qualifiers = visible_qualifiers(request.user)
    tables = lexeme.inflection_tables(variant, qualifiers=qualifiers)
    return {
        'tables': tables,
        'lexeme': lexeme,
        'cross_references': lexeme.refs_to.order_by('type__index'),
        'info': lexeme.sgjp_info(),
    }


@ajax(method='get', template='inflection_table.html')
def table_preview(request, lexeme_id, pattern, inflection_characteristic,
                  lip_id, entry=None, pos=None):
    lexeme = Lexeme.all_objects.get(pk=lexeme_id)
    if not lexeme.perm(request.user, 'view'):
        raise AjaxError('access denied')
    if entry is None:
        entry = lexeme.entry
    if pos is None:
        pos = lexeme.part_of_speech.symbol
    try:
        pattern = Pattern.objects.get(name=pattern)
        inflection_characteristic = InflectionCharacteristic.objects.get(
            pk=inflection_characteristic)
        if lip_id.startswith('lip_add'):
            lip = LexemeInflectionPattern(lexeme=lexeme, index=0)
        else:
            lip = LexemeInflectionPattern.objects.get(pk=int(lip_id[3:]))
        lip.pattern = pattern
        lip.inflection_characteristic = inflection_characteristic
        lip.root = get_root(entry, pos, pattern, inflection_characteristic)
        qualifiers = visible_qualifiers(request.user)
        table = lip.inflection_table('0', separated=True, qualifiers=qualifiers,
            edit_view=True)
        prepare_table(table)
    except Pattern.DoesNotExist:
        table = None
    except TableTemplate.DoesNotExist:
        table = None
    return {'table': table}


@ajax(method='get', template="odm_forms.html")
def odm_forms(request, lexeme_id):
    to_return = {}
    l = Lexeme.all_objects.get(pk=lexeme_id)
    if not l.perm(request.user, 'view'):
        raise AjaxError('access denied')
    odm_lexemes = []
    for l in InputLexeme.objects.filter(entry=l.entry):
        odm_lexemes.append(list(l.inputform_set.values_list('form', flat=True)))
    to_return['odm_lexemes'] = odm_lexemes
    return to_return


def attribute_forms(l, part_of_speech=None, ics=None):
    for attr, v in l.attributes_values(part_of_speech, ics):
        if not attr.closed:
            form_class = LexemeOpenAttributeForm
        elif not attr.multiple:
            form_class = LexemeClosedAttributeForm
        else:
            form_class = LexemeMultipleAttributeForm
        prefix = 'attr%s' % attr.pk
        yield form_class(attribute=attr, initial_value=v, prefix=prefix)


@render_template('extra_attributes.html')
@ajax(method='get', template='extra_attributes.html')
def extra_attributes(request, lexeme_id, pos, ics):
    l = Lexeme.all_objects.get(pk=lexeme_id)
    part_of_speech = PartOfSpeech.objects.get(symbol=pos)
    ics = InflectionCharacteristic.objects.filter(pk__in=ics)
    return {
        'forms': attribute_forms(
            l, part_of_speech=part_of_speech, ics=ics),
    }


@ajax(method='get')
def check_attributes(request, lexeme_id, pos, ics):
    l = Lexeme.all_objects.get(pk=lexeme_id)
    part_of_speech = PartOfSpeech.objects.get(symbol=pos)
    ics = InflectionCharacteristic.objects.filter(
        part_of_speech=part_of_speech, symbol__in=ics)
    attrs = list(l.attributes(part_of_speech, ics).values_list('pk', flat=True))
    return {'attrs': attrs}


@render_template('lexeme_edit_form.html')
@ajax(method='get', template='lexeme_edit_form.html')
def lexeme_edit_form(request, id):
    to_return = {}
    l = Lexeme.all_objects.get(pk=id) # bo może być świeżo utworzony
    if not l.perm(request.user, 'view'):
        raise AjaxError('access denied')
    editable = l.perm(request.user, 'change')
    to_return['editable'] = editable
    owner = l.owner_vocabulary

    to_return['attribute_forms'] = attribute_forms(l)

    editable_vocabs = editable_vocabularies(request.user)
    ro_owner = owner not in editable_vocabs
    to_return['multiple_editable'] = editable and editable_vocabs.count() > 1
    if ro_owner:
        # nie pokazujemy wszystkich, tylko te z właściciela
        ro_qualifiers = l.qualifiers.filter(vocabulary=owner)
    else:
        ro_qualifiers = []
    to_return['owner'] = owner
    ro_vocabularies = l.visible_vocabularies(request.user).exclude(
        pk=owner.pk).exclude(pk__in=editable_vocabs)
    to_return['ro_vocabularies'] = ro_vocabularies
    to_return['ro_qualifiers'] = ro_qualifiers

    to_return['form'] = LexemeEditForm(
        instance=l, editable=editable, user=request.user)
    to_return['id'] = l.pk
    to_return['part_of_speech'] = l.part_of_speech.symbol
    to_return['classification_forms'] = make_classification_forms(
        l, editable=editable)

    lips = l.lexemeinflectionpattern_set.all()
    to_return['lip_forms'] = [
        (LIPEditForm(
            lexeme=l, part_of_speech=l.part_of_speech, instance=lip,
            prefix='lip' + str(lip.pk), user=request.user, editable=editable),
        lip.qualifiers.filter(vocabulary=owner) if ro_owner else [])
        for lip in lips]
    crs = l.refs_to.order_by('type__index')
    to_return['cross_references'] = crs
    return to_return


@ajax(method='get')
def check_classifications(request, owner_id, pos):
    part_of_speech = PartOfSpeech.objects.get(symbol=pos)
    owner = Vocabulary.objects.get(pk=owner_id)
    classifications = owner.classifications.filter(
        parts_of_speech=part_of_speech)
    return {
        'classifications': list(classifications.values_list('pk', flat=True))}


def make_classification_forms(lexeme, vocabulary=None, part_of_speech=None,
                              editable=True):
    if not vocabulary:
        vocabulary = lexeme.owner_vocabulary
    if not part_of_speech:
        part_of_speech = lexeme.part_of_speech
    classifications = vocabulary.classifications.filter(
        parts_of_speech=part_of_speech)
    classification_forms = []
    for c in classifications:
        values = lexeme.classification_values(c)
        classification_forms.append(
            ClassificationForm(
                classification=c, values=values, prefix='cl' + str(c.pk),
                editable=editable))
    return classification_forms


@render_template('classification_forms.html')
@ajax(method='get', template='classification_forms.html')
def classification_forms(request, lexeme_id, vocab_id, pos):
    l = Lexeme.objects.get(pk=lexeme_id)
    part_of_speech = PartOfSpeech.objects.get(symbol=pos)
    if vocab_id:
        vocab = Vocabulary.objects.get(pk=vocab_id)
    else:
        vocab = None
    forms = make_classification_forms(l, vocab, part_of_speech)
    return {'forms': forms}


@render_template('lexeme_edit_form_row.html')
@ajax(method='get', template='lexeme_edit_form_row.html')
def new_lip_edit_row(request, lexeme_id, pos_id, num):
    l = Lexeme.all_objects.get(pk=lexeme_id)
    if not l.perm(request.user, 'change'):
        raise AjaxError('access denied')
    if not pos_id:
        raise AjaxError(u'Nieokreślona część mowy.')
    pos = PartOfSpeech.objects.get(pk=pos_id)
    lip_form = LIPEditForm(
        lexeme=l, part_of_speech=pos, prefix='lip_add_%s' % num,
        user=request.user)
    return {'lip_form': lip_form, 'editable': True}


@render('cross_reference_row.html')
@ajax(method='get', encode_result=False)
def new_cross_reference_row(request, id, pos_id):
    l = Lexeme.objects.get(pk=id)
    if not l.perm(request.user, 'change'):
        raise AjaxError('access denied')
    pos = PartOfSpeech.objects.get(pk=pos_id)
    cr_form = CrossReferenceForm(lexeme=l, pos=pos, prefix='cr_add_NUM')
    return {'cr_form': cr_form, 'editable': True}


@ajax(method='post')
def update_lexeme(request, form_data, mask=''):
    form_dict = dict((x['name'], x['value']) for x in form_data)
    l = Lexeme.all_objects.get(pk=form_dict['id'])
    if not l.perm(request.user, 'view'):
        raise AjaxError('access denied')
    owner = l.owner_vocabulary
    created = l.entry == ''
    if not l.perm(request.user, 'change'):
        return update_lexeme_qualifiers(
            l, request.user, form_dict, form_data)
    form = LexemeEditForm(data=form_dict, instance=l, user=request.user)
    if form.is_valid():
        l = form.save()
        l.responsible = request.user
        l.deleted = False
        l.fix_homonym_number()
        l.save()
    else:
        raise AjaxError(error_messages(form))

    for vocab in editable_vocabularies(request.user):
        if vocab != owner:
            vocab.set_lexeme(l, vocab in form.cleaned_data['vocabularies'])
    new_owner = form.cleaned_data.get('new_owner')
    if new_owner and new_owner != owner:
        l.change_owner(new_owner)
        l.save()
    for qualifier in form.fields['qualifiers'].queryset:
        qualifier.set_for(l, qualifier in form.cleaned_data['qualifiers'])

    classifications = l.owner_vocabulary.classifications.filter(
        parts_of_speech=l.part_of_speech)
    for c in classifications:
        classification_form = ClassificationForm(
            data=form_dict, classification=c, prefix='cl' + str(c.pk))
        if classification_form.is_valid():
            cvs = ClassificationValue.objects.filter(
                pk__in=classification_form.cleaned_data['values'])
            l_cvs = l.classification_values(c)
            for cv in l_cvs:
                if cv.pk not in classification_form.cleaned_data['values']:
                    cv.remove_lexeme(l)
            for cv in cvs:
                if cv not in l_cvs:
                    cv.add_lexeme(l)
        else:
            raise AjaxError(error_messages(classification_form))
    for cv in l.classificationvalue_set.all():
        if cv.classification not in classifications:
            cv.remove_lexeme(l)

    extra_attributes = l.attributes()
    for attr in extra_attributes:
        prefix = 'attr' + str(attr.pk)
        attr_values = attr.values.filter(lexemes=l)
        if not attr.multiple:
            assert len(attr_values) <= 1
            if not attr.closed:
                attr_form = LexemeOpenAttributeForm(
                    attribute=attr, data=form_dict, prefix=prefix)
            else:
                attr_form = LexemeClosedAttributeForm(
                    attribute=attr, data=form_dict, prefix=prefix)
            if attr_form.is_valid():
                if not attr.closed:
                    value = attr_form.cleaned_data['value']
                    av = LexemeAttributeValue.objects.get_or_create(
                        attribute=attr, value=value)
                else:
                    av = attr_form.cleaned_data['value']
                if not attr_values or attr_values.get() != av:
                    for av1 in attr_values:
                        av1.remove_lexeme(l)
                    av.add_lexeme(l)
        else:
            attr_form = LexemeMultipleAttributeForm(
                attribute=attr, data=form_dict, prefix=prefix)
            if attr_form.is_valid():
                new_values = attr_form.cleaned_data['value']
                for av in set(attr_values) - set(new_values):
                    av.remove_lexeme(l)
                for av in set(new_values) - set(attr_values):
                    av.add_lexeme(l)
    for av in l.lexemeattributevalue_set.all():
        if av.attribute not in extra_attributes:
            av.remove_lexeme(l)

    for prefix in form_dict['deleted']:
        pk = int(prefix[3:])
        LexemeInflectionPattern.objects.get(pk=pk).delete()
    for cr_pk in form_dict['deleted_cr']:
        CrossReference.objects.get(pk=cr_pk).delete()
    submitted_lips = []
    submitted_crs = []
    for pair in form_data:
        # może (?) się psuć, jeśli jest zły charfl
        name = pair['name']
        prefix = name.split('-')[0]
        if name.startswith('lip') and prefix not in submitted_lips:
            submitted_lips.append(prefix)
            if prefix.startswith('lip_add'):
                lip = LexemeInflectionPattern()
                lip.lexeme = l
            else:
                pk = int(prefix[3:])
                lip = LexemeInflectionPattern.objects.get(pk=pk)
            form_dict[prefix + '-qualifiers'] = get_list(
                form_data, prefix + '-qualifiers')
            lip_form = LIPEditForm(
                lexeme=l, part_of_speech=l.part_of_speech, data=form_dict,
                prefix=prefix,
                instance=lip, user=request.user, index=len(submitted_lips))
            if lip_form.is_valid():
                lip = lip_form.save()
                lip.root = l.get_root(
                    lip.pattern, lip.inflection_characteristic)
                if lip.root is None:
                    raise AjaxError(
                        u'Niepasujące zakończenie formy podstawowej.')
                for qualifier in lip_form.fields['qualifiers'].queryset:
                    qualifier.set_for(
                        lip, qualifier in lip_form.cleaned_data['qualifiers'])
                lip.save()
            else:
                raise AjaxError(error_messages(lip_form))
        if name.startswith('cr_add') and prefix not in submitted_crs:
            submitted_crs.append(prefix)
            cr_form = CrossReferenceForm(data=form_dict, prefix=prefix)
            if cr_form.is_valid():
                cr_form.save()
            else:
                raise AjaxError(error_messages(cr_form))
    if len(submitted_lips) == 0 and l.status != 'cand':
        raise AjaxError(u'Wybierz odmianę lub ustaw status "kandydat".')
    l.refresh_forms()
    if created:
        sort_rules = request.session['sort_rules']
        filters = request.session['filters']
        query = LexemeQuery(
            filter=filter, sort_rules=sort_rules, mask=mask,
            user=request.user)
        key = query.cache_key()
        pk_list = cache.get(key)
        if pk_list:
            pk_list = [l.pk] + pk_list
            cache.set(key, pk_list)
    return {}


def update_lexeme_qualifiers(lexeme, user, form_dict, form_data):
    owner = lexeme.owner_vocabulary
    editable_vocabs = editable_vocabularies(user).exclude(pk=owner.pk)
    l_editable_vocabs = lexeme.editable_vocabularies(user)
    qualifiers = Qualifier.objects.filter(vocabulary__in=l_editable_vocabs)
    for qualifier in qualifiers:
        qualifier.set_for(
            lexeme, unicode(qualifier.pk) in form_dict['qualifiers'])
    for vocab in editable_vocabs:
        vocab.set_lexeme(lexeme, vocab.pk in form_dict['vocabularies'])
    submitted_lips = []
    for pair in form_data:
        name = pair['name']
        prefix = name.split('-')[0]
        if name.startswith('lip') and prefix not in submitted_lips:
            submitted_lips.append(prefix)
            pk = int(prefix[3:])
            lip = LexemeInflectionPattern.objects.get(pk=pk)
            lip_qualifiers = get_list(form_data, prefix + '-qualifiers')
            for qualifier in qualifiers:
                qualifier.set_for(lip, unicode(qualifier.pk) in lip_qualifiers)
    return {}


def get_list(form_data, name):
    return [pair['value'] for pair in form_data if pair['name'] == name]


@ajax(method='post')
def delete_lexeme(request, lexeme_id):
    lexeme_id = int(lexeme_id)
    l = Lexeme.objects.get(pk=lexeme_id)
    if not l.perm(request.user, 'change'):
        raise AjaxError('access denied')
    l.deleted = True
    l.save()
    key_list = cache.get('key_list', [])
    for key in key_list:
        pk_list = cache.get(key)
        if pk_list and lexeme_id in pk_list:
            pk_list.remove(lexeme_id)
            cache.set(key, pk_list)
    return {}


@ajax(method='get')
def check_pos(request, pos_id, ic_id):
    ic = InflectionCharacteristic.objects.get(pk=ic_id)
    if InflectionCharacteristic.objects.filter(
            symbol=ic.symbol, part_of_speech__pk=pos_id):
        return {'answer': 'yes'}
    else:
        return {'answer': 'no'}


@ajax(method='get')
def check_pattern(request, pattern_name, ic_id):
    lips = LexemeInflectionPattern.objects.filter(
        inflection_characteristic__pk=ic_id, pattern__name=pattern_name)
    lips = lips.exclude(lexeme__status='cand')
    if lips.exists():
        return {'answer': 'yes'}
    else:
        return {'answer': 'no'}


@ajax(method='get')
def get_ics(request, pos_id):
    return {'ics': list(InflectionCharacteristic.objects.filter(
        part_of_speech__pk=pos_id).values_list('pk', 'symbol'))}


START_ID = 1000000


@ajax(method='post')
def create_lexeme(request, vocab_id):
    owner = Vocabulary.objects.get(pk=vocab_id)
    if request.user not in owner.all_editors():
        raise AjaxError('access denied')
    next_id = Lexeme.all_objects.filter(
        pk__gte=START_ID).aggregate(Max('id'))['id__max']
    next_id = next_id + 1 if next_id else START_ID
    l = Lexeme()
    l.id = next_id
    l.homonym_number = 1 # zanim zostanie faktycznie stworzony
    l.part_of_speech = PartOfSpeech.objects.get(symbol='subst')
    l.owner_vocabulary = owner
    l.status = 'cand'
    l.responsible = request.user
    l.deleted = True # proste i genialne!
    l.save()
    owner.add_lexeme(l)
    return {'id': l.id}


@ajax(method='get', login_required=True)
def homonym_count(request, entry, lexeme_id):
    lexemes = Lexeme.objects.filter(entry=entry).exclude(pk=lexeme_id)
    lexemes = filter_visible(lexemes, request.user)
    return {'count': lexemes.count()}


@ajax(method='get', login_required=True)
def cr_homonyms(request, entry, cr_type):
    cr_type = CrossReferenceType.objects.get(pk=cr_type)
    lexemes = Lexeme.objects.filter(entry=entry, part_of_speech=cr_type.to_pos)
    lexemes_data = [
        {
            'homonym_number': l.homonym_number,
            'lip_data': l.lip_data(),
        } for l in lexemes.order_by('homonym_number')
    ]
    return {'lexemes': lexemes_data}


@render('new_action_row.html')
@ajax(method='get', login_required=True, encode_result=False)
def new_action_row(request):
    form = ActionFieldForm(prefix='action_NUM')
    return {'form': form}


@ajax(method='get', login_required=True)
def dynamic_action_fields(request, field_name):
    action_form, value_form = dict(ACTION_FIELDS)[field_name][1:3]
    return {
        'action': action_form()['action'].as_widget(),
        'value': value_form(request)['value'].as_widget(),
    }


@ajax(method='post', login_required=True)
def execute_group_actions(request, actions, filters):
    if not request.user.has_perm('dictionary.change_lexeme'):
        raise AjaxError('access denied')
    if isinstance(filters, basestring):
        filters = json.loads(filters)
    query = LexemeQuery(
        filter=filter, sort_rules=[], mask='', user=request.user)
    pk_list = query.get_id_list()
    lexemes = Lexeme.objects.filter(pk__in=pk_list)
    for l in lexemes:
        for action in actions:
            field = action['field']
            if field == 'status':
                # action['type'] == 'set'
                l.status = action['value']
            elif field == 'using_vocabulary':
                vocab = Vocabulary.objects.get(pk=action['value'])
                if action['type'] == 'add':
                    vocab.add_lexeme(l)
                else: # 'remove'
                    if vocab != l.owner_vocabulary:
                        vocab.remove_lexeme(l)
            else: # field == 'lexeme_qualifier'
                qual = Qualifier.objects.get(pk=action['value'])
                # a co jeśli koliduje z innym?
                if action['type'] == 'add':
                    l.qualifiers.add(qual) #add
                else:
                    l.qualifiers.remove(qual) #add
        l.save()
        #print repr(actions), repr(filters)
    return {}


@ajax(method='post')
def save_columns(request, columns):
    request.session['columns'] = columns
    return {}


@ajax(method='post')
def add_vocabulary(request, name):
    if not request.user.has_perm('dictionary.manage_vocabulary'):
        raise AjaxError('access denied')
    vocab = Vocabulary.objects.create(id=name)
    vocab.managers.add(request.user) #add
    return {}

# nieużywane
@ajax(method='get')
def vocabulary_permissions(request, vocab_id):
    if not request.user.has_perm('dictionary.manage_vocabulary'):
        raise AjaxError('access denied')
    vocab = Vocabulary.objects.get(id=vocab_id)
    return {
        'managers': list(vocab.all_managers().values_list('pk', flat=True)),
        'viewers': list(vocab.all_viewers().values_list('pk', flat=True)),
        'editors': list(vocab.editors.values_list('pk', flat=True)),
    }


@ajax(method='post')
def set_vocabulary_permission(request, name, vocab_id, perm, on):
    if not request.user.has_perm('dictionary.manage_vocabulary'):
        raise AjaxError('access denied')
    vocab = Vocabulary.objects.get(id=name)
    user = User.objects.get(pk=vocab_id)
    if perm == 'view':
        related_manager = vocab.viewers
    elif perm == 'change':
        related_manager = vocab.editors
    else: # type == 'manage'
        related_manager = vocab.managers
    if on:
        related_manager.add(user) #add
    else:
        related_manager.remove(user) #add
    return {}