1:
2: """preliminary object for displaying movies as part of a collection, shall be exchanged by a generalized ressource object"""
3:
4: import string
5: import tempfile
6: import re
7: import os
8: import OFS.Image
9: from types import *
10: from OFS.Cache import Cacheable
11: from OFS.Image import Image
12: from Globals import DTMLFile
13: from OFS.Folder import Folder
14: from OFS.SimpleItem import SimpleItem
15: from AccessControl import ClassSecurityInfo
16: from AccessControl.User import UserFolder
17: from Globals import InitializeClass
18: from Globals import DTMLFile
19: import Globals
20: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
21: from Products.PageTemplates.PageTemplate import PageTemplate
22: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
23: from Globals import Persistent, package_home
24: from Acquisition import Implicit
25:
26: import urllib
27: import smtplib
28: import time
29: from Ft.Xml.Domlette import NonvalidatingReader
30: from Ft.Xml.Domlette import PrettyPrint
31: from Ft.Xml import EMPTY_NAMESPACE
32:
33: import Ft.Xml.XPath
34: import cStringIO
35: import logging
36:
37: try:
38: from psycopg import libpq
39: except:
40: try:
41: from pyPgSQL import libpq
42: except:
43: print "ECHO_collection: Warning - No libpq imported!"
44:
45: import xml.dom.minidom
46:
47: import urllib
48: import xml.dom.minidom
49: import ECHO_helpers
50: from ECHO_helpers import *
51:
52: class ECHO_movie(Folder,Persistent,ECHO_basis):
53: """ECHO Ressource"""
54: security=ClassSecurityInfo()
55: meta_type='ECHO_movie'
56: contentType='movie'
57:
58: # viewClassificationList=viewClassificationListMaster
59:
60: getSubCols = ECHO_helpers.getSubCols
61:
62: security.declareProtected('View','index_html')
63:
64:
65:
66: security.declareProtected('View','createPDF')
67:
68:
69: def linkHTTP(self):
70: """protokoll fuer link html"""
71:
72: splitted=self.link.split(":")
73: if len(splitted)<2:
74: return self.link
75: else:
76: splitted[0]="http"
77:
78: ret= ":".join(splitted)
79: ret=ret.replace("//einst1","//einst3")
80: return ret
81:
82: def linkRTSP(self):
83: """protokoll fuer link html"""
84: splitted=self.link.split(":")
85: if len(splitted)<2:
86: return self.link
87: else:
88: splitted[0]="RTSP"
89:
90: ret= ":".join(splitted)
91: ret=ret.replace("//einst3","//einst1")
92: return ret
93:
94: def lowresHTTP(self):
95: """protokoll fuer link html"""
96: if getattr(self,"lowresFile","")=="":
97: return None
98:
99: splitted=self.lowresFile.split(":")
100: if len(splitted)<2:
101: return self.lowresFile
102: else:
103: splitted[0]="http"
104:
105: ret= ":".join(splitted)
106: ret=ret.replace("//einst1","//einst3")
107: return ret
108:
109: def lowresRTSP(self):
110: """protokoll fuer link html"""
111: if getattr(self,"lowresFile","")=="":
112: return None
113:
114: splitted=self.lowresFile.split(":")
115: if len(splitted)<2:
116: return self.lowresFile
117: else:
118: splitted[0]="RTSP"
119:
120: ret= ":".join(splitted)
121: ret=ret.replace("//einst3","//einst1")
122: return ret
123:
124:
125: def getRDF(self,urn=None):
126:
127: """rdf"""
128: #ret=getRDFDescription(self,self.link,urn=urn)
129: #return ret+self.createSubElementRDF(urn=urn)
130: if not urn:
131: urn=self.absolute_url()
132: ret=""
133:
134: rettemp="""<rdf:Seq rdf:about="%s">\n"""%urn
135:
136: li="""<rdf:li rdf:resource="%s" />\n"""
137: rettemp+=li%self.thumbUrl
138: rettemp+=li%self.metalink
139: rettemp+=li%self.rawFile
140: rettemp+=li%getattr(self,'lowresFile','')
141: rettemp+=li%self.link
142: rettemp+="</rdf:Seq>"
143:
144: rettemp+=getRDFDescription(self,self.thumbUrl,nameDef="thumb",typeName="thumb",urn=self.thumbUrl)
145: rettemp+=getRDFDescription(self,self.metalink,nameDef="metadata",typeName="ECHO_metaData",urn=self.metalink)
146: rettemp+=getRDFDescription(self,self.rawFile,nameDef="raw",typeName="raw_movie",urn=self.rawFile)
147: if not (getattr(self,'lowresFile','')==""):
148: rettemp+=getRDFDescription(self,self.lowresFile,nameDef="lores_movie",typeName="lores",urn=self.lowresFile)
149: rettemp+=getRDFDescription(self,self.link,nameDef="hires",typeName="hires_movie",urn=self.link)
150: return rettemp
151:
152: def getAccessRightSelectorHTML(self,outlook="select"):
153: """htmlselector"""
154: values=['free','mpiwg']
155:
156: if outlook=="select":
157: ret="""<select name="%s">"""%self.getId()
158:
159: for value in values:
160: if value==self.getAccessRightMD():
161: ret+="<option selected>%s</option>"%value
162: else:
163: ret+="<option>%s</option>"%value
164: return ret+"</select>"
165:
166: else:
167: ret=""
168: for value in values:
169:
170: if value==self.getAccessRightMD():
171: ret+="""<input type="radio" name="%s" value="%s" checked>%s"""%(self.getId(),value,value)
172: else:
173: ret+="""<input type="radio" name="%s" value="%s">%s"""%(self.getId(),value,value)
174: return ret
175:
176:
177:
178: def getAccessRightMD(self):
179: """set accessright"""
180: url=self.metalink
181:
182: try:
183: geturl=""
184: for line in ECHO_helpers.urlopen(url).readlines():
185: geturl=geturl+line
186:
187:
188: except:
189: return (None,"Cannot open: "+url)
190:
191: try:
192: dom=xml.dom.minidom.parseString(geturl)
193: root=dom.getElementsByTagName('resource')[0]
194: except:
195: return (None,"Cannot parse: "+url+"<br>"+geturl)
196:
197: internal=dom.getElementsByTagName('internal')
198: if internal:
199: institution=dom.getElementsByTagName('institution')
200: return getText(institution[0].childNodes)
201:
202: free=dom.getElementsByTagName('free')
203: if free:
204: return "free"
205:
206: return "free" #default free
207:
208: def changeAccessRightMD(self,accessright,RESPONSE=None):
209: """change the rights"""
210:
211: params="accessright=%s"%accessright
212:
213:
214: #print ECHO_helpers.urlopen(self.absolute_url()+'/setAccessRightXML'+'?'+params).read()
215:
216:
217: ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/setAccessRightXML'+urllib.quote('?'+params))).read()
218:
219:
220: if RESPONSE is not None:
221: RESPONSE.redirect('manage_main')
222:
223:
224: def setAccessRightXML(self,accessright):
225: """set accessright"""
226: url=self.metalink
227:
228: try:
229: geturl=""
230: for line in ECHO_helpers.urlopen(url).readlines():
231: geturl=geturl+line
232:
233:
234: except:
235: return (None,"Cannot open: "+url)
236:
237: try:
238: dom=xml.dom.minidom.parseString(geturl)
239: root=dom.getElementsByTagName('resource')[0]
240: except:
241: return (None,"Cannot parse: "+url+"<br>"+geturl)
242:
243: metanodes=dom.getElementsByTagName('access-conditions')
244:
245: if not metanodes:
246: nodenew=dom.createElement('access-conditions')
247: root.appendChild(nodenew)
248: metanode=nodenew
249: else:
250: metanode=metanodes[0]
251:
252: accesses=metanode.getElementsByTagName('access')
253:
254: if not accesses:
255: nodenew2=dom.createElement('access')
256: metanode.appendChild(nodenew2)
257: metanode2=nodenew2
258: else:
259: metanode2=accesses[0]
260:
261: internal=metanode.getElementsByTagName('internal')
262:
263: if internal:
264: metanode2.removeChild(internal[0]).unlink()
265:
266: free=metanode.getElementsByTagName('free')
267:
268: if free:
269: metanode2.removeChild(internal[0]).unlink()
270:
271:
272: if accessright=='free':
273: nodenew3=dom.createElement('free')
274: metanode2.appendChild(nodenew3)
275: elif accessright=='mpiwg':
276: nodenew3=dom.createElement('internal')
277: nodenew4=dom.createElement('institution')
278: metanodetext=dom.createTextNode('mpiwg')
279: nodenew4.appendChild(metanodetext)
280: nodenew3.appendChild(nodenew4)
281: metanode2.appendChild(nodenew3)
282:
283: return dom.toxml().encode('utf-8')
284:
285:
286:
287: def copyTitleToInfoXML(self,RESPONSE=None):
288: """copy title from the resource"""
289: presentationXML=readFieldFromXML(self.metalink,'texttool','presentation')
290: resourcepath=readFieldFromXML_xpath(self.metalink,'//resource/archive-path')
291: if (not presentationXML) or (not resourcepath):
292: if RESPONSE:
293: RESPONSE.write("Error: %s\n"%self.getId())
294: else:
295: return None,self.absolute_url()
296:
297: try:
298: fh=file(os.path.join(resourcepath,presentationXML),'w')
299: fh.write("""<info>
300: <author></author>
301: <title>%s</title>
302: <date></date>
303: <display>yes</display>
304: </info>"""%self.title)
305: fh.close()
306: return 1,self.getId()
307: except:
308: if RESPONSE:
309: RESPONSE.write("Error: %s\n"%self.getId())
310: else:
311: return None,self.absolute_url()
312:
313:
314:
315:
316: security.declarePublic('content_html')
317: def content_html(self):
318: """template fuer content"""
319: return ECHO_basis.content_html(self,'movie')
320:
321: # def getViewClassification(self):
322: # if hasattr(self,'viewClassification'):
323: # return self.viewClassification
324: # else:
325: # return ""
326:
327:
328: def getCopyrightsHTML(self):
329: """gib (link auf copyright link, mediatyp, institution, copyrightType, label von copyrightType) aus"""
330:
331: if hasattr(self,'copyrightModel'):
332: obj=self.copyrightModel
333:
334: else:
335: return "ERROR"
336: ret=[]
337:
338: for copyright in obj.getCopyrights(): #copyright - media / partner / copyrightID
339:
340:
341: try:
342: if hasattr(self.copyrightTypes,copyright[2]):
343: copyrightTypeObj=getattr(self.copyrightTypes,copyright[2])
344: link="copyrightTypes/"+copyright[2]+'/copyright.html'
345: else:
346: copyrightTypeObj=getattr(obj,copyright[2])
347: link="copyrightModel/"+copyright[2]+'/copyright.html'
348:
349: label=copyrightTypeObj.label
350: url=getattr(copyrightTypeObj, 'url', '')
351:
352: if url!='':
353: ret.append((url,copyright[0],copyright[1],copyright[2],label))
354: else:
355: if hasattr(copyrightTypeObj, 'copyright.html'):
356: ret.append(("""%s?partner=%s"""%(link,copyright[1]),copyright[0],copyright[1],copyright[2],label))
357: else:
358: ret.append(('empty',copyright[0],copyright[1],copyright[2],label))
359: except:
360: """nothing"""
361:
362: return ret
363:
364: def getInstitutionsHTML(self):
365: """gibt Liste der foerdernden Institutionen aus"""
366:
367: if hasattr(self,'support'):
368: obj=self.support
369: ret=obj.getSupporter()
370: return ret
371: else:
372: return ''
373:
374:
375: def getCredits(self):
376: """Ausgabe der credits"""
377: if self.credits:
378: return self.credits
379: else:
380: return []
381:
382:
383:
384: def __init__(self,id,link,thumbUrl,rawFile,lowresFile,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords):
385:
386: self.id = id
387: """Festlegen der ID"""
388:
389: self.label = label
390: self.link= link
391: self.metalink=metalink
392: self.title=title
393: self.weight=weight
394: self.credits=toList(credits)
395: self.description=description
396: self.contentType=contentType
397: self.copyrightType=copyrightType
398: self.renderingType=renderingType
399: self.responsible=responsible
400: self.resourceID=resourceID
401: self.thumbUrl=thumbUrl
402: self.rawFile=rawFile
403: self.lowresFile=lowresFile
404:
405: if coords:
406: coordsnew=[ string.split(x,",") for x in coords]
407: else:
408: coordsnew=[]
409:
410: self.coords=coordsnew
411: # self.viewClassification=""
412:
413:
414:
415: def getContentType(self):
416: try:
417: return self.contentType
418: except:
419: return ""
420:
421: def getCopyrightType(self):
422: try:
423: return self.copyrightType
424: except:
425: return ""
426:
427: def getRenderingType(self):
428: try:
429: return self.renderingType
430: except:
431: return ""
432:
433: def ECHO_movie_config(self):
434: """Main configuration"""
435:
436: if not hasattr(self,'weight'):
437: self.weight=""
438:
439: pt=zptFile(self, 'zpt/ChangeECHO_movie.zpt')
440: return pt()
441:
442:
443: def ECHO_movie_config_main(self):
444: """Main configuration"""
445: if not hasattr(self,'weight'):
446: self.weight=""
447: pt=zptFile(self, 'zpt/ChangeECHO_movie_main.zpt')
448: return pt()
449:
450: def ECHO_movie_config_coords(self):
451: """Coords configuration """
452: pt=zptFile(self, 'zpt/ChangeECHO_movie_coords.zpt')
453: return pt()
454:
455: def ECHO_movie_config_credits(self):
456: """Main configuration"""
457: pt=zptFile(self, 'zpt/ChangeECHO_movie_credits.zpt')
458: return pt()
459:
460: def ECHO_resource_config_metadata(self):
461: """Main configuration"""
462: if (hasattr(self,'metadata')) and not (hasattr(self,'metaDataHash')):
463: self.metaDataHash={}
464: self.contentType=self.bib_type
465: for data in self.metadata:
466: data_neu=re.sub('-','_',data)
467: self.meta
468: DataHash[data_neu]=getattr(self,data)[0:]
469:
470:
471: pt=zptFile(self, 'zpt/ChangeECHO_resource_metadata.zpt')
472: return pt()
473:
474:
475:
476: def changeECHO_movie_main(self,metalink,link,rawFile,lowresFile,thumbUrl,title,label,description,contentType,renderingType="",weight="",resourceID="",RESPONSE=None):
477: """Aenderung der Properties"""
478: self.resourceID=resourceID
479: self.title=title
480: self.label=label
481: self.description=description
482:
483: self.contentType=contentType
484: self.renderingType=renderingType
485: self.weight=weight
486:
487: self.link=link
488: self.thumbUrl=thumbUrl
489: self.rawFile=rawFile
490: self.lowresFile=lowresFile
491:
492: self.metalink=metalink
493:
494: if RESPONSE is not None:
495: RESPONSE.redirect('manage_main')
496:
497:
498: def changeECHO_movie_coords(self,RESPONSE=None):
499: """Aenderung der Properties - coords"""
500: #return self.REQUEST
501: for area in self.getMapAreas():
502: id = area.getId()
503: if self.REQUEST.has_key('del.'+id):
504: # delete this area
505: self._delObject(id)
506: # return to same menu
507: if RESPONSE is not None:
508: RESPONSE.redirect('ECHO_movie_config_coords')
509: return
510: # modify this area
511: coordstring = self.REQUEST.get('coords.'+id, '')
512: coords = string.split(coordstring, ',')
513: angle = self.REQUEST.get('angle.'+id, '0')
514: type = self.REQUEST.get('type.'+id, 'area')
515: if len(coords) == 4:
516: area.setCoordString(coordstring)
517: area.setAngle(angle)
518: area.setType(type)
519: # return to main menu
520: if RESPONSE is not None:
521: RESPONSE.redirect('manage_main')
522:
523:
524: def changeECHO_movie_credits(self,credits,responsible,copyrightType,RESPONSE=None):
525: """Aenderung der Properties"""
526: self.credits=credits
527: self.responsible=responsible
528: self.copyrightType=copyrightType
529:
530: if RESPONSE is not None:
531: RESPONSE.redirect('manage_main')
532:
533:
534: def changeECHO_resource_metadata_local(self,RESPONSE=None):
535: """change metadata"""
536: tags=self.findTagsFromMapping(self.contentType)
537: for field in tags[1]:
538: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)][0:]
539:
540:
541:
542: if RESPONSE is not None:
543: RESPONSE.redirect('manage_main')
544:
545: def changeECHO_resource_metadata(self,RESPONSE=None):
546: """change metadata"""
547: tags=self.findTagsFromMapping(self.contentType)
548: self.OSAS_meta={}
549: for field in tags[1]:
550: try:
551: self.metaDataHash[self.getFieldTag(tags,field)]=self.REQUEST.form[self.getFieldTag(tags,field)]
552: self.OSAS_meta[self.getFieldTag(tags,field)]=self.REQUEST.form['OSAS_%s'%self.getFieldTag(tags,field)]
553: except:
554: """nothing"""
555:
556: ECHO_helpers.urlopen('http://xserve02.mpiwg-berlin.mpg.de:18880/echo_nav/storage/downloadExternalXML?index_meta_url=%s&xml_url=%s'%(self.metalink,self.absolute_url()+'/newMetaXML')).read()
557:
558:
559: if RESPONSE is not None:
560: RESPONSE.redirect('manage_main')
561:
562: def getMDValue(self,fieldNameTest,empty=None,generic=None):
563: """get md values"""
564: #TODO: cache mappinghash
565:
566: fieldName=None
567: if generic:
568: ct=self.contentType.replace(" ","_").lower()
569:
570: #caching
571: if not hasattr(self,'_v_mapHash'): #noch keine cachevariable
572: self._v_mapHash={}
573:
574: tmp=self._v_mapHash.get(ct,None)
575: if tmp: #teste ob type schon existiert
576: fieldName=tmp.get(fieldNameTest,None)
577: else:
578: self._v_mapHash[ct]={}
579:
580: #noch nicht gecached
581: if not fieldName and hasattr(self.standardMD,ct):
582: fieldName=getattr(self.standardMD,ct).generateMappingHash()[fieldNameTest][0]
583: self._v_mapHash[ct][fieldNameTest]=fieldName
584:
585: if not empty:
586: return self.metaDataHash.get(fieldName,'!!NOT USED HERE in Type: %s'%self.contentType)
587:
588: else:
589: return self.metaDataHash.get(fieldName,empty)
590:
591: def newMetaXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None,digiliburlprefix=None):
592: """new index.meta"""
593: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
594:
595: if not hasattr(self,'metaDataHash'):
596:
597: self.copyIndex_meta2echo_resource()
598: try:
599: return writeMetadata(self.metalink,self.OSAS_meta,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
600: except:
601: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,digiliburlprefix=digiliburlprefix)
602:
603: def showMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
604: """schreibe md"""
605:
606: try:
607:
608: return writeMetadata(self.metalink,self.metaDataHash,project,startpage,xslt,thumbtemplate,topbar,digiLibTemplate,xmlfrag="yes")
609: except:
610: return "<error> no metadata stored</error>"
611:
612: def getMetaDataXML(self,project=None,startpage=None,xslt=None,thumbtemplate=None,topbar=None,digiLibTemplate=None):
613: """prints out metadata as stored in the echo environment, format is the index.meta format"""
614: self.REQUEST.RESPONSE.setHeader('Content-Type','text/xml')
615: return writeMetadata(self.metalink,self.metaDataHash)
616:
617: def changeECHO_movie(self,metalink,link,thumbUrl,rawFile,lowresFile,title,label,description,contentType,responsible,weight,coords=None,credits=None,RESPONSE=None):
618: """Aenderung der Properties"""
619:
620: setECHO_collectionInformation(self,title,label,description,contentType,responsible,credits,weight)
621: self.link=link
622: self.metalink=metalink
623: self.thumbUrl=thumbUrl
624: self.rawFile=rawFile
625: self.lowresFile=lowresFile
626:
627:
628: if RESPONSE is not None:
629: RESPONSE.redirect('manage_main')
630:
631:
632: manage_options = Folder.manage_options+(
633: {'label':'Main Config','action':'ECHO_movie_config_main'},
634: {'label':'Change Metadata','action':'ECHO_movie_config_metadata'},
635: {'label':'Graphic Coords','action':'ECHO_graphicEntry'},
636: {'label':'Sync Metadata','action':'ECHO_getResourceMD'},
637: {'label':'Change TemplateSets and Image Viewer','action':'changeViewerTemplateSetForm'},
638: {'label':'set/change startpage','action':'setStartPageForm'},
639: {'label':'Copy MD for indexing and search','action':'copySearchFields'},
640: )
641:
642:
643: def isDefinedInThisSet(self,fields,field):
644: """checks if field is defined in fields"""
645: if (fields[0].has_key(field)) and not (fields[0][field]==""):
646: return 1
647: else:
648:
649: return 0
650:
651: def getFieldLabel(self,fields,field):
652: """get labels"""
653: try:
654: ret =fields[0][field]
655: if ret == "":
656: return field
657: else:
658: return ret
659: except:
660: return field
661:
662:
663:
664: def getFieldTag(self,fields,field):
665: """get labels"""
666: try:
667: ret =fields[0][field]
668: if ret == "":
669: return field
670: else:
671: return ret
672: except:
673: return field
674:
675:
676:
677: def getMetaDataHash(self):
678: """md hash"""
679: return self.metaDataHash
680:
681: def setFieldValue(self,field,value):
682: """get value"""
683:
684: if not hasattr(self,'metaDataHash'):
685: setattr(self,'metaDataHash',{})
686: self.metaDataHash[field]=value[0:]
687:
688:
689: def copySearchFields(self):
690: """copys metadatafields to the object"""
691: fields=['author','title','year']
692: for field in fields:
693: setattr(self,'MD_'+field,self.getMDValue(field))
694:
695:
696: def findLabelsFromMapping(self,referenceType):
697: """gib hash mit label -> generic zurueck"""
698: #return {},[]
699:
700: temp=self.ZopeFind(self.standardMD)
701:
702: if referenceType=="":
703: referenceType="book"
704:
705:
706: bibdata={}
707: retdata={}
708: fields=[]
709: fieldlist=self.standardMD.fieldList
710:
711: tags=self.findTagsFromMapping(self.contentType)
712: self.referencetypes=tags[2]
713: for referenceTypeF in self.referencetypes:
714:
715: if referenceTypeF[1].title.lower() == referenceType.lower():
716:
717: try:
718: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
719: referenceType=referenceTypeF[1].title
720: except:
721: bibdata[referenceType]=referenceTypeF[1].fields
722:
723:
724: bibdata['data']=referenceTypeF[1]
725: fields=bibdata[referenceType]
726: for field in fieldlist:
727: retdata[field]=referenceTypeF[1].getValue(field)[1]
728:
729: return retdata,fieldlist,temp,fields
730:
731: def findTagsFromMapping(self,referenceType):
732: """gib hash mit label -> generic zurueck"""
733:
734:
735: if referenceType=="":
736: referenceType="book"
737:
738: temp = self.ZopeFind(self.standardMD)[0:]
739:
740:
741: #self.referencetypes=temp[0:]
742:
743:
744:
745:
746:
747:
748: bibdata={}
749: retdata={}
750: fieldlist=self.standardMD.fieldList
751: fields=[]
752: for referenceTypeF in temp:
753: #print referenceType
754:
755: if referenceTypeF[1].title.lower() == referenceType.lower():
756: try:
757: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
758: referenceType=referenceTypeF[1].title
759: except:
760: bibdata[referenceType]=referenceTypeF[1].fields
761: bibdata['data']=referenceTypeF[1]
762: fields=bibdata[referenceType]
763: for field in fieldlist:
764: retdata[field]=referenceTypeF[1].getValue(field)[0]
765:
766: return retdata,fieldlist,temp,fields
767:
768:
769: security.declarePublic('copyIndex_meta2echo_resource') # has to be change, presentlyset because of OSAS koordination
770: def copyIndex_meta2echo_resource(self,RESPONSE=None):
771: """copy MD von Index_meta to the echo_resource"""
772:
773: (metadict, error)=readMetadata(self.metalink)
774:
775:
776:
777: self.metaDataHash={}
778: if not error=="": #Fehler beim Auslesen des Metafiles
779:
780: return "ERROR:",error,self.absolute_url()
781:
782: self.contentType=metadict['bib_type'][0:]
783: fields=self.findTagsFromMapping(self.contentType)
784:
785: #fields=self.findLabelsFromMapping(self.contentType)
786: for field in fields[1]:
787:
788: if self.isDefinedInThisSet(fields,field):
789: #print urllib.unquote(metadict.get(self.getFieldTag(fields,field),''))
790: self.setFieldValue(self.getFieldTag(fields,field),metadict.get(self.getFieldTag(fields,field),''))
791:
792:
793:
794: if RESPONSE:
795: return RESPONSE.redirect('manage_main')
796:
797: def ECHO_getResourceMD(self,template="yes",back=None):
798: """Einlesen der Metadaten und Anlegen dieser Metadaten als Informationen zur Resource"""
799: (metadict, error)=readMetadata(self.metalink)
800:
801: if back:
802: self.REQUEST.SESSION['back']=back
803:
804: if not error=="": #Fehler beim Auslesen des Metafiles
805: return "ERROR:",error
806:
807:
808: if not (metadict['bib_type'].lower()==self.contentType.lower()):
809: self.REQUEST.SESSION['contentStorage']=metadict['bib_type']
810: self.REQUEST.SESSION['contentZope']=self.contentType
811:
812: return zptFile(self, 'zpt/ECHO_getResourceMDErrorContentType.zpt')()
813:
814: self.REQUEST.SESSION['metadict']=metadict
815:
816:
817:
818: self.REQUEST.SESSION['diffs']=checkDiffs(self,self.REQUEST.SESSION['metadict'])
819:
820:
821:
822: if template=="yes":
823: pt=zptFile(self, 'zpt/ECHO_resourceMD.zpt')
824: return pt()
825:
826:
827:
828:
829:
830: def ECHO_getMD(self,item):
831: """Ausgabe der MD"""
832: return getattr(self,item)
833:
834: def checkRDF(self,path):
835: """check if pdf in the path"""
836: try:
837: for fileName in os.listdir(path):
838: if os.path.splitext(fileName)[1]==".pdf":
839: return os.path.join(path,fileName)
840: return None
841: except:
842: return None
843:
844:
845: def index_html(self):
846: """standard page"""
847: pdf=self.checkRDF(self.link)
848: if pdf:
849: fh=file(pdf,'r').read()
850: self.REQUEST.RESPONSE.setHeader('Content-Type','application/pdf')
851: self.REQUEST.RESPONSE.write(fh)
852: self.REQUEST.RESPONSE.close()
853: return
854: return self.REQUEST.RESPONSE.redirect(self.link)
855:
856:
857: security.declarePublic('generate_label') # has to be change, presentlyset because of OSAS koordination
858:
859: def generate_label(self):
860: """Erzeugt_standard_Label aus Template"""
861: try:
862: pt=getattr(self,"label_template_"+self.contentType.lower())
863: self.label=pt()[0:]
864: return pt()
865: except:
866: return self.label
867:
868: security.declarePublic('generate_title') # has to be change, presentlyset because of OSAS koordination
869:
870: def generate_title(self,RESPONSE=None):
871: """Erzeugt_standard_Label aus Template"""
872: try:
873: pt=getattr(self,"label_template_"+self.contentType.lower())
874: self.title=pt()[0:]
875: return pt()
876: except:
877: return self.label
878:
879: Globals.InitializeClass(ECHO_movie)
880:
881: def manage_addECHO_movieForm(self):
882: """Form for adding a ressource"""
883: pt=zptFile(self, 'zpt/AddECHO_movieForm.zpt')
884: return pt()
885:
886:
887:
888: def manage_addECHO_movie(self,id,title,label,description="",responsible="",link="",thumbUrl="",rawFile="",lowresFile="",metalink="",weight="",copyrightType=None,resourceID=None,contentType=None,renderingType=None,credits=None,coords=None,RESPONSE=None):
889: """addaresource"""
890:
891: newObj=ECHO_movie(id,link,thumbUrl,rawFile,lowresFile,metalink,resourceID,title,label,description,contentType,renderingType,copyrightType,responsible,credits,weight,coords)
892:
893: self._setObject(id,newObj)
894:
895: if RESPONSE is not None:
896: RESPONSE.redirect('manage_main')
897:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ECHO_movie.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ECHO_content