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