Return to OSAS_archiver.py CVS log

Up to [Repository] / OSAS / OSA_system

add archiving system

    1: # Methoden und Klassen fuer den MPIWG Archiver
    2: 
    3: from OFS.Image import Image
    4: from OFS.Folder import Folder
    5: from OFS.SimpleItem import SimpleItem
    6: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
    7: from Products.PageTemplates.PageTemplate import PageTemplate
    8: from AccessControl import ClassSecurityInfo
    9: from Globals import InitializeClass
   10: from Globals import Persistent
   11: from Acquisition import Implicit
   12: from OSAS_show import *
   13: 
   14: import os.path
   15: import os
   16: import OSAS_ids
   17: import archive #Baustelle
   18: 
   19: class OSAS_metadataOrganizer(SimpleItem,Persistent,Implicit):
   20:     """Eingabe von Metadaten"""
   21: 
   22:     meta_type="OSAS_metadataOrganizer"
   23: 
   24:     def __init__(self,id,title):
   25:         """init"""
   26:         self.id=id
   27:         self.title=title
   28:         #self.acquisitionData=['provider_name','provider_address','provider_contact','provider_url','date','description']
   29: 
   30:     def addAcquisition(self,path):
   31:         """Hinzufügen von Acquisition Daten"""
   32:         self.REQUEST.SESSION['path']=path
   33:         pt=PageTemplateFile('Products/OSA_system/inputAcquisitionData.zpt').__of__(self)
   34:         return pt()
   35: 
   36:     def writeAcquisitionMetadata(self,producer,date,path,description=""):
   37:         """Schreibe Acquisiondata in index.meta"""
   38:         
   39: def manage_AddOSAS_metadataOrganizerForm(self):
   40:     """interface for adding the OSAS_root"""
   41:     pt=PageTemplateFile('Products/OSA_system/AddOSAS_metadataOrganizer.zpt').__of__(self)
   42:     return pt()
   43: 
   44: 
   45: def manage_AddOSAS_metadataOrganizer(self,id,title="",RESPONSE=None):
   46:     """add the OSAS_root"""
   47:     if title=="":
   48:         title=id
   49:         
   50:     newObj=OSAS_metadataOrganizer(id, title)
   51:     self._setObject(id,newObj)
   52:     if RESPONSE is not None:
   53:         RESPONSE.redirect('manage_main')
   54:     
   55: 
   56: class OSAS_processViewer(SimpleItem,Persistent,Implicit):
   57:     """Process viewer for archiving"""
   58: 
   59:     meta_type="OSAS_processViewer"
   60: 
   61:     def __init__(self, id, title):
   62:         """init"""
   63:         self.id=id
   64:         self.title=title
   65: 
   66:     def index_html(self):
   67:         """main page"""
   68:         pt=PageTemplateFile('Products/OSA_system/processViewerIndex.zpt').__of__(self)
   69:         return pt()
   70: 
   71:     def storeFile(self,something):
   72:         """store info in session"""
   73:         self.REQUEST.SESSION['something']=something
   74:         return 1
   75: 
   76:     def getFile(self):
   77:         """get info from session"""
   78:         return self.REQUEST.SESSION['something']
   79: 
   80:     def getoverview(self,path):
   81:         """get overview"""
   82:         return archive.overview(path)
   83: 
   84:     def storeerror(self,ret,path,context,i):
   85:         """store an error"""
   86:         session=context.REQUEST.SESSION
   87:         session['error%i'%i]=ret
   88:         session['path%i'%i]=path
   89:      
   90:         return 'error?number=%i'%i
   91: 
   92:     def view(self):
   93:         """view page"""
   94:         pt=PageTemplateFile('Products/OSA_system/processViewerView.zpt').__of__(self)
   95:         return pt()
   96:     
   97: def manage_AddOSAS_processViewerForm(self):
   98:     """interface for adding the OSAS_processViewer"""
   99:     pt=PageTemplateFile('Products/OSA_system/AddOSAS_processViewer.zpt').__of__(self)
  100:     return pt()
  101: 
  102: 
  103: def manage_AddOSAS_processViewer(self,id,title="",RESPONSE=None):
  104:     """add the OSAS_processViewer"""
  105:     if title=="":
  106:         title=id
  107:         
  108:     newObj=OSAS_processViewer(id, title)
  109:     self._setObject(id,newObj)
  110:     if RESPONSE is not None:
  111:         RESPONSE.redirect('manage_main')
  112: 
  113: 
  114: 
  115: class OSAS_archiver(Folder, Persistent,Implicit):
  116:     """Hauptklasse fuer das Archiv"""
  117: 
  118:     meta_type="OSAS_archiver"
  119: 
  120:     # to be deleted later
  121:     #startPath="/mpiwg"
  122:     ## methoden aus dem alten archive.py
  123: 
  124:     def archiver(self,path):
  125:         """archive the documents in path"""
  126:         tmp=archive.archive(path,self.REQUEST.SESSION)
  127:         pt=PageTemplateFile('Products/OSA_system/archiveStatus.zpt').__of__(self)
  128:         return pt()
  129: 
  130:         
  131: 
  132: 
  133:     def metachecker(self,path):
  134:         """check the metadata the documents in path"""
  135:         self.REQUEST.SESSION['path']=self.REQUEST['path']
  136:         return archive.metacheck(path)
  137: 
  138:     ## methods  from OSAS_show
  139:     def changeName(self,name):
  140:         return changeName(name)
  141: 
  142:     def hasMetafile(self,path):
  143:         return hasMetafile(path)
  144: 
  145:     def getMetafile(self,path):
  146:         return getMetafile(path)
  147: 
  148:     def toggle_view(self,path,file):
  149:         """Oeffnen bzw. schließen der Subfolders"""
  150:         self.tree(path).toggle(path,file)
  151:         return self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1']+"?path="+path)
  152: 
  153: 
  154: 
  155:     def isdigilib2(self,path):
  156:         """check if digilib"""
  157:         return isdigilib2(path)
  158: 
  159:     def path_to_link_view(self,path):
  160:         """generates navigation bar for viewfiles"""
  161:         return path_to_link_view(self.REQUEST['URL'],path)
  162:     
  163: 
  164:     def tree(self,start):
  165: 	"""get the filetree"""
  166: 	k=browse(start)
  167: 	return k
  168: 
  169:     def getfilesystem2(self,start,reload=0):
  170: 	"""load filesystem"""
  171: 
  172: 	k=filesystem2(start,1)
  173: 	return k
  174: 
  175:     def getfilesystem(self,start,reload=0):
  176: 	"""load filesystem"""
  177: 
  178: 	k=filesystem(start,1)
  179: 	return k
  180: 
  181: 
  182:     ##init
  183:     def __init__(self, id, title,startPath):
  184:         """init"""
  185:         self.id=id
  186:         self.title=title
  187:         self.startPath=startPath
  188: 
  189:     def archiver_html(self):
  190:         """archiver"""
  191:         pt=PageTemplateFile('Products/OSA_system/OSAS_Archiver.zpt').__of__(self)
  192:         return pt()
  193: 
  194:     def index_html(self):
  195:         """main page"""
  196:         pt=PageTemplateFile('Products/OSA_system/archiverIndex.zpt').__of__(self)
  197:         return pt()
  198:     
  199:     def newFolders_html(self):
  200:         """main page"""
  201:         pt=PageTemplateFile('Products/OSA_system/newFolders.zpt').__of__(self)
  202:         return pt()
  203: 
  204:     def getProducers(self):
  205:         """Ausgabe der registrierten Benutzer"""
  206:         ret=[]
  207:         #print self.aq_parent.__dict__
  208:         for list in self.producerFolder.__dict__:
  209:             obj=getattr(self.producerFolder,list)
  210:             if (hasattr(obj,"meta_type")):
  211:                 if (obj.meta_type=="OSAS_producer"):
  212:                     ret.append(obj.getId())
  213:         return ret
  214: 
  215:     def getProducer(self,id):
  216:         """Gebe ProducerObjekt zurück"""
  217:         obj=getattr(self.aq_parent.producerFolder,id)
  218:         return obj
  219:         
  220:         
  221: 
  222:     def createFoldersForm(self,producer,number):
  223:         """Erzeuge Folder im producer Verzeichnis mit ids"""
  224:         self.REQUEST.SESSION['producer']=producer
  225:         self.REQUEST.SESSION['ids']=self.idGenerator.giveIdsOut(number)
  226:         pt=PageTemplateFile('Products/OSA_system/createFoldersForm.zpt').__of__(self)
  227:         return pt()
  228:     
  229:     def createFolders(self,folderList,producer):
  230:         """Erzeug die entsprechenden Folder"""
  231:         for folder in folderList:
  232:             os.mkdir(self.startPath+"/"+producer+"/"+folder)
  233:         self.REQUEST.SESSION['folderList']=folderList
  234:         pt=PageTemplateFile('Products/OSA_system/createFolders.zpt').__of__(self)
  235:         return pt()
  236: 
  237:     def archiveSelected(self):
  238:         """Archiviere ausgewaehlte files"""
  239:         pt=PageTemplateFile('Products/OSA_system/archiveSelected.zpt').__of__(self)
  240:         return pt()
  241: 
  242:     def enterAcquisitionMetadata(self):
  243:         """Erstelle Metadaten fuer Acquisition"""
  244: 
  245:     def enterPreliminaryBibMeta(self):
  246:         """Erstelle Metadaten fuer Bibliography"""
  247:         
  248:     def showFilesForArchiving(self):
  249:         """Anzeige der noch zu archivieren Files"""
  250: 
  251:         
  252: 
  253:     
  254: 
  255: def manage_AddOSAS_archiverForm(self):
  256:     """interface for adding the OSAS_root"""
  257:     pt=PageTemplateFile('Products/OSA_system/AddOSAS_archiver.zpt').__of__(self)
  258:     return pt()
  259: 
  260: 
  261: def manage_AddOSAS_archiver(self,id,startPath,title="",RESPONSE=None):
  262:     """add the OSAS_root"""
  263:     if title=="":
  264:         title=id
  265:         
  266:     newObj=OSAS_archiver(id, title,startPath)
  267:     self._setObject(id,newObj)
  268:     if RESPONSE is not None:
  269:         RESPONSE.redirect('manage_main')
  270: 
  271: 
  272: class OSAS_producer(Image,Persistent,Implicit):
  273:     """Klasse fuer Produzenteninformationen"""
  274: 
  275:     meta_type="OSAS_producer"
  276: 
  277:     def __init__(self,shortName,fullName):
  278: 
  279:         self.id=shortName
  280:         self.title=fullName
  281: 
  282: 
  283: def manage_AddOSAS_producerForm(self):
  284:     """interface for adding the OSAS_root"""
  285:     pt=PageTemplateFile('Products/OSA_system/AddOSAS_producer.zpt').__of__(self)
  286:     return pt()
  287: 
  288: 
  289: def manage_AddOSAS_producer(self,id,title="",RESPONSE=None):
  290:     """add the OSAS_root"""
  291:     if title=="":
  292:         title=id
  293:         
  294:     newObj=OSAS_producer(id, title)
  295:     self._setObject(id,newObj)
  296:     if RESPONSE is not None:
  297:         RESPONSE.redirect('manage_main')
  298: