Mercurial Mercurial > hdabo / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
web/hdalab/views/ajax.py
changeset 208 d4e3ea751966
parent 206 7070d3acc3d4
child 212 3e1193c6dce3
equal deleted inserted replaced
207:44ddbffbfea5 208:d4e3ea751966 
    82     
    82     
    83     return HttpResponse(content=json.dumps(translations), mimetype='application/json')
 
    83     return HttpResponse(content=json.dumps(translations), mimetype='application/json')
 
    84 
    84 
    85 def subcat(category, globtags, level, max_level ):
 
    85 def subcat(category, globtags, level, max_level ):
 
    86     # recursive function used by cattree
 
    86     # recursive function used by cattree
 
    87     tags = Tag.objects.select_related('wp_categories__wp_category').filter(wp_categories__wp_category = category)
 
    87     catlabel = category.label
 
       
    88     tags = Tag.objects.filter(wp_categories__wp_category = category).distinct()
 
    88     taglabels = [k for k in dict([(t.label,t.label) for t in tags])]
 
    89     taglabels = [k for k in dict([(t.label,t.label) for t in tags])]
 
    89     catlabel = category.label
 
       
    90     resobj = {
 
    90     resobj = {
 
    91           'category': category.label,
 
    91           'category': category.label,
 
    92           'tags': [],
 
    92           'tags': [],
 
    93           'contents': []
 
    93           'contents': []
 
    94           }
 
    94           }
 
    99             tag_in_list = {'label' : label, 'contents': []}
 
    99             tag_in_list = {'label' : label, 'contents': []}
 
   100             resobj['tags'].append(tag_in_list)
 
   100             resobj['tags'].append(tag_in_list)
 
   101             globtags[label] = {'level': (level + 1), 'access': tag_in_list }
 
   101             globtags[label] = {'level': (level + 1), 'access': tag_in_list }
 
   102             
   102             
   103     if level < max_level:
 
   103     if level < max_level:
 
   104         subcats = WpCategory.objects.select_related('parent_categories__parent_category').filter(parent_categories__parent_category = category)
 
   104         subcats = WpCategory.objects.filter(parent_categories__parent_category = category)
 
   105         resobj['sub_categories'] = [subcat(subcats[i], globtags, level + 1, max_level ) for i in range(len(subcats))]
 
   105         resobj['sub_categories'] = [subcat(subcats[i], globtags, level + 1, max_level ) for i in range(len(subcats))]
 
   106     return resobj
 
   106     return resobj
 
   107 
   107 
   108 def cleantags(category):
 
   108 def cleantags(category):
 
   109     if category.has_key('contents') and len(category['contents']) == 0:
 
   109     if category.has_key('contents') and len(category['contents']) == 0:
 
   110         del category['contents']
 
   110         del category['contents']
 
       
   111     if category.has_key('contents'):
 
       
   112         category['contents'] = sorted(category['contents'], key=lambda content: -content['score'])
 
   111     if category.has_key('tags'):
 
   113     if category.has_key('tags'):
 
   112         category['tags'] = [tag for tag in category['tags'] if len(tag['contents'])]
 
   114         category['tags'] = [cleantags(tag) for tag in category['tags'] if len(tag['contents'])]
 
   113         if len(category['tags']) == 0:
 
   115         if len(category['tags']) == 0:
 
   114             del category['tags']
 
   116             del category['tags']
 
       
   117         else:
 
       
   118             category['tags'] = sorted(category['tags'], key=lambda tag: tag['label'])
 
   115     if category.has_key('sub_categories'):
 
   119     if category.has_key('sub_categories'):
 
   116         sub_cats = []
 
   120         sub_cats = []
 
   117         for sub_cat in category['sub_categories']:
 
   121         for sub_cat in category['sub_categories']:
 
   118             cat = cleantags(sub_cat)
 
   122             cat = cleantags(sub_cat)
 
   119             if cat.has_key('tags') or cat.has_key('sub_categories') or cat.has_key('contents'):
 
   123             if cat.has_key('tags') or cat.has_key('sub_categories') or cat.has_key('contents'):
 
   120                 sub_cats.append(cat)
 
   124                 sub_cats.append(cat)
 
   121         category['sub_categories'] = sub_cats
 
   125         category['sub_categories'] = sorted(sub_cats, key=lambda cat: cat['category'])
 
   122         if len(category['sub_categories']) == 0:
 
   126         if len(category['sub_categories']) == 0:
 
   123             del category['sub_categories']
 
   127             del category['sub_categories']
 
   124     return category
 
   128     return category
 
   125 
   129 
   126 def cattree(request):
 
   130 def cattree(request):
 
   127     # Gets the category tree from a label
 
   131     # Gets the category tree from a label
 
       
   132     ROOT_MAX_TAG_ORDER = 5
 
   128     MAX_TAG_ORDER = 5
 
   133     MAX_TAG_ORDER = 5
 
   129     MAX_LEVEL = 3
 
   134     MAX_LEVEL = 3
 
   130     label = request.GET.get('label', None)
 
   135     label = request.GET.get('label', None)
 
       
   136     lowerlabel = label.lower()
 
   131     globtags = {}
 
   137     globtags = {}
 
   132     resobj = None
 
   138     resobj = None
 
   133     master_category = WpCategory.objects.filter(label__iexact=label)[0:1]
 
   139     master_category = WpCategory.objects.filter(label__iexact=label)[0:1]
 
   134     if len(master_category):
 
   140     if len(master_category):
 
   135         resobj = subcat(master_category[0], globtags, 1, MAX_LEVEL )
 
   141         resobj = subcat(master_category[0], globtags, 1, MAX_LEVEL )
 
   136     
   142     
   137     tag_list = [k for k in globtags]
 
   143 #    tag_list = [k for k in globtags]
 
   138     
   144     
   139     if len(tag_list):
 
   145 #    if len(tag_list):
 
   140         contents = []
 
   146     contents = []
 
   141         datasheets = Datasheet.objects.select_related('taggedsheet__tag').filter(validated = True, taggedsheet__tag__label__in = tag_list, taggedsheet__order__lte = MAX_TAG_ORDER).distinct()
 
   147 #    datasheets = Datasheet.objects.filter(validated = True, taggedsheet__tag__label__in = tag_list, taggedsheet__order__lte = MAX_TAG_ORDER).distinct()
 
   142         for datasheet in datasheets:
 
   148     datasheets = Datasheet.objects.filter(validated = True, taggedsheet__tag__label__iexact = label, taggedsheet__order__lte = ROOT_MAX_TAG_ORDER).distinct()
 
   143             # Calculating where we add the datasheet in the tree
 
   149     for datasheet in datasheets:
 
   144             maintag = None
 
   150         # Calculating where we add the datasheet in the tree
 
   145             maintagscore = -5
 
   151         maintag = None
 
   146             for ts in TaggedSheet.objects.select_related('tag','datasheet').filter(datasheet__id=datasheet.id,order__lte=MAX_TAG_ORDER):
 
   152         maintagscore = -5
 
   147                 label = ts.tag.label
 
   153         dsscore = 0
 
   148                 if globtags.has_key(label):
 
   154         rootscore = 0
 
   149                     score = 3 * globtags[label]['level'] - ts.order
 
   155         for ts in TaggedSheet.objects.select_related('tag','datasheet').filter(datasheet__id=datasheet.id,order__lte=MAX_TAG_ORDER):
 
   150                     if score > maintagscore:
 
   156             label = ts.tag.label
 
   151                         maintagscore = score
 
   157             if globtags.has_key(label):
 
   152                         maintag = label
 
   158                 score = 3 * globtags[label]['level'] - ts.order
 
   153             if maintag is not None:
 
   159                 if score > maintagscore:
 
   154                 globtags[maintag]['access']['contents'].append({'id': datasheet.id, 'title': datasheet.title, 'url': datasheet.url})
 
   160                     maintagscore = score
 
   155         cleantags(resobj)
 
   161                     maintag = label
 
       
   162                     dsscore = (MAX_TAG_ORDER - ts.order)
 
       
   163                 if label.lower() == lowerlabel:
 
       
   164                     rootscore = (ROOT_MAX_TAG_ORDER - ts.order)
 
       
   165         if maintag is not None:
 
       
   166             globtags[maintag]['access']['contents'].append({'id': datasheet.id, 'title': datasheet.title, 'url': datasheet.url, 'score': (dsscore + rootscore)})
 
       
   167     cleantags(resobj)
 
   156                     
   168                     
   157 #        resobj['contents'] = [{'id': d.id, 'title': d.title, 'tags': [t.label for t in d.tags.filter(taggedsheet__order__lte=5)]} for d in datasheets]
 
   169 #        resobj['contents'] = [{'id': d.id, 'title': d.title, 'tags': [t.label for t in d.tags.filter(taggedsheet__order__lte=5)]} for d in datasheets]
 
   158     
   170     
   159     return HttpResponse(content=json.dumps(resobj), mimetype='application/json')
 
   171     return HttpResponse(content=json.dumps(resobj), mimetype='application/json')
 
   160 
   172 
   228 
   240 
   229 def catsearch(request):
 
   241 def catsearch(request):
 
   230     
   242     
   231     q = request.GET.get('term',None)
 
   243     q = request.GET.get('term',None)
 
   232     
   244     
   233     qs = WpCategory.objects.filter(tags__hidden = False).distinct().filter(Q(label__icontains = ' ' + q ) | Q(label__istartswith = q))
 
   245     # On ne récupère que les catégories qui sont également des tags
 
   234 
   246     
   235 #    qs = WpCategory.objects.filter(label__istartswith = q).order_by('label')[:40]
 
   247     qs = Tag.objects.filter(Q(label__icontains = ' ' + q ) | Q(label__istartswith = q))
 
       
   248     
       
   249     labels = [tag.label for tag in qs]
 
       
   250     
       
   251     qs = WpCategory.objects.filter(label__in = labels)
 
   236     
   252     
   237     res = [{'value':t.label} for t in qs]
 
   253     res = [{'value':t.label} for t in qs]
 
   238     
       
   239 #    qs = WpCategory.objects.filter(label__icontains = ' ' + q).order_by('label')[:30]        
       
   240 #    res += [{'value':t.label} for t in qs]
 
       
   241     
   254     
   242     return HttpResponse(content=json.dumps(res), mimetype='application/json')
 
   255     return HttpResponse(content=json.dumps(res), mimetype='application/json')
 
   243 
   256 
   244 def filter(request):
 
   257 def filter(request):
 
   245     
   258
hdabo