1 from django.conf import settings

     2 from django.contrib.auth.decorators import login_required

     3 from django.contrib.auth.models import User, Group

     4 from django.core.cache import cache

     5 from django.core.urlresolvers import reverse

     6 from django.core.paginator import Paginator, InvalidPage, EmptyPage

     7 from django.db.models import Q

     8 from django.forms.models import model_to_dict

     9 from django.forms.util import ErrorList

    10 from django.http import (HttpResponse, HttpResponseRedirect,

    11     HttpResponseForbidden, HttpResponseServerError)

    12 from ldt.indexation import get_results_with_context, highlight_documents

    13 from django.shortcuts import (render_to_response, get_object_or_404,

    14     get_list_or_404)

    15 from django.template import RequestContext

    16 from django.template.loader import render_to_string

    17 from django.utils import simplejson

    18 from django.utils.html import escape

    19 from django.utils.translation import ugettext as _, ungettext

    20 from ldt.ldt_utils.forms import (LdtAddForm, SearchForm, AddProjectForm, CopyProjectForm,

    21     ContentForm, MediaForm, GroupAddForm)

    22 from guardian.shortcuts import remove_perm, get_objects_for_group, get_objects_for_user

    23 from ldt.ldt_utils.models import Content, Media, Project

    24 from ldt.ldt_utils.utils import boolean_convert, LdtUtils, LdtSearch

    25 from ldt.security.utils import (assign_perm_to_obj, set_forbidden_stream, 

    26     add_change_attr, get_userlist, get_userlist_model, get_userlist_group)

    27 from ldt.security.cache import get_cached_checker, cached_assign

    28 from lxml.html import fragment_fromstring

    29 #from models import Media, Project

    30 from ldt.ldt_utils.projectserializer import ProjectSerializer

    31 from urllib2 import urlparse

    32 from operator import itemgetter

    33 from itertools import groupby

    34 import base64

    35 import django.core.urlresolvers

    36 import ldt.auth as ldt_auth

    37 import ldt.utils.path as ldt_utils_path

    38 import logging

    39 import lxml.etree

    40 import mimetypes

    41 import os

    42 import urllib2

    43 import subprocess

    44 import re

    45 import datetime

    46 

    47 

    48 @login_required

    49 def get_group_projects(request):

    50 

    51     # Get group, user and project_list

    52     grp_id = request.POST["id_group"]

    53     if grp_id == "-1":

    54         project_list = get_objects_for_user(request.user, 'ldt_utils.view_project', use_groups=False).exclude(owner=request.user)

    55     else:

    56         grp = Group.objects.get(id=grp_id)

    57         everyone = Group.objects.get(name=settings.PUBLIC_GROUP_NAME)

    58         project_list = get_objects_for_group(grp, 'ldt_utils.view_project') | get_objects_for_group(everyone, 'ldt_utils.view_project').filter(owner__in=[grp])

    59     

    60     project_list = add_change_attr(request.user, project_list)

    61     

    62     is_gecko = ((request.META['HTTP_USER_AGENT'].lower().find("firefox")) > -1);

    63 

    64     return render_to_response("ldt/ldt_utils/partial/projectslist.html",

    65                               {'projects': project_list, 'show_username':True,

    66                                'is_gecko': is_gecko, 'group_id': grp_id},

    67                               context_instance=RequestContext(request))

    68 

    69 @login_required

    70 def create_group(request):

    71     if not request.user.user_permissions.filter(codename='add_group'):

    72         return HttpResponseServerError('<h1>User %s can not create a group.</h1>' % request.user.username)

    73 

    74     form_status = ''

    75     

    76     if request.method == 'POST':

    77         form = GroupAddForm(request.POST)

    78         

    79         if form.is_valid():         

    80             name = form.cleaned_data['name']

    81             members_list = form.cleaned_data['read_list']

    82             admin_list = form.cleaned_data['write_list']          

    83             

    84             group = Group.objects.create(name=name)

    85             group.save()

    86             cached_assign('is_owner_group', request.user, group)

    87             cached_assign('change_group', request.user, group)

    88             request.user.groups.add(group)             

    89 

    90             for elem in members_list:

    91                 if hasattr(elem, 'username'):

    92                     elem.groups.add(group)

    93                     if elem in admin_list:

    94                         cached_assign('change_group', elem, group)

    95                         

    96             form_status = 'saved'

    97             

    98     else:

    99         form = GroupAddForm()

   100         

   101     return render_to_response("ldt/ldt_utils/create_group.html", {'group_edition': True, 'form' : form, 'form_status' : form_status, 'elem_list' : get_userlist(request.user)}, context_instance=RequestContext(request))

   102 

   103 @login_required

   104 def update_group(request, group_id):

   105     group = get_object_or_404(Group, id=group_id)

   106     checker = get_cached_checker(request.user)

   107     

   108     if not checker.has_perm('change_group', group):

   109         form_status = 'none'

   110         return render_to_response("ldt/ldt_utils/create_group.html", {'form_status' : form_status}, context_instance=RequestContext(request))

   111 

   112     form_status = ''

   113     is_owner_group = checker.has_perm('is_owner_group', group)     

   114             

   115     if request.method == "POST":

   116         form = GroupAddForm(request.POST, instance=group)

   117         submit_action = request.REQUEST.get("submit_button", False)

   118         

   119         if submit_action == 'delete':

   120             if is_owner_group:

   121                 group.delete()

   122                 form_status = 'deleted'

   123         else:   

   124             if form.is_valid():

   125                 name = form.cleaned_data['name']

   126                 new_member_list = form.cleaned_data['read_list']

   127                 old_member_list = group.user_set.exclude(id=request.user.id)

   128                 admin_list = form.cleaned_data['write_list']

   129                 group.name = name

   130 

   131                 for user in new_member_list:

   132                     if not hasattr(user, 'username'):

   133                         raise AttributeError('new_member_list should only contain users')

   134                     if user != request.user:                      

   135                         group.user_set.add(user)

   136                         if is_owner_group:

   137                             if user in admin_list:

   138                                 cached_assign('change_group', user, group)

   139                             else:

   140                                 remove_perm('change_group', user, group)

   141                                 

   142                 for user in old_member_list:

   143                     if user not in new_member_list:

   144                         group.user_set.remove(user)

   145                         remove_perm('change_group', user, group)

   146                                         

   147                 group.save()

   148                 form_status = 'saved'                   

   149     else:

   150         form = GroupAddForm(initial={'name':unicode(group.name)})    

   151 

   152     if form_status != 'deleted':

   153         member_list, admin_list = get_userlist_group(group, request.user)

   154     else:    

   155         member_list = admin_list = []

   156         

   157     return render_to_response("ldt/ldt_utils/create_group.html", {'group_id' : group_id, 'form' : form, 'form_status' : form_status, 'group_edition': True,

   158                                                                   'elem_list' : get_userlist(request.user), 'member_list': member_list, 'admin_list': admin_list,

   159                                                                   'is_owner_group': is_owner_group}, context_instance=RequestContext(request))

   160     

   161     

   162     

   163 @login_required

   164 def groups_filter(request, filter):

   165     if filter and len(filter) > 0 and filter[0] == '_':

   166         filter = filter[1:]

   167 

   168     if filter:

   169         group_list = request.user.groups.filter(name__icontains=filter)

   170         search_active = True 

   171     else:

   172         group_list = request.user.groups.all()

   173         search_active = False

   174         

   175     group_list = group_list.exclude(name=settings.PUBLIC_GROUP_NAME)

   176     group_list = sorted(group_list.all(), key=lambda group: group.name.lower())

   177     group_list = add_change_attr(request.user, group_list)

   178     

   179     

   180     return render_to_response("ldt/ldt_utils/partial/groupslist.html",

   181                               {'groups': group_list, 'search_active': search_active},

   182                               context_instance=RequestContext(request))

   183