Changeset 337 in main


Ignore:
Timestamp:
09/27/11 11:13:57 (8 years ago)
Author:
pcosquer
Message:

add GroupController? and refactor other controllers

Location:
trunk/openPLM
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/openPLM/plmapp/base_views.py

    r333 r337  
    3939from django.utils.translation import ugettext as _ 
    4040from django.http import HttpResponse 
    41 from django.contrib.auth.models import User 
     41from django.contrib.auth.models import User, Group 
    4242from django.shortcuts import render_to_response 
    4343from django.http import HttpResponseServerError, Http404 
     
    4848        DocumentController 
    4949from openPLM.plmapp.controllers.user import UserController 
     50from openPLM.plmapp.controllers.group import GroupController 
    5051from openPLM.plmapp.exceptions import ControllerError 
    5152from openPLM.plmapp.navigate import NavigationGraph 
     
    6869        obj = get_object_or_404(User, username=obj_ref) 
    6970        controller_cls = UserController 
     71    elif obj_type == 'Group': 
     72        obj = get_object_or_404(Group, name=obj_ref) 
     73        controller_cls = GroupController 
    7074    else: 
    7175        obj = get_object_or_404(models.PLMObject, type=obj_type, 
     
    159163        reference = form.cleaned_data["username"] 
    160164        revision = "-" 
     165    elif type_ == "Group": 
     166        reference = form.cleaned_data["name"] 
     167        revision = "-" 
    161168    else: 
    162169        reference = form.cleaned_data["reference"] 
     
    317324    if hasattr(selected_object, "menu_items"): 
    318325        ctx['object_menu'] = selected_object.menu_items 
    319     if isinstance(selected_object, PLMObjectController): 
     326    if hasattr(selected_object, "check_permission"): 
    320327        ctx["is_owner"] = selected_object.check_permission("owner", False) 
    321328    return selected_object, ctx, request_dict.session 
  • trunk/openPLM/plmapp/controllers/__init__.py

    r336 r337  
    152152 
    153153from openPLM.plmapp.controllers.user import UserController 
     154from openPLM.plmapp.controllers.group import GroupController 
    154155 
  • trunk/openPLM/plmapp/controllers/base.py

    r336 r337  
    2727 
    2828import re 
     29from functools import wraps 
     30 
     31from django.db.models.fields import FieldDoesNotExist 
    2932 
    3033import openPLM.plmapp.models as models 
     34from openPLM.plmapp.exceptions import PermissionError 
    3135 
    3236_controller_rx = re.compile(r"(?P<type>\w+)Controller") 
     
    8286get_controller = MetaController.get_controller 
    8387 
     88def permission_required(func=None, role="owner"): 
     89    """ 
     90    Decorator for methods of :class:`PLMObjectController` which 
     91    raises :exc:`.PermissionError` if :attr:`PLMObjectController._user` 
     92    has not the role *role* 
     93    """ 
     94 
     95    def decorator(f): 
     96        @wraps(f) 
     97        def wrapper(*args, **kwargs): 
     98            args[0].check_permission(role) 
     99            return f(*args, **kwargs) 
     100        wrapper.__doc__ = "Permission required: `%s`\n%s" % (role, wrapper.__doc__) 
     101        return wrapper 
     102    if func: 
     103        return decorator(func) 
     104    return decorator 
     105 
     106class Controller(object): 
     107    u""" 
     108    Object used to manage a :class:`~plmapp.models.PLMObject` and store his  
     109    modification in an history 
     110     
     111    :attributes: 
     112        .. attribute:: object 
     113 
     114            The :class:`.PLMObject` managed by the controller 
     115        .. attribute:: _user 
     116 
     117            :class:`~django.contrib.auth.models.User` who modifies ``object`` 
     118 
     119    :param obj: managed object 
     120    :type obj: a subinstance of :class:`.PLMObject` 
     121    :param user: user who modifies *obj* 
     122    :type user: :class:`~django.contrib.auth.models.User` 
     123    """ 
     124 
     125    __metaclass__ = MetaController 
     126 
     127    HISTORY = models.AbstractHistory 
     128 
     129    def __init__(self, obj, user): 
     130        self.object = obj 
     131        self._user = user 
     132        # variable to store attribute changes 
     133        self._histo = "" 
     134        # cache for permissions (dict(role->bool))  
     135        self.__permissions = {} 
     136 
     137    def __setattr__(self, attr, value): 
     138        # we override this method to make it to modify *object* directly 
     139        # if we modify *object*, we records the modification in **_histo* 
     140        if hasattr(self, "object") and hasattr(self.object, attr) and \ 
     141           not attr in self.__dict__: 
     142            old_value = getattr(self.object, attr) 
     143            setattr(self.object, attr, value) 
     144            field = self.object._meta.get_field(attr).verbose_name.capitalize() 
     145            if old_value != value: 
     146                message = "%(field)s : changes from '%(old)s' to '%(new)s'" % \ 
     147                        {"field" : field, "old" : old_value, "new" : value} 
     148                self._histo += message + "\n" 
     149        else: 
     150            super(Controller, self).__setattr__(attr, value) 
     151 
     152    def __getattr__(self, attr): 
     153        # we override this method to get attributes from *object* directly 
     154        obj = object.__getattribute__(self, "object") 
     155        if hasattr(self, "object") and hasattr(obj, attr) and \ 
     156           not attr in self.__dict__: 
     157            return getattr(obj, attr) 
     158        else: 
     159            return object.__getattribute__(self, attr) 
     160 
     161    def save(self, with_history=True): 
     162        u""" 
     163        Saves :attr:`object` and records its history in the database. 
     164        If *with_history* is False, the history is not recorded. 
     165        """ 
     166        self.object.save() 
     167        self.group_info.save() 
     168        if self._histo and with_history: 
     169            self._save_histo("Modify", self._histo)  
     170            self._histo = "" 
     171 
     172    def _save_histo(self, action, details): 
     173        """ 
     174        Records *action* with details *details* made by :attr:`_user` in 
     175        on :attr:`object` in the user histories table. 
     176        """ 
     177        self.HISTORY.objects.create(plmobject=self.object, action=action, 
     178                                     details=details, user=self._user) 
     179 
     180    def get_verbose_name(self, attr_name): 
     181        """ 
     182        Returns a verbose name for *attr_name*. 
     183 
     184        Example:: 
     185 
     186            >>> ctrl.get_verbose_name("ctime") 
     187            u'date of creation' 
     188        """ 
     189        try: 
     190            item = self.object._meta.get_field(attr_name).verbose_name 
     191        except FieldDoesNotExist: 
     192            item = attr_name 
     193        return item    
     194 
     195    def update_from_form(self, form): 
     196        u""" 
     197        Updates :attr:`object` from data of *form* 
     198         
     199        :raises: :exc:`ValueError` if *form* is invalid. 
     200        :raises: :exc:`.PermissionError` if :attr:`_user` is not the owner of 
     201            :attr:`object`. 
     202        :raises: :exc:`.PermissionError` if :attr:`object` is not editable. 
     203        """ 
     204         
     205        self.check_permission("owner") 
     206        self.check_editable() 
     207        if form.is_valid(): 
     208            need_save = False 
     209            for key, value in form.cleaned_data.iteritems(): 
     210                if key not in ["reference", "type", "revision"]: 
     211                    setattr(self, key, value) 
     212                    need_save = True 
     213            if need_save: 
     214                self.save() 
     215        else: 
     216            raise ValueError("form is invalid") 
     217     
     218    def check_permission(self, role, raise_=True): 
     219        """ 
     220        This method checks if :attr:`_user` has permissions implied by *role*. 
     221        For example, *role* can be *owner* or *notified*. 
     222 
     223        If the check succeed, **True** is returned. Otherwise, if *raise_* is 
     224        **True** (the default), an :exc:`.PermissionError` is raised and if 
     225        *raise_* is **False**, **False** is returned. 
     226 
     227        .. admonition:: Implementation details 
     228 
     229            This method keeps a cache, so that you dont have to worry about 
     230            multiple calls to this method. 
     231        """ 
     232         
     233        if role in self.__permissions: 
     234            ok = self.__permissions[role] 
     235        else: 
     236            ok = self.has_permission(role) 
     237            self.__permissions[role] = ok 
     238        if not ok and raise_: 
     239            raise PermissionError("action not allowed for %s" % self._user) 
     240        return ok 
     241 
     242    def has_permission(self, role): 
     243        return False 
     244 
     245    def check_contributor(self, user=None): 
     246        """ 
     247        This method checks if *user* is a contributor. If not, it raises 
     248        :exc:`.PermissionError`. 
     249 
     250        If *user* is None (the default), :attr:`_user` is used. 
     251        """ 
     252         
     253        if not user: 
     254            user = self._user 
     255        profile = user.get_profile() 
     256        if not (profile.is_contributor or profile.is_administrator): 
     257            raise PermissionError("%s is not a contributor" % user) 
     258 
     259    def check_editable(self): 
     260        return True 
     261 
  • trunk/openPLM/plmapp/controllers/plmobject.py

    r336 r337  
    2727 
    2828import re 
    29 from functools import wraps 
    3029 
    3130from django.core.exceptions import ObjectDoesNotExist 
    32 from django.db.models.fields import FieldDoesNotExist 
    3331 
    3432import openPLM.plmapp.models as models 
     
    3735    PromotionError 
    3836from openPLM.plmapp.utils import level_to_sign_str 
    39 from openPLM.plmapp.controllers.base import MetaController 
    40  
    41 def permission_required(func=None, role="owner"): 
    42     """ 
    43     Decorator for methods of :class:`PLMObjectController` which 
    44     raises :exc:`.PermissionError` if :attr:`PLMObjectController._user` 
    45     has not the role *role* 
    46     """ 
    47  
    48     def decorator(f): 
    49         @wraps(f) 
    50         def wrapper(*args, **kwargs): 
    51             args[0].check_permission(role) 
    52             return f(*args, **kwargs) 
    53         wrapper.__doc__ = "Permission required: `%s`\n%s" % (role, wrapper.__doc__) 
    54         return wrapper 
    55     if func: 
    56         return decorator(func) 
    57     return decorator 
     37from openPLM.plmapp.controllers.base import Controller, permission_required 
    5838 
    5939rx_bad_ref = re.compile(r"[?/#\n\t\r\f]|\.\.") 
    60 class PLMObjectController(object): 
     40class PLMObjectController(Controller): 
    6141    u""" 
    6242    Object used to manage a :class:`~plmapp.models.PLMObject` and store his  
     
    7757    """ 
    7858 
    79     __metaclass__ = MetaController 
    80  
    81     def __init__(self, obj, user): 
    82         self.object = obj 
    83         self._user = user 
    84         # variable to store attribute changes 
    85         self.__histo = "" 
    86         # cache for permissions (dict(role->bool))  
    87         self.__permissions = {} 
    88  
     59    HISTORY = models.History 
     60     
    8961    @classmethod 
    9062    def create(cls, reference, type, revision, user, data={}): 
     
    158130        else: 
    159131            raise ValueError("form is invalid") 
    160  
    161     def get_verbose_name(self, attr_name): 
    162         """ 
    163         Returns a verbose name for *attr_name*. 
    164  
    165         Example:: 
    166  
    167             >>> ctrl.get_verbose_name("ctime") 
    168             u'date of creation' 
    169         """ 
    170         try: 
    171             item = self.object._meta.get_field(attr_name).verbose_name 
    172         except FieldDoesNotExist: 
    173             item = attr_name 
    174         return item    
    175132     
    176     def update_from_form(self, form): 
    177         u""" 
    178         Updates :attr:`object` from data of *form* 
    179          
    180         :raises: :exc:`ValueError` if *form* is invalid. 
    181         :raises: :exc:`.PermissionError` if :attr:`_user` is not the owner of 
    182             :attr:`object`. 
    183         :raises: :exc:`.PermissionError` if :attr:`object` is not editable. 
    184         """ 
    185          
    186         self.check_permission("owner") 
    187         self.check_editable() 
    188         if form.is_valid(): 
    189             need_save = False 
    190             for key, value in form.cleaned_data.iteritems(): 
    191                 if key not in ["reference", "type", "revision"]: 
    192                     setattr(self, key, value) 
    193                     need_save = True 
    194             if need_save: 
    195                 self.save() 
    196         else: 
    197             raise ValueError("form is invalid") 
    198      
    199     def check_permission(self, role, raise_=True): 
    200         """ 
    201         This method checks if :attr:`_user` has permissions implied by *role*. 
    202         For example, *role* can be *owner* or *notified*. 
    203  
    204         If the check succeed, **True** is returned. Otherwise, if *raise_* is 
    205         **True** (the default), an :exc:`.PermissionError` is raised and if 
    206         *raise_* is **False**, **False** is returned. 
    207  
    208         .. admonition:: Implementation details 
    209  
    210             This method keeps a cache, so that you dont have to worry about 
    211             multiple calls to this method. 
    212         """ 
    213          
    214         if role in self.__permissions: 
    215             ok = self.__permissions[role] 
    216         else: 
    217             users = [self._user.id] 
    218             users.extend(models.DelegationLink.get_delegators(self._user, role)) 
    219             qset = self.plmobjectuserlink_plmobject.filter(user__in=users, 
    220                                                           role=role) 
    221             ok = bool(qset) 
    222             self.__permissions[role] = ok 
    223         if not ok and raise_: 
    224             raise PermissionError("action not allowed for %s" % self._user) 
    225         return ok 
    226  
    227     def check_contributor(self, user=None): 
    228         """ 
    229         This method checks if *user* is a contributor. If not, it raises 
    230         :exc:`.PermissionError`. 
    231  
    232         If *user* is None (the default), :attr:`_user` is used. 
    233         """ 
    234          
    235         if not user: 
    236             user = self._user 
    237         profile = user.get_profile() 
    238         if not (profile.is_contributor or profile.is_administrator): 
    239             raise PermissionError("%s is not a contributor" % user) 
    240      
    241     def check_editable(self): 
    242         """ 
    243         Raises a :exc:`.PermissionError` if :attr:`object` is not editable. 
    244         """ 
    245         if not self.object.is_editable: 
    246             raise PermissionError("The object is not editable") 
    247  
    248133    def promote(self): 
    249134        u""" 
     
    294179            pass 
    295180 
    296     def __setattr__(self, attr, value): 
    297         # we override this method to make it to modify *object* directly 
    298         # if we modify *object*, we records the modification in **__histo* 
    299         if hasattr(self, "object") and hasattr(self.object, attr) and \ 
    300            not attr in self.__dict__: 
    301             old_value = getattr(self.object, attr) 
    302             setattr(self.object, attr, value) 
    303             field = self.object._meta.get_field(attr).verbose_name.capitalize() 
    304             if old_value != value: 
    305                 message = "%(field)s : changes from '%(old)s' to '%(new)s'" % \ 
    306                         {"field" : field, "old" : old_value, "new" : value} 
    307                 self.__histo += message + "\n" 
    308         else: 
    309             super(PLMObjectController, self).__setattr__(attr, value) 
    310  
    311     def __getattr__(self, attr): 
    312         # we override this method to get attributes from *object* directly 
    313         obj = object.__getattribute__(self, "object") 
    314         if hasattr(self, "object") and hasattr(obj, attr) and \ 
    315            not attr in self.__dict__: 
    316             return getattr(obj, attr) 
    317         else: 
    318             return object.__getattribute__(self, attr) 
    319  
    320181    def save(self, with_history=True): 
    321182        u""" 
     
    324185        """ 
    325186        self.object.save() 
    326         if self.__histo and with_history: 
    327             self._save_histo("Modify", self.__histo)  
    328             self.__histo = "" 
     187        if self._histo and with_history: 
     188            self._save_histo("Modify", self._histo)  
     189            self._histo = "" 
    329190 
    330191    def _save_histo(self, action, details, blacklist=(), roles=()): 
     
    343204        roles = ["notified"] + list(roles) 
    344205        send_mail(self.object, roles, action, [h], self._user, blacklist) 
     206 
     207    def has_permission(self, role): 
     208        users = [self._user.id] 
     209        users.extend(models.DelegationLink.get_delegators(self._user, role)) 
     210        qset = self.plmobjectuserlink_plmobject.filter(user__in=users, 
     211                                                          role=role) 
     212        return bool(qset) 
     213 
     214    def check_editable(self): 
     215        """ 
     216        Raises a :exc:`.PermissionError` if :attr:`object` is not editable. 
     217        """ 
     218        if not self.object.is_editable: 
     219            raise PermissionError("The object is not editable") 
    345220 
    346221    @permission_required(role="owner") 
  • trunk/openPLM/plmapp/controllers/user.py

    r336 r337  
    3535import openPLM.plmapp.models as models 
    3636from openPLM.plmapp.exceptions import PermissionError 
    37 from openPLM.plmapp.controllers.base import MetaController 
    38  
    39 class UserController(object): 
     37from openPLM.plmapp.controllers.base import Controller, permission_required 
     38 
     39class UserController(Controller): 
    4040    u""" 
    4141    Object used to manage a :class:`~django.contrib.auth.models.User` and store his  
     
    5757    """ 
    5858 
    59     __metaclass__ = MetaController 
     59    HISTORY = models.UserHistory 
    6060 
    6161    def __init__(self, obj, user): 
    62         self.object = obj 
    63         self._user = user 
    64         self.__histo = "" 
    65         self.creator = user 
    66         self.owner = user 
     62        super(UserController, self).__init__(obj, user) 
     63        self.creator = obj 
     64        self.owner = obj 
    6765        self.mtime = obj.last_login 
    6866        self.ctime = obj.date_joined 
     
    8987        return item 
    9088 
     89    @permission_required(role=models.ROLE_OWNER) 
    9190    def update_from_form(self, form): 
    9291        u""" 
     
    109108        # we override this method to make it to modify *object* directly 
    110109        # (or its profile) 
    111         # if we modify *object*, we records the modification in **__histo* 
     110        # if we modify *object*, we records the modification in **_histo* 
    112111        if hasattr(self, "object"): 
    113112            obj = object.__getattribute__(self, "object") 
     
    126125                message = "%(field)s : changes from '%(old)s' to '%(new)s'" % \ 
    127126                        {"field" : field, "old" : old_value, "new" : value} 
    128                 self.__histo += message + "\n" 
     127                self._histo += message + "\n" 
    129128        else: 
    130129            super(UserController, self).__setattr__(attr, value) 
     
    148147        If *with_history* is False, the history is not recorded. 
    149148        """ 
    150         self.object.save() 
    151149        self.object.get_profile().save() 
    152         if self.__histo and with_history: 
    153             self._save_histo("Modify", self.__histo)  
    154             self.__histo = "" 
    155  
    156     def _save_histo(self, action, details): 
    157         """ 
    158         Records *action* with details *details* made by :attr:`_user` in 
    159         on :attr:`object` in the user histories table. 
    160         """ 
    161         models.UserHistory.objects.create(plmobject=self.object, action=action, 
    162                                      details=details, user=self._user) 
     150        super(UserController, self).save(with_history) 
     151 
     152    def has_permission(self, role): 
     153        if role == models.ROLE_OWNER: 
     154            return self.object == self._user 
     155        return False 
    163156 
    164157    def get_object_user_links(self): 
     
    168161        return self.plmobjectuserlink_user.order_by("plmobject") 
    169162 
     163    @permission_required(role=models.ROLE_OWNER) 
    170164    def delegate(self, user, role): 
    171165        """ 
     
    206200        self._save_histo(models.DelegationLink.ACTION_NAME, details) 
    207201 
     202    @permission_required(role=models.ROLE_OWNER) 
    208203    def remove_delegation(self, delegation_link): 
    209204        """ 
  • trunk/openPLM/plmapp/models.py

    r333 r337  
    143143        "menu items to choose a view" 
    144144        return ["attributes", "history", "parts-doc-cad", "delegation", 
    145                 "organisation"] 
     145                "groups"] 
    146146 
    147147    @classmethod 
     
    169169    description = models.TextField(blank=True) 
    170170    creator = models.ForeignKey(User) 
     171     
     172    owner = models.ForeignKey(User, verbose_name=_("owner"),  
     173                              related_name="%(class)s_owner") 
     174    ctime = models.DateTimeField(_("date of creation"), default=datetime.datetime.today, 
     175                                 auto_now_add=False) 
     176    mtime = models.DateTimeField(_("date of last modification"), auto_now=True) 
     177 
     178    @property 
     179    def plmobject_url(self): 
     180        return iri_to_uri("/group/%s/" % self.group.name) 
     181 
     182    @property 
     183    def attributes(self): 
     184        u"Attributes to display in `Attributes view`" 
     185        return ["name", "description", "creator", "owner", 
     186                "ctime", "mtime"] 
     187 
     188    @property 
     189    def menu_items(self): 
     190        "menu items to choose a view" 
     191        return ["attributes", "history", "users", "objects"] 
     192 
     193    @classmethod 
     194    def excluded_creation_fields(cls): 
     195        "Returns fields which should not be available in a creation form" 
     196        return ["owner", "creator", "ctime", "mtime"] 
     197    
     198    @property 
     199    def is_editable(self): 
     200        return True 
    171201 
    172202# lifecycle stuff 
     
    715745    plmobject = models.ForeignKey(User) 
    716746 
     747class GroupHistory(AbstractHistory): 
     748    plmobject = models.ForeignKey(Group) 
    717749 
    718750# link stuff 
  • trunk/openPLM/plmapp/views/main.py

    r333 r337  
    5959from django.forms import HiddenInput 
    6060 
    61 from openPLM.plmapp.exceptions import ControllerError 
     61from openPLM.plmapp.exceptions import ControllerError, PermissionError 
    6262import openPLM.plmapp.models as models 
    6363from openPLM.plmapp.controllers import PLMObjectController, get_controller  
    6464from openPLM.plmapp.controllers.user import UserController 
     65from openPLM.plmapp.controllers.group import GroupController 
    6566from openPLM.plmapp.utils import level_to_sign_str, get_next_revision 
    6667from openPLM.plmapp.forms import * 
     
    224225    if isinstance(obj, UserController): 
    225226        history = models.UserHistory.objects 
     227    elif isinstance(obj, GroupController): 
     228        history = models.GroupHistory.objects 
    226229    else:  
    227230        history = models.History.objects 
     
    891894    """ 
    892895    obj, ctx, request_dict = get_generic_data(request, "User", obj_ref) 
     896    if obj.object != request.user: 
     897        raise PermissionError("You are not the user") 
    893898    class_for_div="ActiveBox4User" 
    894899    if request.method == 'POST' and request.POST: 
    895900        modification_form = OpenPLMUserChangeForm(request.POST) 
    896901        if modification_form.is_valid(): 
    897             obj.cupdate_from_form(modification_form) 
     902            obj.update_from_form(modification_form) 
    898903            return HttpResponseRedirect("/user/%s/" % obj.username) 
    899904    else: 
     
    923928        return HttpResponseRedirect("/user/%s/attributes/" % request.user) 
    924929    obj, ctx, request_dict = get_generic_data(request, "User", obj_ref) 
     930    if obj.object != request.user: 
     931        raise PermissionError("You are not the user") 
     932 
    925933    class_for_div="ActiveBox4User" 
    926934    if request.method == 'POST' and request.POST: 
  • trunk/openPLM/templates/DisplayObject.htm

    r279 r337  
    55 
    66{% block content %} 
    7     {% ifequal object_type 'User' %} 
    8         <span class="ButtonLeft"> 
    9             <a class="Button" href="/user/{{object_reference}}/modify/">{% trans "EDIT" %}</a> 
    10         </span> 
    11         <span class="ButtonLeft"> 
    12             <a class="Button" href="/user/{{object_reference}}/password/">{% trans "PASSWORD" %}</a> 
    13         </span> 
    14     {% else %} 
    15         {% if is_owner and obj.is_editable %} 
     7    {% if is_owner %} 
     8        {% ifequal object_type 'User' %} 
    169            <span class="ButtonLeft"> 
    17                 <a class="Button"  
    18                     href="/object/{{object_type}}/{{object_reference}}/{{object_revision}}/modify/"> 
    19                     {% trans "EDIT" %} 
    20                 </a> 
     10                <a class="Button" href="/user/{{object_reference}}/modify/">{% trans "EDIT" %}</a> 
    2111            </span> 
    22         {% endif %} 
    23         {% endifequal %} 
     12            <span class="ButtonLeft"> 
     13                <a class="Button" href="/user/{{object_reference}}/password/">{% trans "PASSWORD" %}</a> 
     14            </span> 
     15        {% else %} 
     16            {% if obj.is_editable %} 
     17                <span class="ButtonLeft"> 
     18                    <a class="Button"  
     19                        href="/object/{{object_type}}/{{object_reference}}/{{object_revision}}/modify/"> 
     20                        {% trans "EDIT" %} 
     21                    </a> 
     22                </span> 
     23            {% endif %} 
     24        {% endifequal %} 
     25    {% endif %} 
    2426        <table class="Content"> 
    2527            {% for description,attribute in object_attributes %} 
  • trunk/openPLM/urls.py

    r316 r337  
    6363object_url = r'^object/' + object_pattern 
    6464user_url = r'^user/(?P<obj_ref>[^/]+)/' 
     65group_url = r'^group/(?P<obj_ref>[^/]+)/' 
    6566user_dict = {'obj_type':'User', 'obj_revi':'-'} 
     67group_dict = {'obj_type':'Group', 'obj_revi':'-'} 
     68 
    6669urlpatterns += patterns('', 
    6770    (r'^admin/', include(admin.site.urls)), 
     
    131134) 
    132135 
     136urlpatterns += patterns2('', group_url,  
     137    (r'$', display_object, group_dict), 
     138    (r'attributes/$', display_object_attributes, group_dict), 
     139    (r'history/$', display_object_history, group_dict), 
     140    #(r'modify/$', modify_group), 
     141    (r'navigate/$', navigate, group_dict), 
     142) 
    133143urlpatterns += patterns('', 
    134144        # In order to take into account the css file 
Note: See TracChangeset for help on using the changeset viewer.