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