Changeset 3277 for WAeUP_SRP/base

Timestamp:

7 Mar 2008, 08:12:02 (17 years ago)

Author:

joachim

Message:

implemented new Upload functionallity

Location:

WAeUP_SRP/base

Files:

• Upload.py (added)
• WAeUPImport.py (modified) (5 diffs)
• WAeUPTool.py (modified) (3 diffs)
• Widgets.py (modified) (4 diffs)
• __init__.py (modified) (1 diff)
• exportimport.py (modified) (2 diffs)
• skins/waeup_upload (added)
• skins/waeup_upload/uploads_form.pt (added)
• skins/waeup_upload/uploads_index.py (added)
• skins/waeup_upload/widget_uploadfile_render.pt (added)

WAeUP_SRP/base/WAeUPImport.py

@@ -26 +26 @@
 #from Globals import DTMLFile
 #from Globals import InitializeClass
-#from OFS.SimpleItem import SimpleItem
+from OFS.SimpleItem import SimpleItem
 from zExceptions import BadRequest
 
@@ -33 +33 @@
 #from Products.CPSSchemas.DataModel import DataModel
 #from Products.CPSSchemas.StorageAdapter import MappingStorageAdapter
-#from Products.CMFCore.ActionProviderBase import ActionProviderBase
+from Products.CMFCore.ActionProviderBase import ActionProviderBase
 #from Products.CMFCore.permissions import View
 #from Products.ZCatalog.ZCatalog import ZCatalog
 #from Products.CMFCore.permissions import ModifyPortalContent
 #from Products.CMFCore.permissions import ManagePortal
-#from Products.CMFCore.utils import UniqueObject
+from Products.CMFCore.utils import UniqueObject
 #from Products.CMFCore.URLTool import URLTool
 from Products.CMFCore.utils import getToolByName
@@ -51 +51 @@
 from utils import makeDigest
 
-class WAeUPImport: ###(
+class WAeUPImport(UniqueObject, SimpleItem, ActionProviderBase): ###(
     """ WAeUPImport """
     required_modes = ('create',)
 
-    def __init__(self,waeup_tool):
+    def __init__(self,waeup_tool): ###(
+        self.students_folder = waeup_tool.portal_url.getPortalObject().campus.students
         self.member = member = waeup_tool.portal_membership.getAuthenticatedMember()
         self.import_date = DateTime.DateTime().strftime("%d/%m/%y %H:%M:%S")
         self.current = DateTime.DateTime().strftime("%d-%m-%y_%H_%M_%S")
         self.waeup_tool = waeup_tool
-        self.students_folder = waeup_tool.portal_url.getPortalObject().campus.students
         self.academics_folder = waeup_tool.portal_url.getPortalObject().campus.academics
         self.schema_tool = getToolByName(waeup_tool, 'portal_schemas')
@@ -115 +115 @@
             break
         self.init_errors = ','.join(errors)
-
-    def makeIdLists(self):
+    ###)
+
+    def makeIdLists(self): ###(
         pending_digests = []
         pending = []
@@ -134 +135 @@
             #copy2(self.pending_path,self.pending_backup)
         return pending, pending_digests
+    ###)
+
+    def checkHeadline(self,headline):
+        """ check the headline of an csv.file """
+        import_keys = [k.strip() for k in headline if not (k.strip().startswith('ignore')
+                                                        or k.strip() in self.info.keys())]
+        diff2schema = set(import_keys).difference(set(self.schema.keys()))
+        diff2layout = set(import_keys).difference(set(self.layout.keys()))
+        #if diff2schema and diff2schema != set(['id',]):
+        if diff2schema:
+            return list(diff2schema)
+        return []
 ###)
+
 
 class ApplicationImport(WAeUPImport):###(

WAeUP_SRP/base/WAeUPTool.py

@@ -1467 +1467 @@
         if not pending_only:
             info['imported_from'] = import_source_fn
-        attrs = csv.reader(open(import_source_path,"rb")).next()
-        if "import_mode" not in attrs:
+        headline = csv.reader(open(import_source_path,"rb")).next()
+        if "import_mode" not in headline:
             msg = 'import_mode must be in heading'
             return msg
-
-        import_keys = [k.strip() for k in attrs if not (k.strip().startswith('ignore')
-                                                        or k.strip() in info.keys())]
-        diff2schema = set(import_keys).difference(set(importer.schema.keys()))
-        diff2layout = set(import_keys).difference(set(importer.layout.keys()))
-        if diff2schema and diff2schema != set(['id',]):
-            msg = 'not ignorable key(s): "%s" found in heading' % ", ".join(diff2schema)
-            return msg
+        invalid_keys = importer.checkHeadline(headline)
+        if invalid_keys:
+            return 'not ignorable key(s): "%s" found in heading' % ", ".join(invalid_keys)
+
+        # import_keys = [k.strip() for k in headline if not (k.strip().startswith('ignore')
+        #                                                 or k.strip() in info.keys())]
+        # diff2schema = set(import_keys).difference(set(importer.schema.keys()))
+        # diff2layout = set(import_keys).difference(set(importer.layout.keys()))
+        # if diff2schema and diff2schema != set(['id',]):
+        #     msg = 'not ignorable key(s): "%s" found in heading' % ", ".join(diff2schema)
+        #     return msg
         #
         # start importing
@@ -1495 +1498 @@
         count = 0
         imported = []
-        old_commit_count = 0
+        old_commit_count = -1
         error_count = imported_count = 0
         already_in = 0
@@ -1581 +1584 @@
                 logger.info(' '.join(log_list))
             finished = count > total_to_import - 1
-            must_commit = False
-            if len(imported) != old_commit_count:
-                if not len(imported) % commit_after:
-                    must_commit = True
-                    old_commit_count = len(imported)
+            must_commit = (imported_count != old_commit_count) and (not imported_count % commit_after)
+            if must_commit:
+                old_commit_count = imported_count
 
             if must_commit or finished:

WAeUP_SRP/base/Widgets.py

@@ -372 +372 @@
             v = ''
         sessions = self._getSessions()
+        #import pdb;pdb.set_trace()
         if not sessions.has_key(v):
             datastructure.setError(widget_id, "'%s' not a valid session key" % v)
@@ -437 +438 @@
             return 0
 
-        if not value:
-            v = value = '100'
+        # if not value:
+        #     v = value = '100'
         #import pdb;pdb.set_trace()
         levels = self._getLevels()
@@ -1920 +1921 @@
         """Get the file info from the datastructure."""
         widget_id = self.getWidgetId()
+        info = None
         if  datastructure.has_key(widget_id):
             fileupload = datastructure[widget_id]
@@ -2148 +2150 @@
 ###)
 
+class DiscFileWidget(CPSFileWidget): ###(
+    """File widget with filesystem storage."""
+    meta_type = 'Disc File Widget'
+    _properties = CPSFileWidget._properties +\
+    (
+     {'id': 'path', 'type': 'string', 'mode': 'w',
+      'label': 'Relative Path'},
+    )
+    path = "import"
+    storage_path = "%s/%s" % (i_home,path)
+
+    def getStoredFileInfo(self,datastructure): ###(
+        datamodel = datastructure.getDataModel()
+        field_id = self.fields[0]
+        widget_id = self.getWidgetId()
+        file_name = datamodel[field_id]
+        info = {}
+        registry = getToolByName(self, 'mimetypes_registry')
+        info['mimetype'] = registry.lookupExtension('file.csv')
+        info['empty_file'] = True
+        info['size'] = 0
+        info['last_modified'] = ''
+        file_path = os.path.join(self.storage_path, file_name)
+        if os.path.exists(file_path):
+            info['empty_file'] = False
+            info['file_name'] = file_name
+            info['content_url'] = os.path.join(self.portal_url(),
+                                            "viewfile",
+                                            file_name,
+                                            )
+            info['current_filename'] =  file_name
+            # get the mimetype
+            mimetype = (registry.lookupExtension(file_name.lower()) or
+                        registry.lookupExtension('file.bin'))
+            info['mimetype'] = mimetype
+            info['file_path'] = file_path
+        else:
+            info['file_name'] = ''
+            info['content_url'] = ''
+            info['current_filename'] = ''
+            info['file_path'] = ''
+        return info
+        ###)
+    
+    def prepare(self, datastructure, **kw): ###(
+        """Prepare datastructure from datamodel."""
+        datamodel = datastructure.getDataModel()
+        #import pdb;pdb.set_trace()
+        widget_id = self.getWidgetId()
+        file_name = datamodel[self.fields[0]]
+        datastructure[widget_id] = file_name
+        datastructure[widget_id + '_filename'] = file_name
+        datastructure[widget_id+'_choice'] = "keep"
+    ###)
+
+    def validate(self, datastructure, **kw): ###(
+        """Update datamodel from user data in datastructure.
+        """
+        logger = logging.getLogger('Widgets.DiscFileWidget.validate')
+        datamodel = datastructure.getDataModel()
+        field_id = self.fields[0]
+        widget_id = self.getWidgetId()
+        store = False
+        fileupload = None
+        mimetype = None
+        old_file = datamodel[field_id]
+        choice = datastructure[widget_id+'_choice']
+        fileupload = datastructure[widget_id]
+        is_upload = isinstance(fileupload, FileUpload)
+        if not is_upload and not datamodel[field_id]:
+            if self.is_required:
+                return self.validateError('File upload required', {},
+                                          datastructure)
+        if choice == 'delete':
+            if self.is_required:
+                return self.validateError('cpsschemas_err_required', {},
+                                          datastructure)
+            info = self.getStoredFileInfo(datastructure)
+            # Remove the file in the filesystem
+            if info:
+                os.remove(info['file_path'])
+            datamodel[field_id] = None
+        elif choice == 'keep':
+            fileupload = datastructure[widget_id]
+            if isinstance(fileupload, PersistableFileUpload):
+                # Keeping something from the session means we
+                # actually want to store it.
+                store = True
+            # else:
+            #     # Nothing to change, don't pollute datastructure
+            #     # with something costly already stored, which therefore
+            #     # doesn't need to be kept in the session.
+            #     self.unprepare(datastructure)
+        elif choice == 'change' and is_upload:
+            if not fileupload:
+                return self.validateError('cpsschemas_err_file_empty', {},
+                                          datastructure)
+            if not isinstance(fileupload, FileUpload):
+                return self.validateError('cpsschemas_err_file', {},
+                                          datastructure)
+            fileupload.seek(0, 2) # end of file
+            size = fileupload.tell()
+            if not size:
+                return self.validateError('cpsschemas_err_file_empty', {},
+                                          datastructure)
+            if self.size_max and size > self.size_max:
+                max_size_str = self.getHumanReadableSize(self.size_max)
+                err = 'This file is too big, the allowed max size is ${max_size}'
+                member_id = str(self.portal_membership.getAuthenticatedMember())
+                logger.info('%s tried to upload picture with size %dk' %(member_id,int(size)/1000) )
+                err_mapping = {'max_size': max_size_str}
+                return self.validateError(err, err_mapping, datastructure)
+            store = True
+
+
+        # Find filename
+        if is_upload and store:
+            filename = cookId('', '', fileupload)[0].strip()
+            base,ext = os.path.splitext(filename)
+            if ext not in ("csv",".csv"):
+                return self.validateError('only csv files allowed', {},
+                                          datastructure)
+            datamodel[field_id] = filename
+            registry = getToolByName(self, 'mimetypes_registry')
+            mimetype = registry.lookupExtension(filename.lower())
+            if mimetype is not None:
+                mimetype = str(mimetype) # normalize
+            file = self.makeFile(filename, fileupload, datastructure)
+            # Fixup mimetype
+            if mimetype and file.content_type != mimetype:
+                file.content_type = mimetype
+            file_path = os.path.join(self.storage_path,filename)
+            #import pdb; pdb.set_trace()
+            data = open(file_path,"w")
+            data.write(str(file.data))
+            data.close()
+        return True
+    ###)
+
+    def render(self, mode, datastructure, **kw): ###(
+        render_method = 'widget_uploadfile_render'
+        meth = getattr(self, render_method, None)
+        #import pdb;pdb.set_trace()
+        if meth is None:
+            raise RuntimeError("Unknown Render Method %s for widget type %s"
+                               % (render_method, self.getId()))
+        file_info = self.getStoredFileInfo(datastructure)
+
+        return meth(mode=mode, datastructure=datastructure, **file_info)
+    ###)
+
+InitializeClass(DiscFileWidget)
+
+widgetRegistry.register(DiscFileWidget)
+###)
+
 ###########
 

WAeUP_SRP/base/__init__.py

@@ -88 +88 @@
         )
      ),
+     ("Upload",
+        ("UploadsFolder",
+         "Upload",
+         )
+     ),
     )
 

WAeUP_SRP/base/exportimport.py

@@ -79 +79 @@
         students = getattr(campus,'students',None)
         accommodation = getattr(campus,'accommodation',None)
+        upload = getattr(campus,'upload',None)
         campus.manage_setLocalGroupRoles(groupid='CampusOfficers',
                                          roles=('SectionOfficer',))
@@ -103 +104 @@
                                          roles=('SectionReader',))
             accommodation.manage_setLocalGroupRoles(groupid='AccommodationOfficers',
+                                         roles=('SectionOfficer',))
+        if upload is not None:
+            upload.manage_setLocalGroupRoles(groupid='CampusOfficers',
                                          roles=('SectionOfficer',))
     members = getattr(site.portal_directories,'members')