[BACK]Return to ECHO_collection.py CVS log [TXT] [DIR] Up to [Repository] / ECHO_content

Diff for /ECHO_content/ECHO_collection.py between versions 1.310.2.7 and 1.310.2.8

version 1.310.2.7, 2012/08/23 10:25:32 version 1.310.2.8, 2012/08/29 07:53:31
Line 86  import xmlrpclib Line 86  import xmlrpclib
   
 import logging  import logging
   
   from ECHO_root  import ECHO_root
   
 #ersetzt logging.info  #ersetzt logging.info
 def logger(txt,method,txt2):  def logger(txt,method,txt2):
     """logging"""      """logging"""
Line 1086  class ECHO_collection(CatalogAware, Fold Line 1088  class ECHO_collection(CatalogAware, Fold
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def changeViewerTemplateSetsForm(self):  
       def changeViewerForm(self):
             """change the viewer template set"""              """change the viewer template set"""
             pt=zptFile(self, 'zpt/changeViewerTemplateSet')              pt=zptFile(self, 'zpt/changeECHOViewer')
             return pt()              return pt()
   
     def getViewerTemplateSets(self,obj_ids=None,RESPONSE=None):  
             """Get the ViewerTemplateSet title for configuration"""  
             ret=[]  
               
             try:  
                     viewerTemplateSets=self.ZopeFind(self.viewerTemplateSets,obj_metatypes=['OSAS_viewerTemplateSet'],obj_ids=obj_ids)#assumes viewerTemplateSets folder somewhere in the hierarchie.  
               
                     for viewerTemplateSet in viewerTemplateSets:  
                             ret.append((viewerTemplateSet[1].title,viewerTemplateSet[0],viewerTemplateSet[1]))  
   
                     return ret  
                       
             except:  
                     return [('no ViewerTemplateSetfolders','')]  
   
     def getTextToolsField(self,name,default=''):      def getTextToolsField(self,name,default=''):
             """Lese viewerTemplateSet der Collection not implemented yet!"""              """Lese text tool field  der Collection not implemented yet!"""
                           
             return default              return default
   
                           
     def isSelectedViewerTemplateSet(self,obj,id):  
         """is ausgewaehlt"""  
           
         if self.REQUEST['viewerTemplateSet']==id:  
             return 1  
         else:  
             return None  
   
     def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):      def changeViewer(self,newViewer,REQUEST=None,RESPONSE=None):
         """changes all ressources to the newViewer"""          """changes all ressources to the newViewer"""
Line 1410  class ECHO_collection(CatalogAware, Fold Line 1391  class ECHO_collection(CatalogAware, Fold
         {'label':'Export/Import Objects','action':'exportImportObjects_html'},          {'label':'Export/Import Objects','action':'exportImportObjects_html'},
         {'label':'Graphic Coords','action':'ECHO_graphicEntry'},          {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
         {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},          {'label':'create resources from XML','action':'createRessourcesFromXMLForm'},
         {'label':'Change Viewer Templates and Image Viewer','action':'changeViewerTemplateSetsForm'},          {'label':'Change Image Viewer','action':'changeViewerForm'},
         {'label':'ImportCollection','action':'importCollection'},          {'label':'ImportCollection','action':'importCollection'},
         {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},          {'label':'Change access rights',  'action':'changeAccessRightsCollectionForm'},
         )          )
Line 1893  def createNode(self,descrs,node): Line 1874  def createNode(self,descrs,node):
         return "XX"          return "XX"
   
   
 class ECHO_root(Folder,Persistent,Implicit):  
     """ECHO Root Folder"""  
   
     security=ClassSecurityInfo()  
       
     meta_type="ECHO_root"  
     management_page_charset="utf-8"  
       
     getSubCols = ECHO_helpers.getSubCols  
   
     manage_options=Folder.manage_options+(  
                 {'label':'Main Config','action':'ECHO_copyright_configForm'},  
                 {'label':'Change Weights','action':'changeWeights'},  
                 {'label':'Generate from RDF','action':'generateFromRDFForm'},  
                 {'label':'update Resource Catalog','action':'updateResourceCatalog'},  
                )  
   
   
   
   
     def getECHORootURL(self):  
         return self.absolute_url()  
       
     def getECHORoot(self):  
         return self  
   
     def getBrowserType(self):  
         """returns browserType object"""  
         return browserType(self)  
       
     def mod_re_sub(self,pattern,replace,string):  
         """re.sub aus mod re zur Verfuegung stellen"""  
         return re.sub(pattern,replace,string)  
       
     def findObjectFromFulltext(self,existUri):  
         '''  
           
         @param url:  
         @param existUri:  
         '''  
   
         if existUri:  
             #TODO: at the moment assume that the filename is unique, the whole has to changed to a system of ids.  
             filename=existUri.split("/")[-1]  
           
         founds=self.resourceCatalog.search({'fullTextUrl':os.path.splitext(filename)[0]})    
           
         ret=[(found.title,found.getObject().absolute_url(),found.getObject().aq_parent.absolute_url()) for found in founds]  
           
         return ret  
           
     def reindex(self,RESPONSE=None):  
         """indiziere alle Objecte neu"""  
           
         if RESPONSE:  
             RESPONSE.write("<html><body>")  
           
         resources=self.ZopeFind(self,obj_metatypes=["ECHO_resource"], search_sub=1)  
           
         for resource in resources:  
             resource[1].reindex()  
             #print "<p> done %s </p>\n"  
             if RESPONSE:  
                 RESPONSE.write("<p> done %s </p>\n"%resource[0])  
                   
         if RESPONSE:  
             RESPONSE.write("<p> ok </p></html></body>\n")  
               
   
     def setLanguage(self,lang):  
             """Set language cookie"""  
             self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")  
   
     def switchLanguage(self):  
             """Set language cookie"""  
             if self.getLanguage()=="en":  
                     lang="de"  
             else:  
                     lang="en"  
               
             self.REQUEST.RESPONSE.setCookie('lang_exhibition',lang,path="/")  
             self.REQUEST.RESPONSE.redirect(self.REQUEST['URL1'])  
               
     def getLanguage(self):  
             """get language cookie"""  
             lang= self.REQUEST.cookies.get('lang_exhibition','de')  
             if lang == '':  
                     lang="de"  
             return lang  
       
     def getContentOverviewTemplate(self):  
         """produces overview template with macro"""  
         pt = zptObjectOrFile(self, 'content_overview_template')  
         return pt  
   
     def mapstyle_css(self):  
         """send mapstyle.css"""  
         sendFile(self, 'html/ECHO_mapstyle.css', 'text/css')  
   
   
     ###Cdli adds -> have to be removed  
     def getTablet(self,item):  
         #print "getTablet"  
         try:  
                 read=urllib.urlopen("http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"%item).read()  
                 read=re.sub("\[search\]","search",read)  
                 return read[read.find("<body>")+6:read.rfind("</body>")]  
         except:  
                 return "<h1>Sorry no connection to the data server enlil.museum.upenn.edu</h1>"  
         #return "http://enlil.museum.upenn.edu/cgi-bin/cdlget.plx?item=%s&project=ncdl"  
     ###END CDLI add  
   
   
     def URLquote(self, text):  
         """urllib.quote fuer Michael"""  
         return urllib.quote(text)  
   
   
     def checkResource(self,id):  
             """checks if a resource is in the tree, gives back none or list of resources"""  
             if not id:  
                 id=""  
             splitted=id.split("/")  
             id=splitted[len(splitted)-1]  
             if hasattr(self,"_v_checkResource") and self._v_checkResource.has_key(id): #existiert ein cache und id ist bereits drin?  
                             return self._v_checkResource[id]  
   
             else:  
                     resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource'],obj_ids=[id],search_sub=1)  
   
                     if not hasattr(self,"_v_checkResource"): self._v_checkResource={}#lege cache an falls nicht existent  
                     if resources:  
                             self._v_checkResource[id]=resources[0:] # slicing to be sure that data is stabil  
                     else:  
                             self._v_checkResource[id]=None  
                       
                     return self._v_checkResource[id]  
               
     def sendForm(self,fromaddr,content,server='mail.mpiwg-berlin.mpg.de'):  
             """sendform"""  
             toaddrs=["dwinter@mpiwg-berlin.mpg.de"]  
               
             msg = ("From: %s\r\nTo: %s\r\nSubject: %s\r\n\r\n"  
                    % (fromaddr, ", ".join(toaddrs),"testsub"))  
             server = smtplib.SMTP(server)  
             #server.set_debuglevel(1)  
             msg=msg+content  
             server.sendmail(fromaddr, toaddrs, msg)  
             server.quit()  
                    
     def generateFromRDFForm(self):  
                 """change form"""  
                 pt=zptFile(self, 'zpt/generateFromRDFForm')  
                 pt.content_type="text/html"  
                 return pt()  
   
     def generateFromRDF(self,file,startNode="/Cuneiform Corpus"):  
   
             """generate from RDF"""  
   
             global seqs  
             seqs={}  
             global descrs  
             descrs={}  
             global key  
             key=""  
             global value  
             value=""  
   
             def getEdges(seqs,urn):  
                     """edges"""  
                     ret=[]  
                     return seqs[urn]  
   
             def createSubs(self,seqs,descrs,urn,level=0):  
                     """create subs"""  
                     for edge in getEdges(seqs,urn):  
                             cn=createNode(self,descrs,edge)  
                             if cn[0]=="CDLI_group":  
                                     createSubs(cn[1],seqs,descrs,cn[2],level+1)  
                     return  
   
             def start_element(name,attrs):  
   
                     global seqs  
                     global descrs  
                     global key  
                     global value  
                     seq=""  
                     if name=="rdf:Seq":  
                             key=attrs.get('rdf:about')  
                             try: # teste ob liste  
                                     x=seqs[key][0]  
                             except:  
   
                                     seqs[key]=[]  
   
                       
                     elif name=="rdf:Description":  
                             key=attrs.get('rdf:about')  
                               
   
                     elif name=="rdf:li":  
                             name=attrs.get('rdf:resource')  
                             seqs[key].append(name)  
   
                     elif name=="echonavigation:type":  
                             value="type"  
   
                     elif name=="echonavigation:name":  
                             value="name"  
                     elif name=="echonavigation:linkClickable":  
                             value="linkClickable"  
                               
             def end_element(name):  
                             """nothing"""  
                             key=""  
                             value=""  
   
             def char_data(data):  
                     """nothing"""  
   
                     data=re.sub("\n","",data)  
                     try:  
                             if descrs[key].has_key(value):  
                                     descrs[key][value]+=data  
                             else:  
                                     descrs[key][value]=data  
                     except:  
   
                             descrs[key]={}  
                             descrs[key][value]=data  
                               
             p = xml.parsers.expat.ParserCreate()  
               
             p.StartElementHandler = start_element  
             p.EndElementHandler = end_element  
             p.CharacterDataHandler = char_data  
               
               
             p.ParseFile(file)  
             self.REQUEST.RESPONSE.write("<html><body><h1>Start</h1>")  
             createSubs(self,seqs,descrs,startNode)  
             self.REQUEST.RESPONSE.write("<h1>done</h1></body></html>")  
             #print "done"  
   
               
             return "done"  
       
               
   
                   
     def changeWeightsInCollection(self):  
             """change all lables of a collection"""  
             ret=""  
             argv=self.REQUEST.form  
               
             resources=self.ZopeFind(self,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_link','ECHO_externalLink'])  
             for resource in resources:  
                      
                     try:  
                             ret+=resource[1].getId()+"   "+argv[resource[1].getId()]+"</br>"  
                             resource[1].weight=argv[resource[1].getId()][0:]  
                     except:  
                             pass  
             return ret  
   
     def changeWeights(self):  
                 """change form"""  
                 pt=zptFile(self, 'zpt/changeWeightForm')  
                 pt.content_type="text/html"  
                 return pt()  
     
       
     def getRDF(self,urn=None):  
             """rdf of the collection"""  
   
             contents=self.ZopeFind(self,obj_metatypes=['ECHO_group','ECHO_resource','ECHO_collection'])  
   
             ret=getRDFDescription(self,self.absolute_url(),urn=urn)  
               
             li="""<rdf:li rdf:resource="%s" />\n"""  
   
               
             for content in contents:  
                     ret+=content[1].getRDF()+"\n"  
                       
             ret+="""<rdf:Seq rdf:about="%s">\n"""%urn  
             for content in contents:  
                     nurn=content[1].absolute_url()  
                     ret+=li%nurn  
             return ret+"</rdf:Seq>"  
               
   
     def showContent(self,path):  
             """return content/html"""  
               
             return ECHO_helpers.urlopen(path+"/content_html").read()  
       
     def getImageViewers(self):  
         """images"""  
         viewers=self.ZopeFind(self.standardImageViewer,obj_metatypes=['OSAS_ViewerObject'])  
         return viewers  
       
   
     def getBibTag(self,tag,content):  
             """get field tag for index-meta-generation"""  
             if not content or content=="":  
                     return ""  
             ret="<%s>"%tag  
             #ret+=urllib.quote(content)  
             ret+=content  
   
             ret+="</%s>"%tag  
             return ret  
   
     def getValueFromClass(self,field,found):  
             """ret attribute if existing"""  
             try:  
                       
   
                     return getattr(found,field)#.decode('ascii','ignore')  
   
   
   
             except:  
                     logging.error("can't: decode: %s"%repr(field))  
                     logging.error("      %s %s"%(sys.exc_info()[0],sys.exc_info()[1]))  
                     return ""  
   
     security.declarePublic('getImageTag')  
     def getImageTag(self):  
             """needed by main_template"""  
             return ""  
           
     secondaryLink="" #needed by main_template  
     secondaryLinkTitle="" #needed by main_template  
       
     def getBgcolour(self):  
         """hack"""  
         return "#dddddd"  
   
     security.declareProtected('View','contentTypeSelector_HTML')  
     def contentTypeSelector_HTML(self,selected=None):  
         """give type selector"""  
         if not selected:  
             retStr="<option selected>\n"  
         else:  
             retStr="<option>\n"  
               
         try: # erste version contentTypes exists  
             for contentType in self.ZopeFind(self.contentTypes,obj_metatypes=["ECHO_contentType","OSAS_MetadataMapping"]):  
                 if selected and (contentType[0]==selected):  
                     retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])  
                 else:                  
                     retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])  
         except:  
                 try:  
                         for contentType in self.ZopeFind(self.standardMD,obj_metatypes=["OSAS_MetadataMapping"]):  
                                 if selected and (contentType[0]==selected):  
                                         retStr+="""<option selected value="%s">%s\n"""%(contentType[0],contentType[0])  
                                 else:                  
                                         retStr+="""<option value="%s">%s\n"""%(contentType[0],contentType[0])  
                 except:  
                         """nothing"""  
                               
         return retStr  
   
     def renderingTypeSelector_HTML(self,selected=None):  
          """give type selector"""  
          if not selected:  
                  retStr="<option selected>\n"  
          else:  
                  retStr="<option>\n"  
                    
          try: # erste version renderingTypes exists  
                  for renderingType in self.ZopeFind(self.renderingTypes,obj_metatypes=["ECHO_renderingType"]):  
                          if selected and (renderingType[0]==selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(renderingType[0],renderingType[0])  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(renderingType[0],renderingType[0])  
          except:  
                  """nothing"""  
          return retStr  
   
   
     def copyrightTypeSelector_HTML(self, object=None, selected=None,first=None):  
          """give type selector"""  
   
          if not first:  
                  if not selected:  
                          retStr="<option selected>\n"  
                  else:  
                          retStr="<option>\n"  
          else:  
                  if not selected:  
                          retStr="""<option selected value="%s">%s\n"""%first  
                  else:  
                          retStr="""<option value="%s">%s\n"""%first  
   
            
          try: # erste version copyrightTypes exists  
                  for copyrightType in self.ZopeFind(self.copyrightTypes,obj_metatypes=["ECHO_copyrightType"]):  
                          if selected and (copyrightType[0]==selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
                    
                  for copyrightTypeSelf in self.ZopeFind(object,obj_metatypes=["ECHO_copyrightType"],search_sub=1):  
                          if selected and (copyrightTypeSelf[0]==selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(copyrightTypeSelf[0],copyrightTypeSelf[0])  
                                    
          except:  
              """nothing"""  
                    
          return retStr  
   
     def partnerSelector_HTML(self,selected=None):  
          """give type selector"""  
          if not selected:  
                  retStr="<option selected>\n"  
          else:  
                  retStr="<option>\n"  
                    
          try: # erste version copyrightTypes exists  
                  for copyrightType in self.ZopeFind(self.partners,obj_metatypes=["ECHO_partner"]):  
                          if selected and (copyrightType[0]==selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(copyrightType[0],copyrightType[0])  
          except:  
                  """nothing"""  
          return retStr  
    
     mediaTypes=['all','text','images','sound','video'] # konfigurierbar in neuer version ueber echoroot??  
   
     def mediaTypeSelector_HTML(self,selected=None):  
          """give type selector"""  
          if not selected:  
                  retStr="<option selected>\n"  
          else:  
                  retStr="<option>\n"  
            
          try: # erste version mediatypesTypes exists  
                  for mediaType in self.mediaTypes:  
                          if selected and (mediaType in selected):  
                                  retStr+="""<option selected value="%s">%s\n"""%(mediaType,mediaType)  
                          else:                  
                                  retStr+="""<option value="%s">%s\n"""%(mediaType,mediaType)  
          except:  
                  """nothing"""  
          return retStr  
   
               
     def patchContentType(self,obj=None):  
         """austauschen content_type with contentType (patch bei umstieg von alter Version)"""  
       
   
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_externalLink','ECHO_pageTemplate'])  
   
         for entry in entries:  
                 setattr(entry[1],'contentType',entry[1].content_type)  
                 #entry[1].contentType == entry[1].content_type  
   
                 if entry[1].meta_type == 'ECHO_collection':  
                     entry[1].patchContentType(entry[1])      
   
                   
         return "changed all contenttypes in: "+self.title  
   
   
     def repairAllCoords(self):  
         """updates map coordinates on the same and sublevels"""  
         return repairCoords(self)  
   
   
     def patchViewClassification(self,obj=None):  
         """setze viewClassification heuristisch"""  
   
         def checkIfArrow(obj):  
                 if hasattr(obj,'coords'):  
                         for coordtemp in obj.coords:  
   
                                 if (len(coordtemp)>4) and not (coordtemp[4]==''):  
                                         return 4  
                         return None  
                 return None  
           
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection','ECHO_group'])  
   
         for entry in entries:  
                   
                 if checkIfArrow(entry[1]):  
                         setattr(entry[1],'viewClassification','view point')  
                 else:  
                         setattr(entry[1],'viewClassification','area')  
   
                 #entry[1].contentType == entry[1].content_type  
   
                 if entry[1].meta_type in ['ECHO_collection','ECHO_group']:  
                     entry[1].patchViewClassification(entry[1])      
   
                   
         return "changed all contenttypes in: "+self.title  
   
     def deleteCache(self,obj=None,RESPONSE=None):  
         """setze alle collections auf cache = CacheManager"""  
         if not obj:  
             obj = self  
         entries=obj.ZopeFind(obj,search_sub=1)  
         for entry in entries:  
                 if hasattr(entry[1],'_v_hash'):  
                         entry[1]._v_hash=None  
           
         return "changed all CM in: "+self.title  
   
       
     security.declarePublic('ECHO_newViewerLink')  
     def ECHO_newViewerLink(self,obj=None):  
         """change links (:86 faellt weg)"""  
   
         if not obj:  
             obj = self  
               
         entries=obj.ZopeFind(obj,obj_metatypes=['ECHO_resource','ECHO_collection'])  
   
         for entry in entries:  
                   
                 if entry[1].meta_type == 'ECHO_resource':  
                       
                     entry[1].link=re.sub('\:86','',entry[1].link)  
   
                 else:  
                       
                     entry[1].ECHO_newViewerLink(entry[1])  
                   
         return "Rerenderd all links to resources in: "+self.title  
   
     def __init__(self,id,title):  
         """init"""  
         self.id = id  
         self.title=title  
   
     def deleteSpace(self,str):  
         """delete space at the end of a line"""  
         if str[len(str)-1]==" ":  
             return str[0:len(str)-1]  
         else:  
             return str  
           
       
   
     # zusaetliche methoden fuer das vlp muessen in ein eigenes produkt  
   
     def formatAscii(self,str,url=None):  
         """ersetze ascii umbrueche durch <br>"""  
   
     if not str:   
             return ""  
   
         if url:  
               
             retStr=""  
             words=str.split("\n")  
               
             for word in words:  
                 strUrl=url%word  
   
                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)  
             str=retStr  
         if str:  
             str = re.sub(r"[\n]","<br/>",str)  
             return unicodify(str)  
         else:  
             return u""  
           
     #link2html=vlp_xmlhelpers.link2html  
     #related2html=vlp_xmlhelpers.related2html  
   
     #xml2html=vlp_xmlhelpers.xml2html  
    
     #checkRef=vlp_xmlhelpers.checkRef  
       
 #    def checkRef(self,ref):  
 #            if ref[0:3]=='lit':  
 #                    if len(self.library_data({ 'id':ref}))>0:  
 #                            return 1  
 #            try:  
 #                    if ref[0:7]=="tec_cat":  
 #                            return 1  
 #            except:  
 #                    """nothing"""  
 #                      
 #            dbs={'vl_technology':'','vl_people':" AND complete='yes'",'vl_sites':''}  
 #            res=None  
 #            for db in dbs.keys():  
 #                    res=res or self.search(var=str("select reference from %s where reference =\'%s\' %s"%(db,ref,dbs[db])))  
 #            return res  
 #                                      
 #    #Ende Methode fuer vlp  
   
     def PgQuoteString(self,string):  
         """Quote string"""  
   
         return libpq.PgQuoteString(string)  
   
     security.declareProtected('View','getPartners')  
     def getPartners(self):  
         """Get list of Partners. Presently only from a subfolder partners"""  
         if hasattr(self,'partners'):              
                 ret = [ item[1] for item in self.partners.ZopeFind(self.partners,obj_metatypes=['ECHO_partner'])]  
                 def sort_title(one, another) : return cmp(one.title, another.title)  
                 ret.sort(sort_title)  
                 return ret  
         else:  
                 return []  
     
     def getInstitutions(self):  
         """Get list of Partners. Presently only from a subfolder partners"""  
                       
         return [ item[1] for item in self.institutions.ZopeFind(self.institutions,obj_metatypes=['ECHO_institution'])]  
   
      
     def getPartnersXML(self):  
         """partner liste als xml"""   
         partners=self.getPartners()  
         ret="""<?xml version="1.0" encoding="utf-8" ?>  
         <partners>"""  
           
         for partner in partners:  
             ret+="""<partner id="%s" title="%s"/>\n"""%(partner.getId(),partner.title)  
   
         return ret+"\n</partners>"  
       
     def getCollectionTree(self):  
         """get the collection tree (list of triples (parent,child, depth)"""  
   
         def getCollection(object,depth=0):  
             depth+=1  
             collections=[]  
             for entry in object.__dict__.keys():  
                 element=getattr(object,entry)  
                 try:  
                     if element.meta_type=="ECHO_collection":  
                         collections.append((object,element,depth))  
                         collections+=getCollection(element,depth)  
                 except:  
                     """nothing"""  
             return collections  
           
   
         return getCollection(self)  
       
     def getCollectionTreeIds(self):  
         """Show the IDs of the Tree"""  
         ret=[]  
         for collection in self.getCollectionTree():  
             ret.append((collection[0].getId(),collection[1].getId(),collection[2]))  
         return ret  
   
     def getResourcesHTML(self,viewerType=None,filter=None):  
             """gebe all ressourcen aus"""  
   
             def sortHTML(x,y):  
                     return cmp(x[1].title,y[1].title)  
               
             ret="""<html><body><h2>Resources in ECHO</h3>"""  
               
             resources = self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1)  
             ret+="""<h3>Found %i resources</h3>"""%len(resources)  
             resources.sort(sortHTML)  
             for resource in resources:  
                     echo_url=resource[1].absolute_url()  
                       
                     if hasattr(resource[1],'title'):  
                             title=resource[1].title  
                     else:  
                             title="None"  
                     if filter:  
                             if re.search(filter,title):  
                                     ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)  
                     else:  
                             ret+="""\n<p><a href="%s">%s</a></p>"""%(echo_url,title)  
   
             ret +="""\n</body></html>"""  
               
             #self.REQUEST.RESPONSE.setHeader("Content-Type", "text/html")  
             #self.REQUEST.RESPONSE.write(ret)  
             return ret  
       
     def getResourcesXML(self,viewerType=None,filter=None):  
             """gebe all ressourcen aus"""  
             ret="""<?xml version="1.0" ?>  
                      <index>"""  
             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource','VLP_resource'],search_sub=1):  
   
                     echo_url=resource[1].absolute_url()  
                     if hasattr(resource[1],'link'):  
                             viewer_url=resource[1].link  
                     else:  
                             viewer_url="NO URL"  
                     if filter:  
                             if re.search(filter,viewer_url):  
                                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
                     else:  
                             ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
             ret +="""\n</index>"""  
               
             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
             self.REQUEST.RESPONSE.write(ret)  
   
     def getCollectionsXML(self,viewerType=None,filter=None):  
             """gebe collections aus"""  
             ret="""<?xml version="1.0" ?>  
                      <index>"""  
             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_collection','ECHO_group'],search_sub=1):  
   
                     echo_url=resource[1].absolute_url()  
                    
                     ret+="""\n<collection echoLink="%s"/>"""%urllib.quote(echo_url,safe='/:?')  
             ret +="""\n</index>"""  
               
             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
             self.REQUEST.RESPONSE.write(ret)  
   
     def getFullTextsXML(self,viewerType=None,filter=None):  
             """gebe all ressourcen aus"""  
             ret="""<?xml version="1.0" ?>  
                      <index>"""  
             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
                     echo_url=resource[1].absolute_url()  
                     if resource[1].getFullTextXML(noredirect="yes"):  
                             if hasattr(resource[1],'link'):  
                                     viewer_url=echo_url+"/getFullTextXML"  
                             else:  
                                     viewer_url="NO URL"  
                             if filter:  
                                     if re.search(filter,viewer_url):  
                                             ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
                             else:  
                                     ret+="""\n<resource echoLink="%s" viewerLink="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(viewer_url,safe='/:?'))  
             ret +="""\n</index>"""  
               
               
             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
             self.REQUEST.RESPONSE.write(ret)  
   
   
     def getMetaDatasXML(self,viewerType=None,filter=None):  
             """gebe all ressourcen aus"""  
             # check if the request's host part was OK  
             http_host = self.REQUEST['HTTP_HOST']  
             host_port = self.REQUEST['SERVER_PORT']  
             fix_host = None  
             if http_host and http_host.rfind(host_port) == -1:  
                     print "HTTP_HOST needs fixing!"  
                     fix_host = http_host + ":" + host_port  
   
             ret="""<?xml version="1.0" ?>  
                      <index>"""  
             for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
   
                     echo_url=resource[1].absolute_url()  
                     if fix_host:  
                             #print "replacing ", http_host, " by ", fix_host  
                             echo_url = string.replace(echo_url, http_host, fix_host, 1)  
                       
                     if hasattr(resource[1],'link'):  
                             meta_url=echo_url+"/getMetaDataXML"  
                     else:  
                             meta_url="NO_URL"  
                               
                     if filter and not re.search(filter,viewer_url):  
                             continue  
   
                     #modificationDate=time.strptime(str(resource[1].bobobase_modification_time()),"%Y/%m/%d %H:%M:%S %Z")  
                       
                     modificationDate=resource[1].bobobase_modification_time().strftime("%Y/%m/%d %H:%M:%S")  
   
                     ret+="""\n<resource resourceLink="%s" metaLink="%s" modificationDate="%s"/>"""%(urllib.quote(echo_url,safe='/:?'),urllib.quote(meta_url,safe='/:?'),modificationDate)  
                       
                               
             ret +="""\n</index>"""  
   
             self.REQUEST.RESPONSE.setHeader("Content-Type", "text/xml")  
             self.REQUEST.RESPONSE.write(ret)  
   
               
     def findPartners(self):       
         """find all partners in partners"""  
         par=self.ZopeFind(self.partners, obj_metatypes='ECHO_partner')  
         return par  
           
     def getPartnerFromID(self):  
         """find partner form ID return object"""  
         pa=self.REQUEST['partner']  
         par=self.ZopeFind(self.partners, obj_ids=[pa])  
         return par  
           
     def getPartnerFromIDParameter(self, id):  
         """ find partners from ID"""  
         par=self.ZopeFind(self.partners, obj_ids=[id])  
         return par  
           
     def getInstitutionFromID(self,id):  
         """ find institution from id """  
         inst=self.ZopeFind(self.institutions, obj_ids=[id])  
         return inst  
   
     def updateResourceCatalog(self,REQUEST,RESPONSE):  
         """update ressource catalog"""  
         catalog=getattr(self,'resourceCatalog',None)  
         if not catalog:  
             return """<html><body><h3>No resourceCatalog available</h3></body></html>"""  
           
         else:  
             class element:  
                 def __init__(self,group,name):  
                     self.group=group  
                     self.name=name  
             catalog.manage_delObjects('author splitter')  
             #elements=[element('Stop Words',""" Don't remove stop words' """),element('Word Splitter','ECHO author splitter')]  
             elements=[element('Word Splitter','ECHO author splitter')]  
             manage_addLexicon(catalog,id="author splitter",elements=elements)  
               
             return catalog.manage_catalogReindex(REQUEST,RESPONSE,'manage_main')  
               
           
     def checkMetaDataLinks(self,correct=None):  
         """check all metadatalinks and if correct is set change the servername to content.mpiwg-berlin.mpg.de"""  
           
         self.REQUEST.RESPONSE.write("<html><body>")  
         for resource in self.ZopeFind(self,obj_metatypes=['ECHO_resource'],search_sub=1):  
             metalink=resource[1].metalink  
           
             try:  
                 url=urllib.urlopen(metalink)  
             except:  
                   
                 self.REQUEST.RESPONSE.write("<p>ERROR (opening %s):"%resource[1].absolute_url() +" -- %s %s <br>"%sys.exc_info()[0:2])  
                 self.REQUEST.RESPONSE.write("-----------%s"%metalink)  
               
                 if correct:  
                     urlparsed=[x for x in urlparse.urlparse(metalink)]  
                     urlparsed[1]="content.mpiwg-berlin.mpg.de"  
                     neu=urlparse.urlunparse(urlparsed)  
                     resource[1].metalink=neu[0:]  
                     self.REQUEST.RESPONSE.write("----------changed to:%s)"%neu)  
                                   
 def manage_addECHO_root(self,id,title,RESPONSE=None):  
     """Add an ECHO_root"""  
     self._setObject(id,ECHO_root(id,title))  
       
     if RESPONSE is not None:  
         RESPONSE.redirect('manage_main')  
   
 def manage_addECHO_rootForm(self):  
         """Nothing yet"""  
         pt=zptFile(self, 'zpt/AddECHO_root.zpt')  
         return pt()  
   
 class ECHO_copyrightType(Folder,ECHO_basis):  class ECHO_copyrightType(Folder,ECHO_basis):
         """copyright typ"""          """copyright typ"""
Line 3196  def repairCoords(self): Line 2308  def repairCoords(self):
         msg += "\nDone!"          msg += "\nDone!"
         return msg          return msg
   
 from ECHO_Nav import ECHO_navigation  from ECHO_root import ECHO_main
   
 class ECHO_main(ECHO_root,ECHO_navigation):  
     """echo main object combines ECHO_root and ECHO_navigation"""  
       
     meta_type="ECHO_main"  
       
     def __init__(self,id,title):  
         """init"""  
         self.id=id  
         self.title=title  
         self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.  
         self.displayedMetaTypes=displayTypes  
           
                   
     manage_options = Folder.manage_options+(  #class ECHO_main(ECHO_root,ECHO_navigation):
         {'label':'Main Config','action':'ECHO_navigationConfigForm'},  #    """echo main object combines ECHO_root and ECHO_navigation"""
         {'label':'Cache','action':'ECHO_cacheManageForm'},  #    
         {'label':'Main Config','action':'ECHO_copyright_configForm'},  #    meta_type="ECHO_main"
         {'label':'Change Weights','action':'changeWeights'},  #    
         {'label':'Generate from RDF','action':'generateFromRDFForm'},  #    def __init__(self,id,title):
         {'label':'update Resource Catalog','action':'updateResourceCatalog'},  #        """init"""
         {'label':'Copy MD for indexing and search','action':'copySearchFields'},  #        self.id=id
         )  #        self.title=title
   #        self.pathToHierarchy="/"+self.id # hierarchie always starts with the object.
       #        self.displayedMetaTypes=displayTypes
 def manage_addECHO_mainForm(self):  #        
     """Form for adding"""  #        
     pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)  #    manage_options = Folder.manage_options+(
     return pt()  #        {'label':'Main Config','action':'ECHO_navigationConfigForm'},
   #        {'label':'Cache','action':'ECHO_cacheManageForm'},
 def manage_addECHO_main(self,id,title,RESPONSE=None):  #        {'label':'Main Config','action':'ECHO_copyright_configForm'},
     """Add an ECHO_main"""  #        {'label':'Change Weights','action':'changeWeights'},
     self._setObject(id,ECHO_main(id,title))  #        {'label':'Generate from RDF','action':'generateFromRDFForm'},
       #        {'label':'update Resource Catalog','action':'updateResourceCatalog'},
     obj=self._getOb(id)  #        {'label':'Copy MD for indexing and search','action':'copySearchFields'},
     text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()  #        )
       #
     manage_addPageTemplate(obj,'main_template',text=text)                 #    
       #def manage_addECHO_mainForm(self):
     #    """Form for adding"""
     if RESPONSE is not None:  #    pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_main.zpt')).__of__(self)
         RESPONSE.redirect('manage_main')  #    return pt()
   #
   #def manage_addECHO_main(self,id,title,RESPONSE=None):
   #    """Add an ECHO_main"""
   #    self._setObject(id,ECHO_main(id,title))
   #    
   #    obj=self._getOb(id)
   #    text=file(os.path.join(package_home(globals()),'zpt','main_template')).read()
   #    
   #    manage_addPageTemplate(obj,'main_template',text=text)               
   #    
   #  
   #    if RESPONSE is not None:
   #        RESPONSE.redirect('manage_main')
Removed from v.1.310.2.7  
changed lines
  Added in v.1.310.2.8

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>