views.py

"""
iPPI-DB django views module
"""

import json
import math
from collections import OrderedDict

from django.db.models import Max, Min, Count, F, Q
from django.db.models.functions import Cast
from django.db.models import FloatField                                                                                                                                                                 
from django.shortcuts import render
from django.urls import reverse
from django.http import HttpResponseRedirect, Http404, JsonResponse
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic.list import ListView
from django.views.generic.base import RedirectView
from formtools.wizard.views import SessionWizardView, NamedUrlSessionWizardView

import ippidb
from .forms import *
from .utils import mol2smi, smi2mol
from .models import Protein, Bibliography, ProteinDomainComplex, ProteinDomainBoundComplex, RefCompoundBiblio, TestActivityDescription, Compound, Ppi, Disease, Taxonomy, LeLleBiplotData, PcaBiplotData, PpiFamily, CompoundTanimoto, create_tanimoto
from .ws import get_pdb_uniprot_mapping


def index(request):
    return render(request, 'index.html')


def about(request):
    return render(request, 'about.html')


def general(request):
    return render(request, 'general.html')


def tutorials(request):
    return render(request, 'tutorials.html')

def contribute(request):
    return render(request, 'contribute.html')

def adminSession(request):
    return render(request, 'admin-session.html')

def update (request):
    return render(request, 'update.html')

#---------------------------------------------- CONTRIBUTE SESSION - WIZARD -------------------------------------------#

FORMS = [("IdForm", ippidb.forms.IdForm),
         ("BibliographyForm", ippidb.forms.BibliographyForm),
         ("PDBForm", ippidb.forms.PDBForm),
         ("ProteinDomainComplexTypeForm",
          ippidb.forms.ProteinDomainComplexTypeForm),
         ("ProteinDomainComplexForm", ippidb.forms.ComplexCompositionFormSet),
         ("PpiForm", ippidb.forms.PpiAndComplexForm),
         ("CompoundForm", ippidb.forms.CompoundFormSet),
         ("TestsForm", ippidb.forms.TestsFormSet),]

TEMPLATES = {"IdForm": "IdForm.html",
             "BibliographyForm": "BibliographyForm.html",
             "PDBForm": "PDBForm.html",
             "ProteinDomainComplexTypeForm": "ProteinDomainComplexTypeForm.html",
             "ProteinDomainComplexForm": "ProteinDomainComplexForm.html",
             "PpiForm": "PpiForm.html",
             "CompoundForm":"CompoundForm.html",
             "TestsForm":"TestsForm.html",
             }


class IppiWizard(LoginRequiredMixin, NamedUrlSessionWizardView):

    def get_context_data(self, **kwargs):
        context=super(IppiWizard, self).get_context_data(**kwargs)
        if self.steps.current == 'BibliographyForm':
            context['id_source']=self.storage.get_step_data('IdForm').get('IdForm-id_source')
            context['source']=self.storage.get_step_data('IdForm').get('IdForm-source')
            print(self.storage.get_step_data('IdForm').get('IdForm-id_source'))
        if self.steps.current == 'ProteinDomainComplexForm':
            context['complex_choice']=self.storage.get_step_data('ProteinDomainComplexTypeForm').get('ProteinDomainComplexTypeForm-complexChoice')
            context['complex_type']=self.storage.get_step_data('ProteinDomainComplexTypeForm').get('ProteinDomainComplexTypeForm-complexType')
            context['pdb']=self.storage.get_step_data('PDBForm').get('PDBForm-pdb_id')
        if self.steps.current == 'PpiForm':
            context['complex_choice']=self.storage.get_step_data('ProteinDomainComplexTypeForm').get('ProteinDomainComplexTypeForm-complexChoice')
            context['complex_type']=self.storage.get_step_data('ProteinDomainComplexTypeForm').get('ProteinDomainComplexTypeForm-complexType')
            context['pdb_id']=self.storage.get_step_data('PDBForm').get('PDBForm-pdb_id')
        return context

    def get_form_kwargs(self, step):
        # change args pass to a form
        kwargs = super().get_form_kwargs()
        if step == 'ProteinDomainComplexForm':
            pks = self.storage.get_step_data('PDBForm').get('pks')
            # print("test pks: ",pks)
            kwargs['form_kwargs']={'pks':pks}
        return kwargs

    def get_form_initial(self, step):
    # Works for form.forms
    # change value pass to a form
        initial = super().get_form_initial(step)
        if step == 'PpiForm':
            initial['pdb_id'] = self.storage.get_step_data('PDBForm').get('PDBForm-pdb_id')
        return initial

    def process_step(self, form):
        """
        This method overrides the one used to postprocess the form data.
        The added code just sets the form model for use in later forms
        when appropriate
        """
        data = super(IppiWizard, self).process_step(form).copy()
        if self.steps.current=='IdForm':
            form.instance.autofill()
        if self.steps.current in ['IdForm', 'Bibliography']:
            form.instance.save()
            data['pk'] = form.instance.id
        if self.steps.current == 'PDBForm':
            pdb_id = form.cleaned_data['pdb_id']
            uniprot_ids = []
            protein_ids = []
            uniprot_ids += get_pdb_uniprot_mapping(pdb_id)
            for uniprot_id in uniprot_ids:
                try:
                    p = Protein.objects.get(uniprot_id=uniprot_id)
                except Protein.DoesNotExist:
                    p = Protein()
                    p.uniprot_id = uniprot_ids[0]
                    p.autofill()
                    p.save()
                protein_ids.append(p.id)
            data['pks'] = protein_ids
        return data

    def get_form_instance(self, step):
    # Works only for Modelform
        if self.steps.current == 'BibliographyForm':
            pk = self.storage.get_step_data('IdForm').get('pk')
            return Bibliography.objects.get(pk=pk)
        if self.steps.current == 'ProteinDomainComplexTypeForm':
            print("blablabla", self.storage.get_step_data('PDBForm').get('pks'))
            pks = self.storage.get_step_data('PDBForm').get('pks')
            print("blablabla", self.storage.get_step_data('PDBForm').get('pks'))
            return Protein.objects.filter(id__in=pks)

    def get_template_names(self):
        return [TEMPLATES[self.steps.current]]

    def done(self, form_list, **kwargs):
        return render(self.request, 'done.html', {
        'form_data': [form.cleaned_data for form in form_list],
    })

#----------------------------------------------------------------------------------------------------------------------#


class CompoundListFilterHandler(object):

    def __init__(self, filter_class, relation_from_compound, relation_to_compound, parameter_name, filter_context, request_get):
        self.filter_class = filter_class
        self.relation_from_compound = relation_from_compound
        self.parameter_name = parameter_name
        self.filter_context = filter_context
        self.relation_from_compound = relation_from_compound
        self.relation_to_compound = relation_to_compound
        self.value = request_get.getlist(parameter_name)

    def process(self, queryset):
        """ to be called during queryset filtering """
        # if a value has been set for this filter
        if self.value:
            # filter queryset on the ID values specified
            queryset = queryset.filter(**{self.relation_from_compound + '__id__in': self.value})
            # selected objects on the ID values specified
            self.filter_context['selected_' + self.parameter_name] = self.filter_class.objects.filter(id__in = self.value)
            # unselected objects on the ID values not specified
            self.filter_context[self.parameter_name] = self.filter_class.objects.exclude(id__in = self.value)
        return queryset
    
    def post_process(self, compound_ids, queryset):
        """ to be called after queryset filtering """
        # if no value has been set for this filter
        if not self.value:
            # selected objects is an empty queryset
            self.filter_context['selected_' + self.parameter_name] = self.filter_class.objects.none()
            if compound_ids:
                # unselected objects is the range related to the current queryset
                self.filter_context[self.parameter_name] = self.filter_class.objects.filter(**{self.relation_to_compound + '__id__in':compound_ids}).distinct()
            else:
                # unselected objects are all objects if no filter is set
                self.filter_context[self.parameter_name] = self.filter_class.objects.all()

class CompoundSimilarityFilterHandler(object):

    def __init__(self, parameter_name, filter_context, request_get):
        self.parameter_name = parameter_name
        self.filter_context = filter_context
        if request_get.get(self.parameter_name):
            self.value = request_get.get(self.parameter_name).strip()
        else:
            self.value = None

    def process(self, queryset):
        """ to be called during queryset filtering """
        if self.value:
            fingerprint, query = self.value.split(':')
            self.filter_context[self.parameter_name] = self.value
            self.filter_context[self.parameter_name+'_fingerprint'] = fingerprint
            self.filter_context[self.parameter_name+'_query'] = query
            #FIXME: test if exists before running
            create_tanimoto(query, fingerprint)
            queryset = queryset.filter(compoundtanimoto__canonical_smiles=query, compoundtanimoto__fingerprint=fingerprint).annotate(tanimoto=F('compoundtanimoto__tanimoto'))
        return queryset
    
    def post_process(self, compound_ids, queryset):
        """ to be called after queryset filtering """
        pass

class TextSearchFilterHandler(object):

    def __init__(self, parameter_name, filter_context, request_get):
        self.parameter_name = parameter_name
        self.filter_context = filter_context
        if request_get.get(self.parameter_name):
            self.value = request_get.get(self.parameter_name).strip()
        else:
            self.value = None
        self.filter_context[self.parameter_name] = self.value

    def process(self, queryset):
        """ to be called during queryset filtering """
        if self.value:
            # filter on:
            # compound common name
            # PPI family name
            # bound complex protein short name
            # disease name
            queryset = queryset.filter(Q(common_name__icontains=self.value) |
                Q(compoundaction__ppi__family__name__icontains=self.value) |
                Q(compoundaction__ppi_id__ppicomplex__complex__protein__short_name__icontains=self.value) |
                Q(compoundaction__ppi__diseases__name__icontains=self.value) )
        return queryset
    
    def post_process(self, compound_ids, queryset):
        """ to be called after queryset filtering """
        pass

class CompoundRangeFilterHandler(object):

    def __init__(self, parameter_name, filter_context, request_get, step=1):
        self.parameter_name = parameter_name
        self.filter_context = filter_context
        self.value = None
        self.step = step or 1
        if request_get.get(parameter_name):
            self.value = request_get.get(parameter_name)
            self.value_min, self.value_max = self.value.split(',')
        else:
            self.value_min = None
            self.value_max = None


    def process(self, queryset):
        """ to be called during queryset filtering """
        # if a value has been set for this filter
        if self.value:
            # filter queryset on the ID values specified
            self.filter_context[self.parameter_name] = self.value
            self.filter_context[self.parameter_name + '_value_min'] = self.value_min
            self.filter_context[self.parameter_name + '_value_max'] = self.value_max
            filter_dict = {
                self.parameter_name + '__gte': self.value_min,
                self.parameter_name + '__lte': self.value_max,
                }
            queryset = queryset.filter(**filter_dict)
            # max and min value are the max and min for
            qs = Compound.objects
            self.filter_context[self.parameter_name+'_max'] = self.get_max(qs)
            self.filter_context[self.parameter_name+'_min'] = self.get_min(qs)
        return queryset

    def get_max(self, qs):
        val = float(qs.aggregate(Max(self.parameter_name))[self.parameter_name + '__max'] or 0)
        val = val - val % self.step + self.step
        return str(val)

    def get_min(self, qs):
        val = float(qs.aggregate(Min(self.parameter_name))[self.parameter_name + '__min'] or 0)
        val = val - val % self.step + self.step
        return str(val)


    def post_process(self, compound_ids, queryset):
        """ to be called after queryset filtering """
        # if no value has been set for this filter
        if not self.value:
            self.filter_context[self.parameter_name+'_max'] = self.get_max(queryset)
            self.filter_context[self.parameter_name+'_min'] = self.get_min(queryset)

class ExistsFilterHandler(object):

    def __init__(self, parameter_name, filter_context, request_get):
        self.parameter_name = parameter_name
        self.filter_context = filter_context
        self.value = None
        if request_get.get(parameter_name):
            self.value = request_get.get(parameter_name)
            self.filter_context[self.parameter_name] = self.value

    def process(self, queryset):
        """ to be called during queryset filtering """
        # if a value has been set for this filter
        if self.value:
            # filter queryset on the ID values specified
            queryset = queryset.exclude(**{self.parameter_name+'__isnull':not(self.value)})
        return queryset

    def post_process(self, compound_ids, queryset):
        """ to be called after queryset filtering """
        pass

class CompoundListView(ListView):

    model = Compound
    template_name = "compound_list.html"
    paginate_by = 15
    
    table_view_default_fields = ['id', 'canonical_smiles', 'common_name', 'molecular_weight', 'a_log_p', 'compound_action_ligand_ids', 'pubs']

    sort_by_option_ids = ['id', 'molecular_weight', 'a_log_p', 'nb_aromatic_sssr', 'nb_chiral_centers', 'pubs', 'le', 'lle', 'best_activity']

    def get_ordering(self):
        # sort by options
        self.sort_by_options = OrderedDict()
        compound_fields = {f.name: f.verbose_name for f in Compound._meta.get_fields() if not(f.is_relation)}
        for sort_by_option_id in self.sort_by_option_ids:
            if sort_by_option_id == 'pubs':
                name = 'Number of publications'
            elif sort_by_option_id == 'le':
                name = 'Ligand Efficiency'
            elif sort_by_option_id == 'lle':
                name = 'Lipophilic Efficiency'
            elif sort_by_option_id == 'best_activity':
                name = 'Best Activity'
            else:
                name = compound_fields.get(sort_by_option_id)
            self.sort_by_options[sort_by_option_id] = {'name': name, 'order':'ascending', 'id': sort_by_option_id}
            self.sort_by_options['-'+sort_by_option_id] = {'name': name, 'order':'descending', 'id': sort_by_option_id}
        if 'similar_to' in self.request.GET:
            self.sort_by_options['tanimoto'] = {'name': 'Tanimoto similarity', 'order':'ascending', 'id': 'tanimoto'}
            self.sort_by_options['-tanimoto'] = {'name': 'Tanimoto similarity', 'order':'descending', 'id': 'tanimoto'}
        default_sort = '-tanimoto' if 'similar_to' in self.request.GET else 'id'
        self.sort_by = self.request.GET.get('sort_by', default_sort)
        if self.sort_by not in self.sort_by_options.keys():
            self.sort_by = 'id'
        return self.sort_by

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        # process display configuration
        display = self.request.GET.get('display')
        if display not in ['l', 't']:
            display = 'v'
        context['display']=display
        # displayed fields in "table" mode
        fields = self.request.GET.getlist('fields', self.table_view_default_fields.copy())
        if 'id' not in fields:
            fields.append('id')
        if 'similar_to' in self.request.GET:
            fields.append('tanimoto')
        context['fields'] = fields
        # filters
        context.update(self.filter_context)
        context['sort_by'] = self.sort_by
        context['sort_by_options'] = self.sort_by_options
        # return context
        return context

    def get_queryset(self):
        self.filter_context = {}
        # get queryset
        qs = super().get_queryset()
        # add filters
        cfhs = [\
            CompoundListFilterHandler(PpiFamily, 'compoundaction__ppi__family', 'ppi__compoundaction__compound', 'family', self.filter_context, self.request.GET),
            CompoundListFilterHandler(Ppi, 'compoundaction__ppi', 'compoundaction__compound', 'ppi', self.filter_context, self.request.GET),
            CompoundListFilterHandler(Disease, 'compoundaction__ppi__diseases', 'ppi__compoundaction__compound', 'disease', self.filter_context, self.request.GET),
            CompoundListFilterHandler(Taxonomy, 'compoundaction__ppi_id__ppicomplex__complex__protein__organism', 'protein__proteindomaincomplex__ppicomplex__ppi__compoundaction__compound', 'taxonomy', self.filter_context, self.request.GET),
            CompoundListFilterHandler(ProteinDomainBoundComplex, 'compoundaction__ppi_id__ppicomplex__complex', 'ppicomplex__ppi__compoundaction__compound', 'boundcomplex', self.filter_context, self.request.GET),
            CompoundRangeFilterHandler('molecular_weight', self.filter_context, self.request.GET, 50),
            CompoundRangeFilterHandler('a_log_p', self.filter_context, self.request.GET),
            CompoundRangeFilterHandler('nb_donor_h', self.filter_context, self.request.GET),
            CompoundRangeFilterHandler('nb_acceptor_h', self.filter_context, self.request.GET),
            CompoundRangeFilterHandler('tpsa', self.filter_context, self.request.GET, 50),
            CompoundRangeFilterHandler('nb_rotatable_bonds', self.filter_context, self.request.GET),
            CompoundRangeFilterHandler('nb_aromatic_sssr', self.filter_context, self.request.GET),
            CompoundRangeFilterHandler('nb_chiral_centers', self.filter_context, self.request.GET),
            CompoundRangeFilterHandler('fsp3', self.filter_context, self.request.GET, 0.1),
            CompoundRangeFilterHandler('pubs', self.filter_context, self.request.GET),
            CompoundRangeFilterHandler('best_activity', self.filter_context, self.request.GET),
            CompoundRangeFilterHandler('le', self.filter_context, self.request.GET, 0.1),
            CompoundRangeFilterHandler('lle', self.filter_context, self.request.GET),
            ExistsFilterHandler('pubchem_id', self.filter_context, self.request.GET),
            ExistsFilterHandler('chemspider_id', self.filter_context, self.request.GET),
            ExistsFilterHandler('chembl_id', self.filter_context, self.request.GET),
            CompoundSimilarityFilterHandler('similar_to', self.filter_context, self.request.GET),
            TextSearchFilterHandler('q', self.filter_context, self.request.GET),
        ]
        for cfh in cfhs:
            qs = cfh.process(qs)
        # post filter filters
        if self.filter_context:
            # compound ids in the final selection if a selection has happened
            cids = [c for c in qs.all().values_list('id', flat=True)]
        else:
            cids = None
        for cfh in cfhs:
            cfh.post_process(cids, qs)
        # return queryset
        return qs


def compound_card(request, compound_id):
    try:
        compound = Compound.objects.get(id=int(compound_id))
    except Compound.DoesNotExist:
        raise Http404("No compound data for %s:%s" % (compound_id))
    le_lle_biplot_data = LeLleBiplotData.objects.get().le_lle_biplot_data
    pca_biplot = json.loads(PcaBiplotData.objects.get().pca_biplot_data)
    pca_biplot_data = json.dumps(pca_biplot['data'])
    pca_biplot_cc = pca_biplot['correlation_circle']
    return render(request, 'compound_card.html', {'compound': compound, 'le_lle_biplot_data': le_lle_biplot_data, 'pca_biplot_data': pca_biplot_data, 'pca_biplot_cc': pca_biplot_cc})

class CompoundCardBDCHEMRedirectView(RedirectView):

    def get_redirect_url(self, *args, **kwargs):
        kwargs['compound_id'] = str(int(kwargs['compound_id']))
        return reverse('compound_card', kwargs=kwargs)

def convert_mol2smi(request):
    mol_string = request.GET.get('molString')
    smiles_string = mol2smi(mol_string)
    resp = {'smiles': smiles_string}
    return JsonResponse(resp)

def convert_smi2mol(request):
    smi_string = request.GET.get('smiString')
    mol_string = smi2mol(smi_string)
    resp = {'mol': mol_string}
    return JsonResponse(resp)