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