Changeset 797 in main


Ignore:
Timestamp:
02/24/12 10:27:27 (10 years ago)
Author:
pcosquer
Message:
  • change rules to detach a document/part
  • revisions: show parts to attach while revising a document
Location:
trunk/openPLM
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/openPLM/gdoc/models.py

    r679 r797  
    7575            self.client = get_gclient(credential) 
    7676 
    77     def revise(self, new_revision): 
    78         rev = super(GoogleDocumentController, self).revise(new_revision) 
     77    def revise(self, new_revision, *args, **kwargs): 
     78        rev = super(GoogleDocumentController, self).revise(new_revision, *args, **kwargs) 
    7979        # try to copy the document in google docs 
    8080        if not hasattr(self, "client"): 
  • trunk/openPLM/plmapp/controllers/document.py

    r795 r797  
    225225        :attr:`~PLMObjectController.object`. 
    226226        """ 
    227  
     227         
     228        self.check_attach_part(part, True) 
    228229        if isinstance(part, PLMObjectController): 
    229230            part = part.object 
     
    239240        """ 
    240241        return self.object.documentpartlink_document.all() 
    241  
     242     
     243    def get_detachable_parts(self): 
     244        """ 
     245        Returns all attached parts the user can detach. 
     246        """ 
     247        links = [] 
     248        for link in self.get_attached_parts().select_related("parts"): 
     249            part = link.part 
     250            if self.can_detach_part(part): 
     251                links.append(link.id) 
     252        return self.documentpartlink_document.filter(id__in=links) 
     253     
    242254    def is_part_attached(self, part): 
    243255        """ 
     
    249261        return bool(self.documentpartlink_document.filter(part=part)) 
    250262 
    251     def check_attach_part(self, part): 
     263    def check_attach_part(self, part, detach=False): 
    252264        if not (hasattr(part, "is_part") and part.is_part): 
    253265            raise TypeError("%s is not a part" % part) 
    254266        if not isinstance(part, PLMObjectController): 
    255267            part = get_controller(part.type)(part, self._user) 
    256         part.check_attach_document(self) 
     268        part.check_attach_document(self, detach) 
    257269        
    258270    def can_attach_part(self, part): 
     
    267279            pass 
    268280        return can_attach 
     281        
     282    def can_detach_part(self, part): 
     283        """ 
     284        Returns True if *part* can be detached. 
     285        """ 
     286        can_detach = False 
     287        try: 
     288            self.check_attach_part(part, True) 
     289            can_detach = True 
     290        except StandardError: 
     291            pass 
     292        return can_detach 
    269293 
    270294    def revise(self, new_revision, selected_parts=()): 
     
    350374                        :class:`~plmapp.forms.ModifyRelPartForm` 
    351375        """ 
     376        parts = set() 
    352377        if formset.is_valid(): 
    353378            for form in formset.forms: 
     
    358383                part = form.cleaned_data["part"] 
    359384                if delete: 
     385                    parts.add(part) 
     386            if parts: 
     387                for part in parts: 
    360388                    self.detach_part(part) 
     389                ids = (p.id for p in parts) 
     390                self.documentpartlink_document.filter(part__in=ids).delete() 
    361391 
    362392    def update_file(self, formset): 
  • trunk/openPLM/plmapp/controllers/part.py

    r795 r797  
    319319            :attr:`object`. 
    320320        """ 
    321  
    322         self.check_permission("owner") 
     321         
     322        self.check_attach_document(document, True) 
    323323        if isinstance(document, PLMObjectController): 
    324324            document = document.object 
     
    334334        """ 
    335335        return self.documentpartlink_part.all() 
     336 
     337    def get_detachable_documents(self): 
     338        """ 
     339        Returns all attached documents the user can detach. 
     340        """ 
     341        links = [] 
     342        for link in self.get_attached_documents().select_related("document"): 
     343            doc = link.document 
     344            if self.can_detach_document(doc): 
     345                links.append(link.id) 
     346        return self.documentpartlink_part.filter(id__in=links) 
    336347      
    337348    def is_document_attached(self, document): 
     
    344355        return bool(self.documentpartlink_part.filter(document=document)) 
    345356     
    346     def check_attach_document(self, document): 
     357    def check_attach_document(self, document, detach=False): 
    347358        if not hasattr(document, "is_document") or not document.is_document: 
    348359            raise TypeError("%s is not a document" % document) 
     360        self.check_contributor() 
    349361        if not (self.is_draft or document.is_draft): 
    350362            raise ValueError("Can not attach: one of the part or document's state must be draft.")  
     
    376388        if not owner_ok: 
    377389            self.check_permission("owner") 
     390         
    378391        if self.is_document_attached(document): 
    379             raise ValueError("Document is already attached to the part.") 
     392            if not detach: 
     393                raise ValueError("Document is already attached to the part.") 
     394        elif detach: 
     395            raise ValueError("Document is not attached to the part.") 
    380396 
    381397    def can_attach_document(self, document): 
     
    391407        return can_attach 
    392408 
     409    def can_detach_document(self, document): 
     410        """ 
     411        Returns True if *document* can be detached. 
     412        """ 
     413        can_detach = False 
     414        try: 
     415            self.check_attach_document(document, True) 
     416            can_detach = True 
     417        except StandardError: 
     418            pass 
     419        return can_detach 
     420 
    393421    def update_doc_cad(self, formset): 
    394422        u""" 
     
    399427                        :class:`~plmapp.forms.ModifyChildForm` 
    400428         
    401         :raises: :exc:`.PermissionError` if :attr:`_user` is not the owner of 
    402             :attr:`object`. 
    403         """ 
    404          
    405         self.check_permission("owner") 
     429        :raises: :exc:`ValueError` if one of the document is not detachable. 
     430        """ 
     431          
     432        docs = set() 
    406433        if formset.is_valid(): 
    407434            for form in formset.forms: 
     
    412439                document = form.cleaned_data["document"] 
    413440                if delete: 
    414                     self.detach_document(document) 
     441                    docs.add(document) 
     442            if docs: 
     443                for doc in docs: 
     444                    self.check_attach_document(doc, True) 
     445                ids = (d.id for d in docs) 
     446                self.documentpartlink_part.filter(document__in=ids).delete() 
    415447 
    416448    def cancel(self): 
  • trunk/openPLM/plmapp/forms.py

    r758 r797  
    440440    revision = forms.CharField() 
    441441    clean_revision = _clean_revision 
    442      
    443 class AddRelPartForm(PLMObjectForm): 
    444     pass 
    445      
    446 class ModifyRelPartForm(forms.ModelForm): 
    447     delete = forms.BooleanField(required=False, initial=False) 
     442    
     443class RelPartForm(forms.ModelForm): 
    448444    document = forms.ModelChoiceField(queryset=m.Document.objects.all(), 
    449445                                   widget=forms.HiddenInput()) 
     
    453449        model = m.DocumentPartLink 
    454450        fields = ["document", "part"] 
     451 
     452class SelectPLMObjectForm(RelPartForm): 
     453    selected = forms.BooleanField(required=False, initial=True) 
     454         
     455SelectPLMObjectFormset = modelformset_factory(m.DocumentPartLink, 
     456                        form=SelectPLMObjectForm, extra=0) 
     457 
     458class AddRelPartForm(PLMObjectForm): 
     459    pass 
     460     
     461class ModifyRelPartForm(RelPartForm): 
     462    delete = forms.BooleanField(required=False, initial=False) 
    455463         
    456464RelPartFormset = modelformset_factory(m.DocumentPartLink, 
    457465                                      form=ModifyRelPartForm, extra=0) 
    458 def get_rel_part_formset(controller, data=None): 
    459     if data is None: 
    460         queryset = controller.get_attached_parts() 
    461         formset = RelPartFormset(queryset=queryset) 
    462     else: 
    463         formset = RelPartFormset(data=data) 
     466 
     467def get_rel_part_formset(controller, data=None, **kwargs): 
     468    queryset = controller.get_detachable_parts() 
     469    formset = RelPartFormset(queryset=queryset, data=data, **kwargs) 
    464470    return formset 
    465471 
     
    499505DocCadFormset = modelformset_factory(m.DocumentPartLink, 
    500506                                     form=ModifyDocCadForm, extra=0) 
    501 def get_doc_cad_formset(controller, data=None): 
    502     if data is None: 
    503         queryset = controller.get_attached_documents() 
    504         formset = DocCadFormset(queryset=queryset) 
    505     else: 
    506         formset = DocCadFormset(data=data) 
     507def get_doc_cad_formset(controller, data=None, **kwargs): 
     508    queryset = controller.get_detachable_documents() 
     509    formset = DocCadFormset(queryset=queryset, data=data, **kwargs) 
    507510    return formset 
    508511 
  • trunk/openPLM/plmapp/tests/controllers/partdoc.py

    r795 r797  
    8080        ("deprecated","deprecated",True,True,False), 
    8181) 
    82     def test_attach(self): 
    83         other_owner = self.get_contributor("Otherowner") 
    84         other_owner.groups.add(self.group) 
    85         other_owner.save() 
     82 
     83    def setUp(self): 
     84        super(PartDocControllerTestCase, self).setUp() 
     85        self.other_owner = self.get_contributor("Otherowner") 
     86        self.other_owner.groups.add(self.group) 
     87        self.other_owner.save() 
    8688         
    8789        lcl = LifecycleList("dpop","official", "draft",  
    8890               "proposed", "official", "deprecated") 
    8991        lc = models.Lifecycle.from_lifecyclelist(lcl) 
    90         states = dict((s, models.State.objects.get(name=s)) for s in lcl)  
    91         states["cancelled"] = models.get_cancelled_state() 
    92         lifecycles = dict.fromkeys(lcl, lc) 
    93         lifecycles["cancelled"] = models.get_cancelled_lifecycle() 
     92        self.states = dict((s, models.State.objects.get(name=s)) for s in lcl)  
     93        self.states["cancelled"] = models.get_cancelled_state() 
     94        self.lifecycles = dict.fromkeys(lcl, lc) 
     95        self.lifecycles["cancelled"] = models.get_cancelled_lifecycle() 
    9496        data = self.DATA.copy() 
    9597        data["lifecycle"] = lc 
    96         part = PartController.create("p1","Part", "a", self.user, data, 
     98        self.part = PartController.create("p1","Part", "a", self.user, data, 
    9799                True, True) 
    98         doc = DocumentController.create("d1","Document", "a", self.user, data, 
    99                 True, True) 
     100        self.doc = DocumentController.create("d1","Document", "a", 
     101                self.user, data, True, True) 
     102 
     103 
     104    def test_attach(self): 
    100105        expected = [] 
    101106        result_part = [] 
    102107        result_doc = [] 
    103108        for pstate, dstate, powner, downer, can_attach in self.MATRICE: 
    104             part.object.state = states[pstate] 
    105             part.object.lifecycle = lifecycles[pstate] 
    106             doc.object.state = states[dstate] 
    107             doc.object.lifecycle = lifecycles[dstate] 
    108             part.set_owner(self.user if powner else other_owner, True) 
    109             doc.set_owner(self.user if downer else other_owner, True) 
     109            self.part.object.state = self.states[pstate] 
     110            self.part.object.lifecycle = self.lifecycles[pstate] 
     111            self.doc.object.state = self.states[dstate] 
     112            self.doc.object.lifecycle = self.lifecycles[dstate] 
     113            self.part.set_owner(self.user if powner else self.other_owner, True) 
     114            self.doc.set_owner(self.user if downer else self.other_owner, True) 
    110115             
    111116            expected.append(can_attach) 
    112             pctrl = PartController(part.object, self.user) 
    113             result_part.append(pctrl.can_attach_document(doc.object)) 
    114             dctrl = DocumentController(doc.object, self.user) 
    115             result_doc.append(dctrl.can_attach_part(part.object)) 
    116             if expected[-1] != result_doc[-1]: 
    117                 print pstate, dstate, powner, downer, can_attach  
     117            pctrl = PartController(self.part.object, self.user) 
     118            result_part.append(pctrl.can_attach_document(self.doc.object)) 
     119            dctrl = DocumentController(self.doc.object, self.user) 
     120            result_doc.append(dctrl.can_attach_part(self.part.object)) 
    118121        self.assertEqual(expected, result_part) 
    119122        self.assertEqual(expected, result_doc) 
     123 
     124    def test_detach(self): 
     125        expected = [] 
     126        result_part = [] 
     127        result_doc = [] 
     128        self.doc.attach_to_part(self.part) 
     129        for pstate, dstate, powner, downer, can_detach in self.MATRICE: 
     130            self.part.object.state = self.states[pstate] 
     131            self.part.object.lifecycle = self.lifecycles[pstate] 
     132            self.doc.object.state = self.states[dstate] 
     133            self.doc.object.lifecycle = self.lifecycles[dstate] 
     134            self.part.set_owner(self.user if powner else self.other_owner, True) 
     135            self.doc.set_owner(self.user if downer else self.other_owner, True) 
     136             
     137            expected.append(can_detach) 
     138            pctrl = PartController(self.part.object, self.user) 
     139            result_part.append(pctrl.can_detach_document(self.doc.object)) 
     140            dctrl = DocumentController(self.doc.object, self.user) 
     141            result_doc.append(dctrl.can_detach_part(self.part.object)) 
     142        self.assertEqual(expected, result_part) 
     143        self.assertEqual(expected, result_doc) 
  • trunk/openPLM/plmapp/tests/views.py

    r758 r797  
    329329        response = self.get(self.base_url + "parts/", page="parts") 
    330330        self.assertEqual([part.id], 
    331                          [p.part.id for p in response.context["object_rel_part"]]) 
     331                         [p.part.id for p in response.context["all_parts"]]) 
     332        self.assertEqual([part.id], 
     333            [f.instance.part.id for f in response.context["parts_formset"].forms]) 
    332334         
    333335    def test_add_related_part_get(self): 
     
    451453    def test_doc_cad_empty(self): 
    452454        response = self.get(self.base_url + "doc-cad/", page="doc-cad") 
    453         self.assertEqual(0, len(list(response.context["object_doc_cad"]))) 
     455        self.assertEqual(0, len(list(response.context["all_docs"]))) 
    454456     
    455457    def test_doc_cad(self): 
     
    460462        self.controller.attach_to_document(doc1) 
    461463        self.controller.attach_to_document(doc2) 
     464        doc2.object.state = doc2.object.lifecycle.last_state 
     465        doc2.object.save() 
    462466        response = self.get(self.base_url + "doc-cad/", page="doc-cad") 
    463         self.assertEqual(2, len(list(response.context["object_doc_cad"]))) 
     467        self.assertEqual(2, response.context["all_docs"].count()) 
     468        forms = response.context["forms"] 
     469        self.assertEqual([doc1.id], [f.instance.document.id for f in forms.values()])  
    464470 
    465471    def test_doc_add_add_get(self): 
  • trunk/openPLM/plmapp/views/main.py

    r785 r797  
    236236    """ 
    237237    obj, ctx = get_generic_data(request, obj_type, obj_ref, obj_revi) 
    238      
     238    if obj.is_document: 
     239        confirmation = obj.get_attached_parts().exists() 
     240    else: 
     241        confirmation = False 
    239242    if obj.is_revisable(): 
    240243        if request.method == "POST" and request.POST: 
    241244            add_form = AddRevisionForm(request.POST) 
     245            kwargs = {} 
     246            if obj.is_document and confirmation: 
     247                part_formset = forms.SelectPLMObjectFormset(request.POST) 
     248                parts = [] 
     249                if part_formset.is_valid(): 
     250                    for form in part_formset.forms: 
     251                        doc = form.cleaned_data["document"] 
     252                        if doc.pk != obj.pk: 
     253                            raise ValueError("Bad document") 
     254                        part = form.cleaned_data["part"] 
     255                        if form.cleaned_data["selected"] and part.is_editable: 
     256                            parts.append(part) 
     257                kwargs["selected_parts"] = parts 
    242258            if add_form.is_valid(): 
    243                 obj.revise(add_form.cleaned_data["revision"]) 
     259                obj.revise(add_form.cleaned_data["revision"], **kwargs) 
    244260        else: 
    245261            add_form = AddRevisionForm({"revision" : get_next_revision(obj_revi)}) 
     262            if obj.is_document: 
     263                qs = obj.get_attached_parts() 
     264                ctx["part_formset"] = forms.SelectPLMObjectFormset(queryset=qs) 
    246265        ctx["add_revision_form"] = add_form 
     266 
     267    ctx["confirmation"] = confirmation 
    247268    revisions = obj.get_all_revisions() 
    248269    ctx.update({'current_page' : 'revisions', 
     
    452473    else: 
    453474        formset = get_doc_cad_formset(obj) 
     475    dforms = dict((form.instance.id, form) for form in formset.forms) 
    454476    archive_form = forms.ArchiveForm() 
    455477    ctx.update({'current_page':'doc-cad', 
    456                 'object_doc_cad': obj.get_attached_documents(), 
     478                'all_docs': obj.get_attached_documents(), 
     479                'forms' : dforms, 
    457480                'archive_form' : archive_form, 
    458                 'doc_cad_formset': formset}) 
     481                'docs_formset': formset}) 
    459482    return r2r('DisplayObjectDocCad.htm', ctx, request) 
    460483 
     
    507530    else: 
    508531        formset = get_rel_part_formset(obj) 
     532    forms = dict((form.instance.id, form) for form in formset.forms) 
     533 
    509534    ctx.update({'current_page':'parts',  
    510                 'object_rel_part': obj.get_attached_parts(), 
    511                 'rel_part_formset': formset}) 
     535                'all_parts': obj.get_attached_parts(), 
     536                'forms' : forms, 
     537                'parts_formset': formset}) 
    512538    return r2r('DisplayObjectRelPart.htm', ctx, request) 
    513539 
  • trunk/openPLM/templates/DisplayObjectDocCad.htm

    r792 r797  
    55 
    66{% block content %} 
    7     {% if object_doc_cad.count > 0 %} 
     7    {% if all_docs %} 
    88        <form class="archive_form" method="GET" action="./archive/"> 
    99            {{ archive_form.as_p }} 
     
    1919    {% endif %} 
    2020    <form method="post" action="">       
    21         {{ doc_cad_formset.management_form }} 
    22         <table class="Content"> 
    23                 {% for form in doc_cad_formset.forms %} 
    24                 {{ form.id }} 
    25                 {{ form.part }} 
    26                 {{ form.document }} 
     21 
     22          <table class="Content"> 
     23            {% for link in all_docs %} 
     24 
    2725                <tr class="Content"> 
    28                     {% if is_owner %} 
    29                         <td class="Content"  style="width:50px; text-align:center">{{ form.delete }}</td> 
    30                     {% endif %} 
    31                             <td class="Content">{{ form.instance.document.type }}</td> 
    32                             <td class="Content"> 
    33                         <a href="{{ form.instance.document.plmobject_url }}"/> 
    34                                     {{ form.instance.document.reference }} 
    35                             </a> 
     26                    {% with link.document as document %} 
     27                        {% if user.get_profile.is_contributor and link.id in forms %} 
     28                            {% with forms|key:link.id as form %}  
     29                                {{ form.id }} 
     30                                {{ form.document }} 
     31                                {{ form.part }} 
     32                                <td class="Content" style="width:50px; text-align:center">{{ form.delete }}</td> 
     33                            {% endwith %} 
     34                        {% else %} 
     35                            <td class="Content"> - </td> 
     36                        {% endif %} 
     37                        <td class="Content">{{ document.type }}</td> 
     38                        <td class="Content"> 
     39                            <a href="{{ document.plmobject_url }}"/> 
     40                                {{ document.reference }} 
     41                            </a> 
     42                        </td> 
     43                        <td class="Content">{{ document.revision }}</td> 
     44                    {% endwith %} 
     45                </tr> 
     46            {% empty %} 
     47                <tr> 
     48                    <td> 
     49                        {% trans "There are no documents attached to this part." %} 
    3650                    </td> 
    37                             <td class="Content">{{ form.instance.document.revision }}</td> 
    3851                </tr> 
    39                 {% empty %} 
    40                 <tr><td>{% trans "There are no document attached to this part" %}</td></tr> 
    41                 {% endfor %} 
    42             </table> 
    43         {% if is_owner %} 
     52            {% endfor %} 
     53        </table> 
     54         
     55        {% if user.get_profile.is_contributor  %} 
     56            {{ docs_dormset.management_form }} 
    4457            <a class="{{"Button"|button}}" href="./add/"> 
    4558                <span class="ui-button-text">{% trans "Attach another document" %}</span> 
    4659            </a> 
    47             {% if object_doc_cad.count > 0 %} 
     60            {% if forms %} 
    4861                <input type="submit" class="{{"Button"|button}}" value="{% trans "DISCONNECT" %}"/> 
    4962            {% endif %} 
  • trunk/openPLM/templates/DisplayObjectRelPart.htm

    r792 r797  
    66{% block content %} 
    77    <form method="post" action="">       
    8         {{ rel_part_formset.management_form }} 
    9         {% if is_owner %} 
     8 
     9        {% if user.get_profile.is_contributor %} 
     10            {{ parts_formset.management_form }} 
    1011            <a class="{{"Button"|button}}" href="./add/"><span class="ui-button-text">{% trans "ADD" %}</span></a> 
    11             {% if rel_part_formset.forms %} 
     12            {% if parts_formset.forms %} 
    1213                <input type="submit" class="{{"Button"|button}}" value="{% trans "DISCONNECT" %}"/> 
    1314            {% endif %} 
    1415        {% endif %} 
     16 
    1517        <table class="Content"> 
    16                 {% for form in rel_part_formset.forms %} 
    17                 {{ form.id }} 
    18                 {{ form.document }} 
    19                 {{ form.part }} 
     18            {% for link in all_parts %} 
     19 
    2020                <tr class="Content"> 
    21                     {% if is_owner %} 
    22                         <td class="Content" style="width:50px; text-align:center">{{ form.delete }}</td> 
    23                     {% endif %} 
    24                                 <td class="Content">{{ form.instance.part.type }}</td> 
    25                                 <td class="Content"> 
    26                         <a href="{{ form.instance.part.plmobject_url }}"/> 
    27                                         {{ form.instance.part.reference }} 
    28                                 </a> 
    29                         </td> 
    30                                 <td class="Content">{{ form.instance.part.revision }}</td> 
     21                    {% with link.part as part %} 
     22                        {% if user.get_profile.is_contributor and link.id in forms %} 
     23                            {% with forms|key:link.id as form %}  
     24                                {{ form.id }} 
     25                                {{ form.document }} 
     26                                {{ form.part }} 
     27                                <td class="Content" style="width:50px; text-align:center">{{ form.delete }}</td> 
     28                            {% endwith %} 
     29                        {% else %} 
     30                            <td class="Content"> - </td> 
     31                        {% endif %} 
     32                        <td class="Content">{{ part.type }}</td> 
     33                        <td class="Content"> 
     34                            <a href="{{ part.plmobject_url }}"/> 
     35                                {{ part.reference }} 
     36                            </a> 
     37                        </td> 
     38                        <td class="Content">{{ part.revision }}</td> 
     39                    {% endwith %} 
    3140                </tr> 
    3241            {% empty %} 
     
    3645                    </td> 
    3746                </tr> 
    38                 {% endfor %} 
    39             </table> 
     47            {% endfor %} 
     48        </table> 
    4049    </form> 
    4150{% endblock %} 
  • trunk/openPLM/templates/DisplayObjectRevisions.htm

    r792 r797  
    22{% load i18n plmapp_tags %} 
    33 
     4{% block css %} 
     5 
     6    <link rel="stylesheet" href="/media/css/lifecycle.css" type="text/css" charset="utf-8" /> 
     7{% endblock css %} 
    48<!-- Manage html display in the Content div which correspond to the "revisions" menu --> 
    59 
    610{% block content %} 
    711    {% if add_revision_form and obj.is_revisable %} 
    8         <form method="POST" action=""> 
    9             {{add_revision_form}} 
     12        <form id="form-revision" method="POST" 
     13            {% if confirmation %} class="confirmation" {% endif %} action=""> 
     14            {{ add_revision_form }} 
     15            {% if obj.is_document and confirmation %} 
     16                <div id="form-revision-dialog" 
     17                    title="{% trans "Are you sure?" %}" 
     18                    {% if part_formset.is_bound and not part_formset.is_valid %}  
     19                        class="c-error action-{{ action }}" 
     20                    {% endif %} 
     21                    > 
     22                    <p><span class="ui-icon ui-icon-alert" style="float:left; margin:0 7px 20px 0;"></span>{% trans "Here is the list of parts connected to the original document. Do you want to connect them to new document?" %}</p> 
     23                    <div class="parts"> 
     24                        {{ part_formset.management_form }} 
     25 
     26                        <table class="Content"> 
     27                            {% for form in part_formset.forms %} 
     28                                {{ form.id }} 
     29                                {{ form.document }} 
     30 
     31                                {{ form.part }} 
     32                                <tr class="Content"> 
     33                                    {% with form.instance.part as part %} 
     34                                        {% if part.is_editable %} 
     35                                            <td class="Content" style="width:50px; text-align:center">{{ form.selected }}</td> 
     36                                        {% else %} 
     37                                            <td class="Content">-</td> 
     38                                        {% endif %} 
     39                                        <td class="Content">{{ part.type }}</td> 
     40                                        <td class="Content">{{ part.reference }} </td> 
     41                                        <td class="Content">{{ part.revision }}</td> 
     42                                        <td class="Content">{{ part.name }}</td> 
     43                                    {% endwith %} 
     44                                </tr> 
     45                            {% endfor %} 
     46                        </table> 
     47 
     48                    </div> 
     49                </div> 
     50            {% endif %} 
     51 
    1052            <input type="submit" class="{{"Button"|button}}" value="{% trans "NEW" %}"/> 
    1153        </form> 
Note: See TracChangeset for help on using the changeset viewer.