Ejemplo n.º 1
0
def getSimilarByKeywords(material_id, version):
    """Returns list of similar materials getting by comparing keywords"""

    # why possibly version gets nothing as value?
    if not version:
        version = models.getMaterialLatestVersion(material_id)

    try:
        weight_list = {}
        material = models.Material.objects.filter(
            material_id=material_id, 
            version=version).values('keywords')[0]

        # build the keyword query
        keywords = material.get('keywords', '')
        keywords = keywords.split('\n')
        for kw in keywords:
            objs = models.Material.objects.exclude(material_id=material_id).\
                filter(keywords__contains=kw).values('material_id', 'title')
            m_list = [(item['material_id'], item['title']) for item in objs]
            for m_item in m_list:
                mid = m_item[0]
                if not weight_list.has_key(mid):
                    item_dict = {'material_id': m_item[0], 'title': m_item[1]}
                    weight_list[mid] = [0, item_dict]
                weight_list[mid][0] += SM_WEIGHT_KEYWORD 
        
        # sort by weights then limit the results
        couples = weight_list.values()
        couples.sort(reverse=True)
        result = [item[1] for item in couples[:10]]
    except:
        raise404(request, 404)
    return result
Ejemplo n.º 2
0
 def get_object(self, mfid, version='', request=None):
     """ Customized get_object() function, used for Material objects
         which will be get by ID and version.
     """
     try:
         object = self.model.objects.get(id=mfid)
         return object 
     except:
         raise404(request, 404)
Ejemplo n.º 3
0
 def destroy(self, request, *args, **kwargs):
     """ Delete the material """
     if request.META.get('HTTP_VOER', None) != '1':
         ret_code = 400
     else:  
         try:
             res = models.deleteMaterial(
                 kwargs.get('mid'), 
                 kwargs.get('version'))
             if res:
                 ret_code = status.HTTP_200_SUCCESS
             else:
                 ret_code = status.HTTP_204_NO_CONTENT
         except:
             raise404(request)
     return Response(status=ret_code)
Ejemplo n.º 4
0
 def get_object(self, material_id, version='', request=None):
     """ Customized get_object() function, used for Material objects
         which will be get by ID and version.
     """
     try:
         args = {'material_id':material_id}
         # get latest or specific version
         object = self.model.objects
         if version:
             args['version'] = version
             object = object.get(**args)
         else:
             object = models.getLatestMaterial(material_id)
         return object 
     except:
         raise404(request, 404)
Ejemplo n.º 5
0
    def put(self, request, *args, **kwargs):
        """ Check in a material  """
        try: 
            serializer = self.get_serializer(data=request.DATA)
            response = None
            if serializer.is_valid():

                # check if valid editor or new material will be created
                sobj = serializer.object
                sobj.material_id = material_id = kwargs['mid']

                # special update or checkin?
                if request.GET.get('magic-update', None):
                    sobj.version = current_version = int(kwargs['version'])
                    res = models.deleteMaterial(material_id, current_version)
                    if not res:
                        raise   # 404
                else:
                    last_version = models.getMaterialLatestVersion(sobj.material_id)
                    try:
                        sobj.version = last_version + 1
                    except AttributeError:
                        sobj.version = 1
                        
                self.pre_save(sobj)
                self.object = serializer.save()

                # update the person and roles
                models.setMaterialPersons(self.object.id, request.DATA)

                # add the attached image manually
                self.object.image = request.FILES.get('image', None)
                self.object.save()

                # next, add all other files submitted
                material_id = self.object.material_id
                material_version = self.object.version 
                for key in request.FILES.keys():
                    if key == 'image': continue
                    mfile = models.MaterialFile()
                    mfile.material_id = material_id 
                    mfile.version = material_version
                    file_content = request.FILES.get(key, None)
                    mfile.mfile = file_content 
                    mfile.name = request.FILES[key].name
                    mfile.description = request.DATA.get(key+'_description', '')
                    mfile.mime_type = mimetypes.guess_type(
                        os.path.realpath(mfile.mfile.name))[0] or ''
                    mfile.save()

                # (module/collection) create the zip package and post to vpt
                try:
                    if not request.DATA.get('export-later', 0):
                        requestMaterialPDF(self.object)
                except:
                    pass

                response = Response(serializer.data, status=status.HTTP_201_CREATED)
            else:
                response = Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)            

            return response
        except: 
            raise404(request)
Ejemplo n.º 6
0
    def list(self, request, *args, **kwargs):
        """ Customized function for listing materials with same ID
        """
        # in case of listing all version of specific material
        material_id = kwargs.get('mid', None)

        # caching
        query_st = request.GET.urlencode() or material_id or 'all'
        cache_key = 'list-materials:' + query_st
        result = cache.get(cache_key)

        if result:
            sr_data = eval(result)
        else:
            try: 
                # show all versions of specific material
                if material_id: 
                    self.object_list = self.model.objects.filter(
                        material_id=material_id
                        )
                else:
                    # get the or criterias
                    or_crits = getOrFields(request)

                    self.object_list = self.model.objects
                    # filter by person roles
                    mp_objs = models.MaterialPerson.objects
                    mp_list = []
                    role_in_query = False
                    for role in settings.VPR_MATERIAL_ROLES:
                        role_id = settings.VPR_MATERIAL_ROLES.index(role)
                        if request.GET.get(role, ''):
                            query = request.GET.get(role, '').split(',')
                            query = [int(pid) for pid in query]
                            mp_list.extend(mp_objs.filter(role=role_id, person_id__in=query))
                            role_in_query = True
                    allow_materials = []
                    for mp in mp_list:
                        if mp.material_rid not in allow_materials:
                            allow_materials.append(int(mp.material_rid))

                    # do the filtering
                    browse_on = {}
                    fields = [item for item in request.GET if item in self.br_fields]
                    [browse_on.update({item:request.GET[item]}) for item in fields]
                    if role_in_query:
                        browse_on['pk__in'] = allow_materials
                    self.object_list = self.object_list.filter(**browse_on)

                    # custom fileting with categories 
                    self.object_list = queryCategory(
                        request,
                        self.object_list,
                        'categories' in or_crits
                        )

                    # continue with sorting
                    sort_fields = request.GET.get('sort_on', '')
                    if sort_fields:
                        #import pdb;pdb.set_trace()
                        self.object_list = self.object_list.order_by(sort_fields)
            except:
                raise404(request) 

            # Default is to allow empty querysets.  This can be altered by setting
            # `.allow_empty = False`, to raise 404 errors on empty querysets.
            allow_empty = self.get_allow_empty()
            if not allow_empty and len(self.object_list) == 0:
                error_args = {'class_name': self.__class__.__name__}
                raise404(request, self.empty_error % error_args)

            # Pagination size is set by the `.paginate_by` attribute,
            # which may be `None` to disable pagination.
            page_size = self.get_paginate_by(self.object_list)
            if page_size:
                packed = self.paginate_queryset(self.object_list, page_size)
                paginator, page, queryset, is_paginated = packed
                serializer = self.get_pagination_serializer(page)
            else:
                serializer = self.get_serializer(self.object_list)

            # silly steps: remove heavy data from response
            try:
                for res in range(len(serializer.data['results'])):
                    material = serializer.data['results'][res]
                    material['text'] = ''
                    if request.GET.get('names', None):
                        # add the category names
                        cats = []
                        for mc in material['categories']:
                            cats.append([mc, models.getCategoryName(mc)])
                        material['categories'] = cats
                        # .. and the person names
                        for role in settings.VPR_MATERIAL_ROLES:
                            if material.has_key(role):
                                persons = []
                                pids = [int(pid) for pid in material[role].split(',')]
                                for pc in pids:
                                    persons.append([pid, models.getPersonName(pid)])
                                material[role] = persons
                    serializer.data['results'][res] = material

            except:
                # should we shout anything?
                pass

            # setting cache
            sr_data = serializer.data
            for mi in sr_data['results']:
                mi['modified'] = str(mi['modified'])
            cache.set(cache_key, str(sr_data), CACHE_TIMEOUT_MATERIAL)

        return Response(sr_data)