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