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

     2 '''

     3 Created on Jan 31, 2012

     4 

     5 @author: ymh

     6 '''

     7 from django.conf import settings

     8 from django.db import connection

     9 from django.db.models import Q, Count, Sum

    10 from django.http import HttpResponse

    11 from hdabo.models import Tag, Datasheet, TaggedSheet

    12 from hdalab.models import TagLinks, HdaSession, CountryCode, TagYears

    13 import django.utils.simplejson as json

    14 import hmac

    15 import uuid

    16 

    17 def taginfo(request):

    18     label = request.GET.get('label', None)

    19     

    20     resobj = {'requested_label' : label}

    21         

    22     resobj["content_count"] = Datasheet.objects.filter(taggedsheet__tag__label__iexact = label).distinct().count()

    23     

    24     res = Tag.objects.select_related('dbpedia_fields').filter(label__iexact = label).order_by('-dbpedia_uri')[0:1]

    25     if len(res) == 1:

    26         restag = res.get()

    27         resobj["dbpedia_uri"] = restag.dbpedia_uri

    28         if resobj["dbpedia_uri"] is not None and restag.dbpedia_fields is not None:

    29             dbfield = restag.dbpedia_fields

    30             resobj["abstract"] = dbfield.abstract

    31             resobj["dbpedia_label"] = dbfield.label

    32             resobj["thumbnail"] = dbfield.thumbnail

    33     res = Tag.objects.filter(label__iexact = label).order_by('-wikipedia_url')[0:1]

    34     if len(res) == 1:

    35         resobj["wikipedia_url"] = res.get().wikipedia_url

    36         

    37     resobj["links"] = [{'subject':tl.subject.label, 'object':tl.object.label} for tl in TagLinks.objects.select_related().filter(Q(subject__label__iexact = label) | Q(object__label__iexact = label))]

    38 

    39     return HttpResponse(content=json.dumps(resobj), mimetype='application/json')

    40 

    41 

    42 def sessioninfo(request):

    43     

    44     data = json.loads(request.GET.get('data', "{}"))

    45     write = False

    46     

    47     if 'sessionid' in request.GET:

    48         request.session['sessionid'] = request.GET['sessionid']

    49     if 'sessionkey' in request.GET:

    50         request.session['sessionkey'] = request.GET['sessionkey']

    51         

    52     if 'sessionid' in request.session:

    53         sessionid = request.session['sessionid']

    54         

    55         if HdaSession.objects.filter(sessionid=sessionid).count() == 1:

    56             sessionkey = request.session.get('sessionkey',None)

    57             hm = hmac.new(settings.SECRET_KEY, sessionid)

    58             if hm.hexdigest() == sessionkey:

    59                 write = True            

    60         else:

    61             del request.session['sessionid']

    62         

    63     if 'sessionid' not in request.session:

    64         sessionid = unicode(uuid.uuid1())

    65         HdaSession.objects.create(sessionid=sessionid, data=json.dumps({}))

    66         write = True

    67         request.session['sessionid'] = sessionid

    68         request.session['sessionkey'] = hmac.new(settings.SECRET_KEY, sessionid).hexdigest()

    69         

    70     if write and data:

    71         HdaSession.objects.filter(sessionid=sessionid).update(data=json.dumps(data))

    72     else:

    73         data = HdaSession.objects.get(sessionid=sessionid).data

    74         data = json.loads(data) if data else {}           

    75          

    76     resobj = {'data': data, "write_allowed" : write, "sessionid": sessionid }

    77     if write:

    78         resobj['sessionkey'] = request.session['sessionkey']

    79         

    80     return HttpResponse(content=json.dumps(resobj), mimetype='application/json')

    81 

    82 

    83 def tagsearch(request):

    84     

    85     q = request.GET.get('term',None)

    86     qs = Tag.objects.filter(label__icontains = q) if q else Tag.objects.all()        

    87     res = qs.annotate(nb=Count('datasheet')).order_by('-nb')[:20]

    88     

    89     return HttpResponse(content=json.dumps([{'label':t.label,'nb':t.nb} for t in res]), mimetype='application/json')

    90 

    91 

    92 def filter(request):

    93     periode = request.GET.get('period',None)

    94     label = request.GET.get('label', None)

    95     contentlist = request.GET.get('contentlist', None)

    96     max_tag_order = request.GET.get('mto', 12)

    97     content_count = request.GET.get('contentcount', 12)

    98     tag_count = request.GET.get('tagcount', 30)

    99     cont_count = 0;

   100     contenus = {}

   101 

   102 

   103     if label or periode or contentlist :

   104         

   105         qs = Datasheet.objects.filter(validated=True)

   106         

   107         #$globalsql = "SELECT id, title, description, url FROM hdabo_datasheet E";

   108 

   109         globalids = []

   110         #$globalfilters = array();

   111         

   112         if periode:

   113             years = periode.split(",")

   114             start_year = int(years[0])

   115             end_year = int(years[0:2][-1])

   116             delta = max(1, (end_year-start_year)/2)

   117             minstart = start_year - delta;

   118             maxend = end_year + delta;

   119             

   120             tagqs = Tag.objects.filter(years__end_year__gte = start_year, 

   121                                        years__start_year__lte = end_year,

   122                                        years__end_year__lte = maxend,

   123                                        years__start_year__gte = minstart)

   124             

   125             globalids += [t.id for t in tagqs]

   126             

   127             qs = qs.filter(taggedsheet__tag__in = tagqs) 

   128             

   129         if label:

   130             for txtlbl in label.split(","):

   131                 taglblqs = Tag.objects.filter(label__iexact = txtlbl)

   132                 globalids += [t.id for t in taglblqs if t.id not in globalids]

   133                 qs = qs.filter(taggedsheet__tag__in = taglblqs)

   134 

   135         if label or periode:

   136             qs = qs.filter(taggedsheet__order__lte = max_tag_order)

   137 

   138         if contentlist:

   139             qs = qs.filter(id__in = contentlist.split(","))

   140         

   141         if contentlist is None:

   142             qs = qs.order_by('?')

   143         

   144         

   145         for content in qs:

   146             cont_count += 1

   147             contenus[content.id] = {'score' : 0, 'tags' : [], 'id':content.id, 'title': content.title, 'description': content.description, 'url': content.url}

   148 

   149 

   150         countries = dict([ (cc.label, {'isocode':cc.isocode, 'score':0}) for cc in CountryCode.objects.all() ])

   151         disciplines = dict([ (d.label, {'label':d.label, 'score':0}) for d in Tag.objects.filter(category__label = "Discipline artistique")])

   152         

   153         tags = {}

   154         

   155         contentids = contenus.keys()

   156         qs = TaggedSheet.objects.select_related('tag').filter(datasheet__in = contentids, order__lte = max_tag_order).order_by('order')

   157         for ts in qs:

   158             match_tag = ts.tag.id in globalids

   159             contenus[ts.datasheet.id]['tags'].append({'id': ts.tag.id, 'label':ts.tag.label, 'order':ts.order, 'match': match_tag})

   160             tagscore = 2*max_tag_order - ts.order

   161             if ts.tag.id not in tags:

   162                 tags[ts.tag.id] = {'id':ts.tag.id,'label':ts.tag.label, 'score':0}

   163             tags[ts.tag.id]['score'] += tagscore

   164             if match_tag:

   165                 contenus[ts.datasheet.id]['score'] += tagscore

   166                 tags[ts.tag.id]['match'] = True

   167             if ts.tag.label in countries:

   168                 countries[ts.tag.label]['score'] += tagscore

   169             if ts.tag.label in disciplines:

   170                 disciplines[ts.tag.label]['score'] += tagscore

   171 

   172         content_count = content_count if not contentlist else len(contenus)

   173         contenus = sorted(contenus.values(),key=lambda e: e.get('score', 0))[0:content_count]

   174         countries = countries.values()

   175         tags = sorted(tags.values(), key=lambda e: e.get('score', 0))[0:tag_count]

   176         disciplines = sorted(disciplines.values(), key=lambda e: e.get('score', 0))[0:10]

   177         years = {}

   178         if contentids:

   179             qs = TagYears.objects.values('start_year', 'end_year').annotate(order_count=Count('tag__taggedsheet'), order_sum=Sum("tag__taggedsheet__order")).filter(tag__taggedsheet__order__lte=max_tag_order, tag__taggedsheet__datasheet__in = contentids)

   180             for ty in qs:

   181                 for year in range(ty['start_year'], ty['end_year']):

   182                     years[year] = (2*max_tag_order*ty['order_count']-ty['order_sum'])/(ty['end_year']-ty['start_year']) + years[year] if year in years else 0

   183 #        $rq = pg_query("SELECT U.start_year, U.end_year, SUM(".(2*$max_tag_order)." - V.order)/(U.end_year + 1 - U.start_year) score FROM hdaviz_years U, hdabo_taggedsheet V WHERE U.tag_id = V.tag_id AND V.order <= $max_tag_order AND V.datasheet_id IN ($contentids) GROUP BY U.start_year, U.end_year");

   184 #        while($ligne = pg_fetch_row($rq)) {

   185 #            foreach(range($ligne[0], $ligne[1]) as $year) {

   186 #                $years[$year] = $ligne[2] + ( isset($years[$year]) ? $years[$year] : 0 );

   187 

   188     else:

   189         

   190         for ds in Datasheet.objects.order_by("?")[:content_count]:

   191             contenus[ds.id] = {'id':ds.id, 'title':ds.title, 'description':ds.description, 'url':ds.url, 'tags':[]}

   192         cont_count = Datasheet.objects.count()

   193         

   194         qs = TaggedSheet.objects.select_related('tag','datasheet').filter(datasheet__id__in = contenus.keys(), order__lte = max_tag_order).order_by("order").only('order','tag__label','tag__id','datasheet__id')

   195         for ts in qs:

   196             contenus[ts.datasheet.id]['tags'].append({'id': ts.tag.id, 'label':ts.tag.label, 'order':ts.order})

   197         contenus = contenus.values()

   198 

   199         cursor = connection.cursor() #@UndefinedVariable

   200         try:

   201             cursor.execute("select t.id, t.label, sum(2*%s-ts.order) as score from hdabo_tag as t join hdabo_taggedsheet as ts on t.id = ts.tag_id where ts.order < %s group by t.id, t.label order by score limit %s",[max_tag_order, max_tag_order, tag_count])

   202             tags = [{'id': t[0], 'label':t[1], 'score':t[2]} for t in cursor.fetchall()]

   203             #tags = sorted([{'id':tag.id,'label':tag.label,'score':2*max_tag_order*tag.count_score - tag.sum_score} for tag in qs], key=lambda t:t['score'])[:tag_count]                    

   204         finally:

   205             cursor.close()

   206         cursor = connection.cursor() #@UndefinedVariable

   207         try:

   208             cursor.execute("select c.isocode as isocode, sum(2*%s-ts.order) as score from hdabo_tag as t join hdabo_taggedsheet as ts on t.id = ts.tag_id join hdalab_countrycode as c on t.label = c.label group by c.isocode", [max_tag_order])

   209             countries = [{'isocode': r[0], 'score':r[1]} for r in cursor.fetchall()]

   210             

   211         finally:

   212             cursor.close()

   213 

   214         qs = Tag.objects.annotate(count_score=Count('taggedsheet'),sum_score=Sum('taggedsheet__order')).filter(taggedsheet__order__lte = max_tag_order, category__label__iexact = u"Discipline")

   215         disciplines = sorted([{'label':tag.label,'score':2*max_tag_order*tag.count_score - tag.sum_score} for tag in qs], key=lambda t:t.score, reverse=True)[:10]

   216 

   217         years = {}

   218         qs = TagYears.objects.values('start_year', 'end_year').annotate(order_count=Count('tag__taggedsheet'), order_sum=Sum("tag__taggedsheet__order")).filter(tag__taggedsheet__order__lte=max_tag_order)

   219         for ty in qs:

   220             for year in range(ty['start_year'], ty['end_year']):

   221                 years[year] = (2*max_tag_order*ty['order_count']-ty['order_sum'])/(ty['end_year']-ty['start_year']) + years[year] if year in years else 0

   222 

   223     yearchange = []

   224     for year in sorted(years.keys()):

   225         score = years[year]

   226         if year < 2011:

   227             if year-1 not in years or years[year-1] != score:

   228                 yearchange.append({'year': year, 'score': score})

   229             if year+1 not in years and year != -1:

   230                 yearchange.append({'year': year+1, 'score': 0})

   231 

   232     output = {'count': cont_count, 'contents': contenus, 'tags':tags, 'sparkline':yearchange, 'countries':countries, 'disciplines':disciplines}

   233     

   234     return HttpResponse(content=json.dumps(output), mimetype='application/json')