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