MPIWGThesaurus: MPIWGThesaurus

comparison MPIWGThesaurus_orig.py @ 45:efdbe9eb2403

thesaurus jetzt in datenbank

author	dwinter
date	Mon, 25 Nov 2013 08:12:11 +0100
parents
children

comparison

equal deleted inserted replaced

-:a30307377ed9
+:efdbe9eb2403
+#Klasse zum Taggen und Anzeigen der Tags von Projekte bzw. allgemein Webseiten des Institutes
+#Tags werden in der Instanz abgespeichert
+#Personenname kommen aus dem Virtuoso-Triplestore , lokal erzeugte zusaetliche Name werden dort abgespeichert
+#Fuer die Suche ueber die Personenname wird das MetaDataManagerRestlet benoetigt.
+#TODO: Zur Zeit werden die entsprechenden Server URLs hier in der Klasse definiert.
+# TODO: generell verwaltung der tags im triple store und nicht in zope.
+# TODO: mache server und namespaces konfigurierbar im project
+from OFS.Folder import Folder
+from Globals import package_home
+from Products.PageTemplates.PageTemplateFile import PageTemplateFile
+from BTrees.OOBTree import OOBTree
+from BTrees.OOBTree import OOSet
+from AccessControl import ClassSecurityInfo
+#import os
+import re
+import os.path
+import logging
+import time
+import email.Utils
+from types import ListType
+import transaction
+import random
+import urllib2
+import urllib
+from SrvTxtUtils import utf8ify
+class projectHolder:
+projectHolder=""
+projectName=""
+projectID=""
+persons=""
+tags={}
+def __init__(self,ID):
+self.projectID=ID
+self.tags={}
+#Entry beschreibt jeweils einen Tag mit dem Namen "title", entries enthaelt eine Liste von Subtags (der Klasse Entry), die diesem Tag untergeordnet sind.
+class Entry:
+"""publicClass"""
+#===========================================================================
+# __init__
+#===========================================================================
+def __init__(self,title,entries=[]):
+self.title=title
+self.entries=entries
+def getTitle(self):
+"""getTitle"""
+return self.title
+#Beschriebt einen von einem Benutzer vorgeschlagenen Tag
+class SuggestedTag:
+"""publicClass"""
+type=""
+userName=""
+def __init__(self,name,comment,type,userName):
+self.name=name
+self.comment=comment
+self.type=type
+self.userName=userName
+class MPIWGThesaurus(Folder):
+"""MPIWGThesaurus main folder"""
+security=ClassSecurityInfo()
+meta_type="MPIWGThesaurus"
+TMP_PERSON_NS="http://ontologies.mpiwg-berlin.mpg.de/tempObjects/person/"
+ONTOLOGY_NS="http://ontologies.mpiwg-berlin.mpg.de/authorities/namedIdentities/"
+personproviderURL="http://127.0.0.1:8280/MetaDataManagerRestlet/person/"
+#personproviderURL="http://virtuoso.mpiwg-berlin.mpg.de:8080/MetaDataManagerRestlet/person/"
+#PERSONS_LOOKUP_URL="http://127.0.0.1:8280/MetaDataManagerRestlet/search/persons"
+PERSONS_LOOKUP_URL="http://127.0.0.1:8280/MetaDataManagerRestlet/persons"
+EDIT_URL="http://127.0.0.1:8280/MetaDataManagerRestlet/edit?id="
+#PERSONS_LOOKUP_URL="http://virtuoso.mpiwg-berlin.mpg.de:8080/MetaDataManagerRestlet/person/"
+additionalNamesGraphURL="file://newpersonsFromProjects"
+#virtuosoServer="http://ontologies.mpiwg-berlin.mpg.de"
+virtuosoServer="http://virtuoso.mpiwg-berlin.mpg.de:8890"
+virtuosoDAV="/DAV/home/websiteuser/"
+virtuosoDAVUser="websiteuser"
+virtuosoDAVPW="w3s45us3"
+virtuosoGraph="file://newpersonsFromProjects"
+logpathDefault="/var/tmp/tagchanges.log"
+#BTrees fuer die Tags
+projectPersons= OOBTree() #project --> personen IDs
+projectObjects= OOBTree() #project --> objects
+projectHistoricalPlaces= OOBTree()
+projectSuggestedTags= OOBTree()
+persons2Projects= OOBTree() #personenID --> projects
+objects2Projects=OOBTree() #objects --> projects
+historicalPlaces2Projects=OOBTree()
+suggestedTags2Projects=OOBTree()
+personIDtoNames=OOBTree() # weist den personenIDs Klartextnamen aus dem Triplestore zu
+personsIDForSort=[] # liste personenID sortiert nach dem tupel (nachname,vorname)
+personsIDForSortFull=[] # liste (personenID,(nachname,vorname)) nicht sortiert!
+suggestedPersons= OOBTree(); #TODO: das sollte die ueberfluessig werde und nur im triple store stehen.
+tagList=[]
+#default liste fuer tags, wird ueber das Managementinterface ueberschrieben
+approachesTxt="""A
+---
+ent1
+---
+B
+---
+enta
+entb
+entc
+"""
+disciplines=[]
+disciplinesTxt="""A
+B
+C
+"""
+periods=[]
+periodsTxt="""PA
+PB
+PC
+"""
+spaces=[]
+spacesTxt="""SPA
+---
+sPent1
+---
+SPB
+---
+SPenta
+SPentb
+SPentc
+"""
+technologies=[]
+technologiesTxt="""TPA
+---
+TPent1
+---
+TPB
+---
+TPenta
+TPentb
+TPentc
+"""
+knowledgeTransfers=[]
+knowledgeTransfersTxt="""KTPA
+---
+TPent1
+---
+TPB
+---
+TPenta
+TPentb
+TPentc
+"""
+manage_options = Folder.manage_options+(
+{'label':'Thesaurus entries','action':'changeMPIWGThesaurusForm'},
+{'label':'Manage Thesaurus','action':'manageMPIWGThesaurus'},
+{'label':'Thesaurus Log','action':'manageMPIWGThesaurusLogs'},
+#{'label':'Change Publications Special','action':'changePublications_specialForm'},
+)
+def __init__(self,id):
+"""init"""
+self.id=id
+def index_html(self):
+"""index file"""
+pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','index.html')).__of__(self)
+return pt()
+security.declareProtected('View management screens','changeMPIWGThesaurusForm')
+def changeMPIWGThesaurusForm(self):
+"""form for changing the project"""
+pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGThesaurusForm.zpt')).__of__(self)
+return pt()
+security.declareProtected('View management screens','manageMPIWGThesaurus')
+def manageMPIWGThesaurus(self):
+"""form for changing the project"""
+pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageMPIWGThesaurus.zpt')).__of__(self)
+return pt()
+security.declareProtected('View management screens','manageMPIWGThesaurusLogs')
+def manageMPIWGThesaurusLogs(self):
+"""form for changing the project"""
+pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageMPIWGThesaurusLog.zpt')).__of__(self)
+return pt()
+def changeMPIWGThesaurusLog(self,logpath,RESPONSE=None):
+"""change log file path"""
+self.logpath=logpath
+if RESPONSE is not None:
+redirect(RESPONSE,'manage_main')
+security.declareProtected('View management screens','changeMPIWGThesaurus')
+def changeMPIWGThesaurus(self,approachesTxt,disciplinesTxt,periodsTxt,spacesTxt,technologiesTxt,knowledgeTransfersTxt,RESPONSE=None):
+"""change it"""
+self.approachesTxt=approachesTxt
+self.disciplinesTxt=disciplinesTxt
+self.periodsTxt=periodsTxt
+self.spacesTxt=spacesTxt
+self.technologiesTxt=technologiesTxt
+self.knowledgeTransfersTxt=knowledgeTransfersTxt
+if RESPONSE is not None:
+redirect(RESPONSE,'manage_main')
+#    def getAllProjectsAndTagsAsCSV(self,archived=1):
+#        """alle projekte auch die nicht getaggten"""
+#        retList=[]
+#        for project in self.getProjectFields('WEB_title_or_short'):
+#            proj = project[0]
+#            p_name = project[1]
+#            retProj=[]
+#            if (not proj.isArchivedProject() and archived==1) or (proj.isArchivedProject() and archived==2):
+#                retProj.append(self.utf8ify(p_name))
+#                retProj.append(self.utf8ify(proj.getContent('xdata_01')))
+#                retProj.append("|".join([person[1] for person in self.thesaurus.getPersonsFromProject(proj.getId())]))
+#                retProj.append("|".join([person[1] for person in self.thesaurus.getHistoricalPlacesFromProject(proj.getId())]))
+#                retProj.append("|".join([person[1] for person in self.thesaurus.getObjectsFromProject(proj.getId())]))
+#                retProj.append("|".join(self.thesaurus.getTags(proj.getId())))
+#                retList.append("\t".join(retProj))
+#
+#        return "\n".join(retList);
+#
+def getProjectsAndTags(self):
+"""projekte und tags"""
+projectTags={}
+for tag in self.tags.keys():
+logging.debug("getProjectsAndTags:"+tag)
+# <div class="level1_projects" tal:repeat="proj
+#              python:here.getProjectsWithTag('approaches',here.getTitle(level1))"><a tal:attributes="href
+#                                                         python:proj[0]"><span  tal:content="python:proj[1]">my proj</span><tal:x define="person python:proj[2]"><span
+#                                                                                                          class="person_projects" tal:content="person"/></tal:x></a></div>
+#</div>
+for subTag in self.tags.get(tag):
+projs = self.getProjectsWithTag(tag,subTag)
+if not isinstance(projs, ListType):
+projs=[projs]
+for proj in projs:
+if proj is None:
+continue
+projectID=proj[0]
+logging.debug("PTS"+repr(projectTags))
+project=projectTags.get(projectID,projectHolder(projectID))
+project.projectName=proj[1]
+project.persons=proj[2]
+logging.debug(project)
+logging.debug(tag)
+logging.debug("PROTS"+repr(project.tags))
+tagsOfType=project.tags.get(tag,OOSet())
+logging.debug(tagsOfType)
+tagsOfType.add(subTag.decode('utf-8'))
+logging.debug("Adding %s to %s"%(subTag,projectID))
+project.tags[tag]=tagsOfType
+projectTags[projectID]=project
+logging.debug("Saved %s to %s"%(repr(list(tagsOfType)),projectID))
+logging.debug(projectTags)
+return projectTags
+def getProjectsAndTagsAsCSV(self):
+"""get the projects as tab"""
+ret=""
+#genereate headers
+headers=['date','projectPath','projectName','researchers resp']
+headers.extend(list(self.tags.keys()))
+ret+="\t".join(headers)+"\n"
+projectTags = self.getProjectsAndTags()
+for projectID in projectTags.keys():
+retarray=[]
+splitted = projectID.split("/") # hiern nur die eingetliche ID ohne den Pfad
+if len(splitted)>0:
+projectIDShort=splitted[-1]
+retarray.append(self.lastChangeInThesaurus.get(projectIDShort,''))
+else:
+retarray.append('')
+retarray.append(projectID)
+project = projectTags.get(projectID)
+retarray.append(project.projectName)
+retarray.append(project.persons)
+for tagType in self.tags.keys():
+tags = project.tags.get(tagType,[''])
+retarray.append(";".join(tags))
+ret+="\t".join(retarray)+"\n"
+return ret
+def getAllProjectsAndTagsAsCSV(self,active=0,archived=0,RESPONSE=None):
+"""alle projekte auch die nicht getaggten"""
+retList=[]
+headers=['projectId','sortingNumber','projectName','scholars','startedAt','completedAt','lastChangeThesaurusAt','lastChangeProjectAt','projectCreatedAt','active','persons','objects']
+headers.extend(list(self.tags.keys()))
+retList.append("\t".join(headers))
+projectTags = self.getProjectsAndTags()
+projects = self.getMPIWGRoot().getProjectFolder().getProjectsAsList(active=active,archived=archived)
+for proj in projects:
+p_name = proj.getLabel()
+retProj=[]
+#if (not proj.isArchivedProject() and archived==1) or (proj.isArchivedProject() and archived==2):
+retProj.append(utf8ify(proj.getId()))
+retProj.append(utf8ify(proj.getContent('xdata_05')))
+retProj.append(utf8ify(p_name))
+retProj.append(utf8ify(proj.getContent('xdata_01')))
+retProj.append(utf8ify(proj.getStartedAt()))
+retProj.append(utf8ify(proj.getCompletedAt()))
+changeDate=self.lastChangeInThesaurus.get(proj.getId(),'')
+n = re.sub("[:\- ]","",str(changeDate))
+retProj.append(n)
+retProj.append(utf8ify(getattr(proj,'creationTime','20050101000000')))
+retProj.append("")#TODO: project created at
+retProj.append(str(proj.isActiveProject()))
+retProj.append(";".join([person[1] for person in self.getPersonsFromProject(proj.getId())]))
+#retProj.append(";".join([person[1] for person in self.thesaurus.getHistoricalPlacesFromProject(proj.getId())]))
+retProj.append(";".join([person[1] for person in self.getObjectsFromProject(proj.getId())]))
+retProj+=self.getTags(proj.getId(),projectTags)
+retList.append("\t".join(retProj))
+if RESPONSE:
+RESPONSE.setHeader('Content-Disposition','attachment; filename="ProjectsAndTags.tab"')
+RESPONSE.setHeader('Content-Type', "application/octet-stream")
+return "\n".join(retList);
+def getLogpath(self):
+return getattr(self,"logpath",self.logpathDefault)
+def getLogfile(self,projectID="",date=""):
+# logfile format : YYYY-MM-TT HH:mm:ss\tUSER\ttype\tprojectid\CHANGED_TAG_or_OBJECT_or_PERSON
+if not os.path.exists(self.getLogpath()):
+return ""
+fh = open(self.getLogpath(),"r")
+lines=fh.readlines()
+if (projectID!=""):
+ret=[]
+for line in lines:
+splitted=line.split("\t")
+if splitted[3]==projectID:
+ret.append(line)
+lines=ret[0:]
+if (date!=""):
+ret=[]
+for line in lines:
+splitted=line.split("\t")
+if splitted[0]>=date:
+ret.append(line)
+lines=ret[0:]
+txt= "".join(lines)
+fh.close()
+return txt
+#In der Anzeige soll der Name der zitierten Personen in Klartext angezeigt werden, ausserdem die Varianten, wie sie tatsaechlich
+#in den Projekten benutzt werden
+def addPersonAndFirstNameFromTripleStore(self, personID):
+mainName, sortName = self.getMainNameFromTripleStore(personID) # hole die hauptbezeichnung aus dem triplestore
+personNames = []
+logging.debug("get person:"+ personID)
+logging.debug("names:"+repr(mainName)+":"+ repr(sortName))
+projects=self.persons2Projects.get(personID)
+logging.debug(repr(projects))
+if projects is None:
+projects=[]
+for project in projects: #hole die personen aus dem projekte
+logging.debug("Found:project:" + project)
+namesInProject = self.projectPersons.get(project)
+for nameInProjectTuple in namesInProject:
+logging.debug(repr(nameInProjectTuple))
+nameInProject = nameInProjectTuple[1]
+logging.debug(nameInProjectTuple[0] + "??" + personID)
+if nameInProjectTuple[0] == personID:
+logging.debug("changing")
+if mainName == "": # es gibt keinen Eintrag im Triplestore fuer name (sollte eigentlich nicht sein, ist dann ein Fehler dort)
+mainName = nameInProject #nimm dann aber den ersten aus den projekten
+if nameInProject != mainName:
+personNames.append(nameInProject)
+logging.debug(str(mainName) + "- foundalso :" + ",".join(personNames))
+self.personIDtoNames.update({personID:(mainName, personNames)})
+self.personsIDForSortFull.append((personID, sortName))
+def generateSortingOrderForPersonIDs(self):
+def sort(x,y):
+logging.debug("sort:")
+logging.debug((x[1][0],y[1][0]))
+return cmp(x[1][0],y[1][0])
+self.personsIDForSortFull.sort(cmp=sort)
+self.personsIDForSort=[x[0] for x in self.personsIDForSortFull]
+self.personIDtoNames=self.personIDtoNames # make clear that it has changed #TODO: change this to variablen with names _p
+security.declareProtected('View management screens','collectPersonNamesToIds')
+def collectPersonNamesToIds(self):
+"""Ordne Namen aus dem Triplestore bzw. die vergebenenden Label den Personen-Ids zu."""
+#sollte z.B. gemacht werden, wenn im Triplestore editiert wurde.
+self.personIDtoNames=OOBTree() # loesche alle
+self.personsIDForSort=[]
+self.personsIDForSortFull=[]
+for personID in self.persons2Projects:
+self.addPersonAndFirstNameFromTripleStore(personID)
+#sortiere personIDs nach erstmal nach Nachnamene TODO: sortiere nach name,vorname
+self.generateSortingOrderForPersonIDs();
+#        def sort(x,y):
+#            logging.debug("sort:")
+#            logging.debug((x[1][0],y[1][0]))
+#            return cmp(x[1][0],y[1][0])
+#
+#        self.personsIDForSortFull.sort(cmp=sort)
+#
+#        self.personsIDForSort=[x[0] for x in self.personsIDForSortFull]
+#
+#        self.personIDtoNames=self.personIDtoNames # make clear that it has changed #TODO: change this to variablen with names _p
+#
+#Hole die Namen, die einer personID zugeordnet sind.
+def getNamesFromID(self,personID):
+personID=personID.rstrip().lstrip() #make sure no spaces
+logging.debug("<"+personID+">")
+retStr=""
+retStr+=self.personIDtoNames.get(personID,[personID])[0] # hole die Hauptbezeichnung, falls keine angeben ist, wird die ID ausgegeben, das is jedoch ein Felher in den Daten!!
+#additionalNames = self.personIDtoNames.get(personID,['',[]])[1]
+#if len(additionalNames)>0:
+#    retStr+=" ("+",".join(additionalNames)+","+")"
+return retStr
+#Hole die Hauptnamemsansetzung aus dem Triplestore ),falls vorhanden, wenn nicht ist der String leer.
+#ausserdem einen Namen zum sortieren, =  Tupel(nachname, vorname)
+def getMainNameFromTripleStore(self,personID):
+cmdString ="""select * where { <%s> <http://xmlns.com/foaf/0.1/name> ?name}"""%personID
+names= self.callSparql(cmdString)
+cmdString ="""select * where { <%s> <http://xmlns.com/foaf/0.1/lastName> ?name}"""%personID
+lastName= self.callSparql(cmdString)
+cmdString ="""select * where { <%s> <http://xmlns.com/foaf/0.1/firstName> ?name}"""%personID
+firstName= self.callSparql(cmdString)
+return names,(lastName,firstName)
+def callSparqlAll(self,cmdString):
+"""list of results"""
+auth_handler = urllib2.HTTPBasicAuthHandler()
+auth_handler.add_password(realm='sparql',
+uri=self.virtuosoServer+"/sparql",
+user=self.virtuosoDAVUser,
+passwd=self.virtuosoDAVPW)
+opener = urllib2.build_opener(auth_handler)
+opener.addheaders = [('Content-Type','application/sparql-query')]
+logging.debug(cmdString)
+try:
+logging.debug(self.virtuosoServer+"/sparql?" + urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':'','format':'text/csv'}))
+#r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':'','format':'text/csv'}))
+r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':'','named-graph-uri':'','format':'text/csv'}))
+namesTxt=r.read()
+except urllib2.URLError, e:
+logging.error(e.code)
+logging.error(e.read())
+return
+logging.debug(namesTxt)
+names=namesTxt.split("\n")
+if len(names) < 2: #in der ersten Zeile stehen bei der Rueckgabe die Spaltennamen, <2 heiss also es gibt keinen Eintrag
+return []
+ret=[]
+for name in names[1:]:
+line=[]
+for entry in name.split("\",\""):
+line.append(entry.replace('"',''));
+ret.append(line);
+return ret;
+def callSparql(self,cmdString):
+auth_handler = urllib2.HTTPBasicAuthHandler()
+auth_handler.add_password(realm='sparql',
+uri=self.virtuosoServer+"/sparql",
+user=self.virtuosoDAVUser,
+passwd=self.virtuosoDAVPW)
+opener = urllib2.build_opener(auth_handler)
+opener.addheaders = [('Content-Type','application/sparql-query')]
+logging.debug(cmdString)
+try:
+logging.debug(self.virtuosoServer+"/sparql?" + urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':'','format':'text/csv'}))
+#r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':'','format':'text/csv'}))
+r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':'','named-graph-uri':'','format':'text/csv'}))
+namesTxt=r.read()
+except urllib2.URLError, e:
+logging.error(e.code)
+logging.error(e.read())
+return
+logging.debug(namesTxt)
+names=namesTxt.split("\n")
+if len(names) < 2: #in der ersten Zeile stehen bei der Rueckgabe die Spaltennamen, <2 heiss also es gibt keinen Eintrag
+return
+return names[1].replace('"','') # wir nehmen nur den ersten treffer
+security.declareProtected('View management screens','changeTags')
+def changeTags(self,projectID,approaches=[],disciplines=[],periods=[],spaces=[],technologies=[],transfers=[],RESPONSE=None):
+"""change tags"""
+self.changeTagFromList(projectID,"approaches", approaches)
+self.changeTagFromList(projectID,"disciplines", disciplines)
+self.changeTagFromList(projectID,"periods", periods)
+self.changeTagFromList(projectID,"spaces", spaces)
+self.changeTagFromList(projectID,"technologies", technologies)
+self.changeTagFromList(projectID,"transfers", transfers)
+self.projectObjects=self.projectObjects #necessesary to make the object persistent after the first call
+self.projectHistoricalPlaces=self.projectHistoricalPlaces #necessesary to make the object persistent after the first call
+self.projectPersons=self.projectPersons #necessesary to make the object persistent after the first call
+self.projectSuggestedTags=self.projectSuggestedTags
+self.persons2Projects=self.persons2Projects
+self.objects2Projects=self.objects2Projects
+self.historicalPlaces2Projects=self.historicalPlaces2Projects
+self.suggestedTags2Projects=self.suggestedTags2Projects;
+self.suggestedPersons=self.suggestedPersons;
+security.declareProtected('View management screens','deleteAllTags')
+def deleteAllTags(self):
+"""deleteAllTags - TODO: take this out!!,"""
+setattr(self,"tags",None)
+return "DONE!"
+security.declareProtected('View management screens','deleteAllPersons')
+def deleteAllPersons(self):
+"""deleteAllTags - TODO: take this out!!,"""
+self.projectPersons= OOBTree()
+self.persons2Projects= OOBTree()
+self.personIDtoNames=OOBTree()
+self.suggestedPersons= OOBTree(); #TODO: das sollte die ueberfluessig werde und nur im triple store stehen.
+return "DONE!"
+security.declareProtected('View management screens','deleteAllObjects')
+def deleteAllObjects(self):
+"""deleteAllTags - TODO: take this out!!,"""
+logging.debug("delete all objects")
+self.projectObjects= OOBTree()
+self.objects2Projects=OOBTree()
+return "DONE!"
+def changeTagFromList(self,projectID,tagType,tagList):
+logging.debug("changing:"+projectID)
+logging.debug("asking tag::"+tagType)
+if type(tagList) is not ListType:
+tagList=[tagList]
+tags = getattr(self,"tags",None)
+if tags is None:
+logging.debug("Create new tags")
+tags=OOBTree()
+setattr(self,"tags",tags)
+tagsStored=tags.get(tagType,None)
+if tagsStored is None:
+tagsStored=OOBTree();
+for tag in tagsStored.keys(): #gehe durch alle gespeichteren tags
+logging.debug("checking:"+tag)
+projectsOfTag = tagsStored.get(tag,None)
+logging.debug(projectsOfTag)
+if projectsOfTag is None:
+projectsOfTag=OOSet()
+if tag in tagList: #dieser ist getagged
+projectsOfTag.update([projectID]);
+self.storeChange("added",projectID,tag)
+tagList.remove(tag);
+else:
+if projectsOfTag.has_key(projectID):
+projectsOfTag.remove(projectID);
+self.storeChange("remove",projectID,tag)
+tagsStored.update({tag:projectsOfTag});
+for tag in tagList: # alle Tags, die nicht abgearbeitet worden sind, muessen noch angelegt werden
+logging.debug("adding:"+tag)
+newApproach=OOSet()
+newApproach.update([projectID]);
+tagsStored.insert(tag, newApproach);
+tags.update({tagType:tagsStored})
+transaction.commit()
+def getTitle(self,entry):
+return entry.title
+def thes_quote(self,txt):
+import md5
+logging.debug("@*%s*@"%txt)
+return md5.md5(txt.lower()).hexdigest()
+def formatTag(self,tag):
+splitted= tag.split("_")
+return splitted[-1]
+def getEntriesFormatted(self,entries,formatType):
+if not hasattr(self,'levelFormatted'):
+pt=PageTemplateFile('zpt/levelFormatted', globals()).__of__(self)
+return pt(level1_entries=entries,type=formatType)
+pt = getattr(self,'levelFormatted')
+return pt(level1_entries=entries,type=formatType)
+#return self.levelFormatted(level1_entries=entries,type=formatType)
+def getEntries(self,entry):
+#logging.debug("GETENTRY:"+repr(entry))
+return entry.entries
+#nimmt ein eine Text der Form
+# TAG1
+# ---
+# SUBTAG1_1
+# SUBTAG1_2
+# ---
+# TAG2
+# ---
+# SUBTAG2_1
+# SUBTAG2_2
+#....
+# und erzeugt daraus eine entsprechende Liste von Entries
+def getEntriesFromTxt(self,txt):
+apps=[]
+lines=txt.split("\n");
+level=False
+for line in lines:
+line=line.rstrip().lstrip()
+if line=="":
+continue
+if line=="---":
+if level:
+level=False
+else:
+level=True
+else:
+if not level:
+entry=Entry(line,[])
+apps.append(entry)
+else:
+entry.entries.append(Entry(line))
+return apps[0:]
+def getApproaches(self):
+self.tagList=self.getEntriesFromTxt(self.approachesTxt)
+return self.tagList
+def getTagsAsHash(self,projectID,tagType=None):
+"""get all  tags as hash or None if no tag exists"""
+retHash={}
+tagCnt=0
+tags = getattr(self,"tags",None)
+if tags is None:
+return;
+#falls nicht gesetzt
+if tagType is None:
+tagTypes = tags.keys()
+else:
+tagTypes = [tagType]
+for tagType in tagTypes:
+tagsStored=tags.get(tagType,None)
+if tagsStored is None:
+# WTF: was: return
+continue
+retHash[tagType]=[]
+for tag in tagsStored.keys(): #gehe durch alle gespeichteren approached
+logging.debug("checking:"+tag)
+currentTag = tagsStored.get(tag,None)
+if currentTag is None:
+continue
+if currentTag.has_key(projectID):
+tagCnt+=1
+retHash[tagType].append("""%s"""%tag)
+if len(retHash[tagType]) == 0:
+# empty tag list
+del retHash[tagType]
+if tagCnt==0:
+return None
+return retHash
+def getTagsJSON(self,projectID,tagType,RESPONSE=None):
+"""get all selected tagList"""
+#logging.debug("asking:"+projectID)
+#logging.debug("asking tag::"+tagType)
+retList=[]
+tags = getattr(self,"tags",None)
+if tags is None:
+return;
+tagsStored=tags.get(tagType,None)
+if tagsStored is None:
+return;
+for tag in tagsStored.keys(): #gehe durch alle gespeichteren approached
+logging.debug("checking:"+tag)
+currentTag = tagsStored.get(tag,None)
+if currentTag is None:
+continue
+if currentTag.has_key(projectID):
+retList.append(""" "%s" """%tag)
+if RESPONSE:
+RESPONSE.setHeader('Content-Type', "application/json")
+logging.debug(retList)
+return "["+",".join(retList)+"]"
+def getTags(self,projectID,projectTags,RESPONSE=None):
+"""get all selected tagList"""
+#projectTags = self.getProjectsAndTags()
+#logging.debug(projectTags)
+project = projectTags.get(projectID)
+if project is None:
+project = projectTags.get("/en/research/projects/"+projectID) #TODO fix this projectTag list from getProjectsAndTags()contains  fullpath
+if project is None:
+return []
+retarray=[]
+for tagType in self.tags.keys():
+tags = project.tags.get(tagType,[''])
+retarray.append(utf8ify(";".join(tags)))
+return retarray
+#        logging.debug("asking:"+projectID)
+#
+#
+#        apps = self.getApproaches()+ self.getDisciplines();
+#        retList=[]
+#        for tagType in self.tags.keys():
+#
+#            logging.debug("asking tag::"+repr(tagType))
+#
+#            tags = getattr(self,"tags",None)
+#            if tags is None:
+#                continue;
+#
+#            tagsStored=tags.get(tagType,None)
+#            if tagsStored is None:
+#                continue;
+#
+#            for tag in tagsStored.keys(): #gehe durch alle gespeichteren approached
+#                logging.debug("checking:"+tag)
+#                currentTag = tagsStored.get(tag,None)
+#                if currentTag is None:
+#                    continue
+#                if currentTag.has_key(projectID):
+#                    retList.append(""" "%s" """%tag)
+#
+#        if RESPONSE:
+#            RESPONSE.setHeader('Content-Type', "application/json")
+#
+#        logging.debug(retList)
+#        return retList
+def getDisciplines(self):
+self.disciplines=self.getEntriesFromTxt(self.disciplinesTxt)
+return self.disciplines
+def getObjectsJSON(self,term="",RESPONSE=None):
+""" get all stored objects as json list starting with term"""
+term=term.lower();
+logging.debug("Asking:"+term)
+#objectList=["baus","berg","lurg"]
+objects = self.objects2Projects;
+objectList= [x for x in objects.keys()]
+logging.debug("Create:"+repr(objectList))
+retList=[]
+for object in objectList:
+if object.find(term)>-1:
+retList.append(""" "%s" """%object)
+ret="["
+ret+=",".join(retList)
+ret+="]"
+logging.debug("Objects:"+ret)
+if RESPONSE:
+RESPONSE.setHeader('Content-Type', "application/json")
+return ret
+def getHistoricalPlacesJSON(self,term="",RESPONSE=None):
+""" get all stored historicalPlaces as json list starting with term"""
+term=term.lower();
+logging.debug("Asking:"+term)
+#historicalPlaceList=["baus","berg","lurg"]
+historicalPlaces = self.historicalPlaces2Projects;
+historicalPlaceList= [x for x in historicalPlaces.keys()]
+logging.debug("Create:"+repr(historicalPlaceList))
+retList=[]
+for historicalPlace in historicalPlaceList:
+if historicalPlace.find(term)>-1:
+retList.append(""" "%s" """%historicalPlace)
+ret="["
+ret+=",".join(retList)
+ret+="]"
+logging.debug("historicalPlaces:"+ret)
+if RESPONSE:
+RESPONSE.setHeader('Content-Type', "application/json")
+return ret
+def getPeriods(self):
+self.periodes=self.getEntriesFromTxt(self.periodsTxt)
+return self.periodes
+def getSpaces(self):
+self.spaces=self.getEntriesFromTxt(self.spacesTxt)
+return self.spaces
+def getTechnologies(self):
+self.technologies=self.getEntriesFromTxt(self.technologiesTxt)
+return self.technologies
+def getKnowledgeTransfers(self):
+self.knowledgeTransfers=self.getEntriesFromTxt(self.knowledgeTransfersTxt)
+return self.knowledgeTransfers
+def getObjectsFromProject(self,projectID):
+return self.getFromProject(self.projectObjects,projectID);
+def getHistoricalPlacesFromProject(self,projectID):
+return self.getFromProject(self.projectHistoricalPlaces,projectID);
+def getSuggestedTagsFromProject(self,projectID):
+return self.getFromProject(self.projectSuggestedTags,projectID);
+def getPersonsFromProject(self,projectID):
+#hole alle personenID die zu einem Projekt gehoeren.
+#zurueckgegeben wird ein OOSet()
+return self.getFromProject(self.projectPersons,projectID);
+def getFromProject(self,objects,projectID):
+#holt die zu projectID gehoerigen objekte aus dem objects-set.
+#oder legt einen neuen leeren Satz zu dieser ProjektID an.
+#zuruecgegeben wird ein OOSet()
+if objects.has_key(projectID): #wenn zu der ProjektID schon etwas abgespeichter ist, gieb es zurueck
+logging.debug("key exists:"+projectID)
+persons=objects.get(projectID);
+else: # andernfalls lege einen neuen Satz an.
+persons=OOSet()
+objects.update({projectID:persons})
+logging.debug("key does not exists:"+projectID)
+return persons
+def getHistoricalPlacesFromProjectAsHTML(self,projectID):
+"""gertobjects"""
+return self.getFromProjectAsHTML(self.projectHistoricalPlaces, projectID, "HistoricalPlace");
+def getObjectsFromProjectAsHTML(self,projectID):
+"""gertobjects"""
+return self.getFromProjectAsHTML(self.projectObjects, projectID, "Object");
+def getPersonsFromProjectAsHTML(self,projectID):
+"""getpersons"""
+return self.getFromProjectAsHTML(self.projectPersons, projectID, "Person");
+def getFromProjectAsHTML(self,objects,projectID,tagType):
+"""getpersons"""
+ret=""
+if objects.has_key(projectID):
+persons=objects.get(projectID);
+else:
+persons=OOSet()
+for person in persons:
+ret+="""<div class="removeButton">
+<span>%s </span><div style="display:inline" class="remove%s"><span style="display:none" class="removeValue">%s</span>remove</div>
+</div>"""%(person[1],tagType,person[0])
+#            ret+="""<div>
+#        <input tagType="checkbox" name="persons_remove"
+#         value="%s">
+#        <span>%s</span>
+#        </div>"""%(person[0],person[1])
+#
+logging.debug(tagType+":"+ret)
+return ret
+security.declareProtected('View management screens','removeHistoricalPlaceFromProject')
+def removeHistoricalPlaceFromProject(self,projectID,value):
+"""remove"""
+logging.debug("removeHP:"+projectID+":"+value);
+HistoricalPlaces = self.getHistoricalPlacesFromProject(projectID)
+for HistoricalPlace in HistoricalPlaces.keys():
+logging.debug("trying:"+repr(HistoricalPlace[0])+"::"+repr(value)+"__")
+if HistoricalPlace[0]==value:
+logging.debug("---removed!")
+HistoricalPlaces.remove(HistoricalPlace)
+self.projectHistoricalPlaces.update({projectID:HistoricalPlaces})
+retstring = self.getHistoricalPlacesFromProjectAsHTML(projectID)
+logging.debug(retstring)
+return retstring
+security.declareProtected('View management screens','removeObjectFromProject')
+def removeObjectFromProject(self,projectID,value):
+"""remove"""
+logging.debug("remove:"+projectID+":"+value);
+self.storeChange("removeObject",projectID,value)
+objects = self.getObjectsFromProject(projectID)
+for object in objects.keys():
+logging.debug("trying:"+repr(object[0])+"::"+repr(value)+"__")
+if object[0]==value:
+logging.debug("---removed!")
+objects.remove(object)
+#now also delete the project from the object.
+objectsOfPerson=self.objects2Projects.get(object[0])
+if projectID in list(objectsOfPerson):
+objectsOfPerson.remove(projectID)
+#self.persons2Projects.update({person:projectsList})
+if (len(objectsOfPerson)==0): #loesche person aus der liste wenn keine Projekte dazu existieren.
+del self.objects2Projects[object[0]]
+self.projectObjects.update({projectID:objects})
+retstring = self.getObjectsFromProjectAsHTML(projectID)
+logging.debug(retstring)
+return retstring
+security.declareProtected('View management screens','removePersonFromProject')
+def removePersonFromProject(self,projectID,value):
+"""remove a person from the projeckt"""
+logging.debug("remove:"+projectID+":"+value);
+self.storeChange("removePerson",projectID,value)
+persons = self.getPersonsFromProject(projectID) # hole alle personen die mit dem Projekt verbunden sind.
+for person in persons.keys():
+logging.debug("trying:"+repr(person[0])+"::"+repr(value)+"__")
+if person[0]==value:#person ist die zuloeschende, dann raus damit
+logging.debug("---removed!")
+persons.remove(person)
+#now also delete the project from the person.
+projectsOfPerson=self.persons2Projects.get(person[0])
+logging.debug(projectsOfPerson)
+if projectID in list(projectsOfPerson):
+projectsOfPerson.remove(projectID)
+#self.persons2Projects.update({person:projectsList})
+if (len(projectsOfPerson)==0): #loesche person aus der liste wenn keine Projekte dazu existieren.
+del self.persons2Projects[person[0]]
+#self.projectPersons.update({projectID:persons})
+retstring = self.getPersonsFromProjectAsHTML(projectID)
+logging.debug(retstring)
+return retstring
+#fuegt die neue Person zur personIDtoNames hinzu, fuer die spaetere Anzeige in der Personenliste
+def addNameTOPersonIDNames(self,personID,label):
+personName = self.personIDtoNames.get(personID)
+if personName==None: # Anlegen falls noch nicht existent
+personName=(label,[])
+else:
+if (not label in personName[1]) and (not label==personName[0]): # hinzufuegen falls der neuen name noch nicht als bezeichnugn fuer personID eingetragen ist
+personName[1].append(label)
+self.personIDtoNames.update({personID:personName})
+security.declareProtected('View management screens','addPersonToProject')
+def addPersonToProject(self,projectID,value,label):
+""" add a person so the project"""
+self.storeChange("addPerson",projectID,value+":"+label)
+persons=self.getPersonsFromProject(projectID);
+logging.debug("adding:"+projectID+":"+value+":"+label);
+persons.insert([value,label])
+self.projectPersons.update({projectID:persons})
+for personTuple in persons:
+#hole die abgespeicherten Projekte zu einer Person
+person=personTuple[0] #hole die ID
+if getattr(self,"persons2Projects",None)==None:
+setattr(self,"persons2Projects",OOBTree())
+projects = self.persons2Projects.get(person,None)
+logging.debug("found projects:"+ repr(projects))
+if projects is None: #person hatte noch keine projekte
+projects=OOSet();
+projects.insert(projectID )
+logging.debug("update:"+person)
+self.persons2Projects.update({person:projects})
+self.addPersonAndFirstNameFromTripleStore(person)
+self.generateSortingOrderForPersonIDs();
+self.addNameTOPersonIDNames(value,label)
+retstring = self.getPersonsFromProjectAsHTML(projectID)
+logging.debug(retstring)
+transaction.commit()
+return retstring
+def rearangePersonIDsHTML(self,REQUEST=None):
+"""setze neue ID zu personen"""
+ret=[]
+for personID in self.persons2Projects.keys():
+logging.debug(personID)
+masterID,name=self.findMasterIDAndName(personID.rstrip().lstrip())
+logging.debug("        masterID -appending")
+logging.debug(repr(name))
+if len(name)==0:
+name=['']
+ret.append((personID,self.personIDtoNames.get(personID,[''])[0],masterID,self.personIDtoNames.get(masterID,name)[0]))
+if REQUEST:
+pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','rearrangePersons.zpt')).__of__(self)
+return pt(changeList=ret,lookupUrl=self.PERSONS_LOOKUP_URL,editURL=self.EDIT_URL);
+else:
+return ret;
+def rearangePersonIDs(self,REQUEST):
+"""unify a list of persons"""
+argv=REQUEST.form;
+logging.debug(repr(argv))
+changes=argv['changes']
+if isinstance(changes,str):
+changes=[changes]
+changeList=self.rearangePersonIDsHTML()
+personToMaster={}
+logging.debug("changelist:"+repr(changeList))
+#aendere person2project
+for change in changes:
+changeItem=changeList[int(change)];
+masterID=argv['newID_'+change].lstrip().rstrip() #make sure no spaces
+personID=changeItem[0]
+personToMaster[personID]=masterID
+masterIDProjects = self.persons2Projects.get(masterID,None);
+if masterIDProjects==None:
+masterIDProjects=OOSet();
+#ret.append((personID,self.personIDtoNames.get(personID,[''])[0],masterID,self.personIDtoNames.get(masterID,[''])[0]))
+oldProjects= self.persons2Projects.get(personID)
+logging.debug("personID:"+repr(personID))
+logging.debug("masterID:"+repr(masterID))
+logging.debug("keys:"+repr(self.persons2Projects.keys()))
+logging.debug("oldProjects:"+repr(oldProjects))
+masterIDProjects.update(oldProjects)
+self.persons2Projects.update({masterID:masterIDProjects})
+self.persons2Projects.pop(personID)
+self.addPersonAndFirstNameFromTripleStore(masterID) #addpersontotiplestore
+logging.debug("Change:" +personID+":"+ masterID)
+if personID!=masterID:
+self.addSameAsRelationToTripleStore(personID,masterID)
+#aendere nun projectperson
+logging.debug(personToMaster)
+for project in self.projectPersons.keys():
+personsNew=OOSet()
+persons=self.projectPersons.get(project)
+for person in persons:
+personsNew.insert([personToMaster.get(person[0],person[0]),person[1]])
+logging.debug("REPLACE in:"+project+":" +repr(person)+" by "+ repr(personToMaster.get(person[0],person[0])))
+self.projectPersons.update({project:personsNew})
+self.generateSortingOrderForPersonIDs(); #now sort the new names
+return personToMaster
+#fuehre personen zusammen die ueber owl:sameAs verbunden sind
+def getUnifyPersonsList(self,REQUEST=None):
+"""vereinheitlichung der personen auf eine ID aus der GND, wenn moeglich"""
+ret=[]
+for personID in self.persons2Projects.keys():
+masterID,name=self.findMasterIDAndName(personID)
+logging.debug("masterID:"+masterID)
+if (masterID is not None) and (masterID is not "") and (not personID==masterID):
+#masterIDProjects = self.persons2Projects.get(masterID,None);
+##if masterIDProjects==None:
+#    masterIDProjects=OOSet();
+logging.debug("        masterID -appending")
+logging.debug(repr(name))
+ret.append((personID,self.personIDtoNames.get(personID,[''])[0],masterID,self.personIDtoNames.get(masterID,name)[0]))
+#masterIDProjects.update(self.persons2Projects.get(personID));
+#self.persons2Projects.update({masterID:masterIDProjects});
+if REQUEST:
+pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','unifyPersons.zpt')).__of__(self)
+return pt(changeList=ret);
+else:
+return ret;
+def unifyPersons(self,changes,REQUEST=None):
+"""unify a list of persons"""
+if isinstance(changes,str):
+changes=[changes]
+changeList=self.getUnifyPersonsList();
+personToMaster={}
+logging.debug("changelist:"+repr(changeList))
+#aendere person2project
+for change in changes:
+changeItem=changeList[int(change)];
+masterID=changeItem[2]
+personID=changeItem[0]
+personToMaster[personID]=masterID
+masterIDProjects = self.persons2Projects.get(masterID,None);
+if masterIDProjects==None:
+masterIDProjects=OOSet();
+#ret.append((personID,self.personIDtoNames.get(personID,[''])[0],masterID,self.personIDtoNames.get(masterID,[''])[0]))
+oldProjects= self.persons2Projects.get(personID)
+logging.debug("personID:"+repr(personID))
+logging.debug("masterID:"+repr(masterID))
+logging.debug("keys:"+repr(self.persons2Projects.keys()))
+logging.debug("oldProjects:"+repr(oldProjects))
+masterIDProjects.update(oldProjects)
+self.persons2Projects.update({masterID:masterIDProjects})
+self.persons2Projects.pop(personID)
+self.addPersonAndFirstNameFromTripleStore(masterID) #addpersontotiplestore
+logging.debug("Change:" +personID+":"+ masterID)
+#aendere nun projectperson
+logging.debug(personToMaster)
+for project in self.projectPersons.keys():
+personsNew=OOSet()
+persons=self.projectPersons.get(project)
+for person in persons:
+personsNew.insert([personToMaster.get(person[0],person[0]),person[1]])
+logging.debug("REPLACE in:"+project+":" +repr(person)+" by "+ repr(personToMaster.get(person[0],person[0])))
+self.projectPersons.update({project:personsNew})
+self.generateSortingOrderForPersonIDs(); #now sort the new names
+return personToMaster
+def findMasterIDAndName(self,ressourceID):
+queryString="""select *
+FROM <file://mpiwg_persons_dnb.rdf>
+FROM <file://mpiwg_persons_2.rdf>
+FROM <file:///GND.rdf>
+FROM <http://identifiedNames>
+where {
+?person <http://www.w3.org/2002/07/owl#sameAs> <%s>.
+?ident <http://ontologies.mpiwg-berlin.mpg.de/authorities/namedIdentities/identifies_NamedEntity> ?person.
+?gnd crm:P1_is_identified_by ?ident.
+?gnd <http://RDVocab.info/ElementsGr2/dateOfBirth> ?birthDate.
+?gnd <http://RDVocab.info/ElementsGr2/dateOfDeath> ?deathDate.
+?person <http://xmlns.com/foaf/0.1/name> ?name.
+?person <http://xmlns.com/foaf/0.1/lastName> ?lastName.
+?person <http://xmlns.com/foaf/0.1/firstName> ?firstName.
+}
+"""%ressourceID
+entries = self.callSparqlAll(queryString);
+if len(entries)>0:
+return entries[0][0],entries[0][5:8] #nur den ersten Treffer und nur die personID
+return None,None
+security.declareProtected('View','getPersonsWithProjectIDs')
+def getPersonsWithProjectIDs(self,check=False):
+"""holt die getaggted Personen mit Projekten"""
+persons = self.persons2Projects;
+ret={}
+logging.debug("Check Person:"+repr(persons.keys()))
+personsList=[x for x in persons.keys()]
+def sort(x,y):
+try:
+sortNrx=self.personsIDForSort.index(x)
+except:
+logging.warn("couldn't find personsIDForSort:"+x)
+sortNrx=0
+try:
+sortNry=self.personsIDForSort.index(y)
+except:
+logging.warn("couldn't find personsIDForSort:"+y)
+sortNry=0
+#logging.debug("INSORT***")
+#logging.debug((sortNrx,sortNry))
+return cmp(sortNrx,sortNry)
+logging.debug("SORT***")
+logging.debug(self.personsIDForSort)
+logging.debug("SORT.list")
+logging.debug(personsList)
+personsList.sort(cmp=sort)
+#for person in persons.keys():
+logging.debug("AFTERSORT***")
+logging.debug(personsList)
+for person in personsList:
+logging.debug("Check:"+person)
+#TODO: person muss duch den namen von provider geholt werden
+retlist=[]
+projectsList=persons.get(person)
+if projectsList is None:
+projectsList=[]
+for projectID in list(projectsList): #list notwendig da projectList in der folgenden iteration veraendert wird.
+if check: #teste ob im Projekt noch ein Verweis auf den Namen steht
+#sollte eigentlich nicht sein.
+personsProjects=self.getPersonsFromProject(projectID)
+logging.debug("persons check mode")
+personsProjectsCheck=[x[0] for x in personsProjects]
+if not person in personsProjectsCheck: #falls es so ist korrigiere die Projektliste der Person
+#loesche die person von projectListe
+projectsList.remove(projectID)
+persons.update({person:projectsList})
+retlist.append(self.getProjectDetails(projectID))
+if check and (len(projectsList)==0): #loesche person aus der liste wenn keine Projekte dazu existieren.
+del persons[person]
+ret[person]=retlist[0:]
+logging.debug("AFTERSORT-ret***")
+logging.debug(ret.keys())
+return ret,personsList
+def getHistoricalPlacesWithProjectIDs(self):
+"""holt die getaggted Personen mit Projekten"""
+HistoricalPlaces = self.HistoricalPlaces2Projects;
+ret={}
+logging.debug("Check HistoricalPlace:"+repr(HistoricalPlaces.keys()))
+for HistoricalPlace in HistoricalPlaces.keys():
+logging.debug("Check:"+HistoricalPlace)
+#TODO: HistoricalPlace muss duch den namen von provuder geholt werden
+list=[]
+for projectID in HistoricalPlaces.get(HistoricalPlace):
+list.append(self.getProjectDetails(projectID))
+ret[HistoricalPlace]=list[0:]
+return ret
+def getObjectsWithProjectIDsSortedkeys(self):
+def sortF(x,y):
+return cmp(x.lower(),y.lower())
+keys = [x for x in self.getObjectsWithProjectIDs().keys()]
+keys.sort(sortF)
+return keys
+def getObjectsWithProjectIDs(self):
+"""holt die getagten Personen mit Projekten"""
+objects = self.objects2Projects;
+ret={}
+logging.debug("Check Object:"+repr(objects.keys()))
+for object in objects.keys():
+logging.debug("Check:"+object)
+#TODO: object muss duch den namen von provuder geholt werden
+list=[]
+for projectID in objects.get(object):
+list.append(self.getProjectDetails(projectID))
+ret[object]=list[0:]
+logging.debug(ret)
+return ret
+security.declareProtected('View management screens','listAllSuggestedTags')
+def listAllSuggestedTags(self):
+"""list all tags"""
+ret="<html><body>"
+for projectID in self.projectSuggestedTags:
+ret+="<h3>"+projectID+"</h3><table>"
+for tags in self.projectSuggestedTags.get(projectID):
+ret+="<tr><td>"+tags[0]+"</td><td>"+tags[1].type+"</td><td>"+tags[1].comment+"</td><td>"+tags[1].userName+"</td></tr>"
+ret+="</table>"
+ret+="</body></html>"
+logging.debug(ret);
+return ret
+security.declareProtected('View management screens','suggestTag')
+def suggestTag(self,projectID,tagName,tagComment,tagType,tagUserName):
+"""suggest a new tag"""
+""" add a person so the project"""
+SuggestedTags=self.getSuggestedTagsFromProject(projectID);
+logging.debug("suggested:"+projectID+":"+tagName);
+#TODO: Im moment noch keine Zuordnung zu einer ID.
+newTag = SuggestedTag(tagName,tagComment,tagType,tagUserName)
+SuggestedTags.insert([tagName,newTag])
+self.projectSuggestedTags.update({projectID:SuggestedTags})
+for SuggestedTagTuple in SuggestedTags:
+#hole die abgespeicherten Projekte zu einer Person
+person=SuggestedTagTuple[0] #hile die ID
+if getattr(self,"SuggestedTags2Projects",None)==None:
+setattr(self,"SuggestedTags2Projects",OOBTree())
+projects = self.SuggestedTags2Projects.get(person,None)
+if projects==None:
+projects=OOSet();
+projects.insert(projectID )
+logging.debug("update:"+person)
+self.SuggestedTags2Projects.update({person:projects})
+#retstring = self.getSuggestedTagsFromProjectAsHTML(projectID)
+#logging.debug(retstring)
+#return retstring
+security.declareProtected('View management screens','addHistoricalPlaceToProject')
+def addHistoricalPlaceToProject(self,projectID,value):
+""" add a person so the project"""
+HistoricalPlaces=self.getHistoricalPlacesFromProject(projectID);
+logging.debug("adding:"+projectID+":"+value);
+#TODO: Im moment noch keine Zuordnung zu einer ID.
+HistoricalPlaces.insert([value,value])
+self.projectHistoricalPlaces.update({projectID:HistoricalPlaces})
+for HistoricalPlaceTuple in HistoricalPlaces:
+#hole die abgespeicherten Projekte zu einer Person
+person=HistoricalPlaceTuple[0] #hile die ID
+if getattr(self,"HistoricalPlaces2Projects",None)==None:
+setattr(self,"HistoricalPlaces2Projects",OOBTree())
+projects = self.HistoricalPlaces2Projects.get(person,None)
+if projects==None:
+projects=OOSet();
+projects.insert(projectID )
+logging.debug("update:"+person)
+self.HistoricalPlaces2Projects.update({person:projects})
+retstring = self.getHistoricalPlacesFromProjectAsHTML(projectID)
+logging.debug(retstring)
+return retstring
+security.declareProtected('View management screens','addObjectToProject')
+def addObjectToProject(self,projectID,value):
+""" add a person so the project"""
+objects=self.getObjectsFromProject(projectID);
+logging.debug("adding:"+projectID+":"+value);
+self.storeChange("addObject",projectID,value)
+#TODO: Im moment noch keine Zuordnung zu einer ID.
+objects.insert([value,value])
+self.projectObjects.update({projectID:objects})
+for objectTuple in objects:
+#hole die abgespeicherten Projekte zu einer Person
+person=objectTuple[0] #hile die ID
+if getattr(self,"objects2Projects",None)==None:
+setattr(self,"objects2Projects",OOBTree())
+projects = self.objects2Projects.get(person,None)
+if projects==None:
+projects=OOSet();
+projects.insert(projectID )
+logging.debug("update:"+person)
+self.objects2Projects.update({person:projects})
+retstring = self.getObjectsFromProjectAsHTML(projectID)
+logging.debug(retstring)
+return retstring
+def getProjectsWithTag(self,tagType,tagName):
+tags = getattr(self,"tags",None)
+if tags is None:
+logging.debug("can't find Tags")
+return []
+tagsStored=tags.get(tagType,None)
+if tagsStored is None:
+logging.debug("can't find Tag:"+tagType)
+return []
+projects = tagsStored.get(tagName,None)
+if projects is None:
+logging.debug("can't find any projects for Tag:"+tagName+"("+tagType+")")
+return []
+ret=[]
+for project in projects:
+logging.debug("found:"+project)
+proj =self.getProjectDetails(project);
+if proj is not None:
+ret.append(proj)
+return ret
+def getProjectDetails(self,projectId):
+pf = self.getMPIWGRoot().getProjectFolder()
+project=pf.get(projectId,None)
+if project is None:
+logging.debug("no project!! " +projectId)
+return None
+link=projectId
+title=project.getContent("WEB_title")
+#persons=project.getPersonKeyList()
+persons=project.getContent('xdata_01')
+logging.debug("%s %s %s"%(link,title,persons))
+thumb = project.getThumbUrl()
+return link,title,persons,thumb
+#        $.post("addNewPerson",{"projectID":
+#                     $('#projectID').val(),
+#                     "personName":$("#suggest_newPerson").val(),
+#                     "personComment":$("#suggest_newPerson_comment").val()}
+#
+#              );
+#
+security.declareProtected('View management screens','addAndCreateNewPerson')
+def addAndCreateNewPerson(self,projectID,personName,personComment,personUserName):
+"""adds anew person to the project which is not in the authority file"""
+id = random.randint(0, 1000000);
+idstring="http://ontologies.mpiwg-berlin.mpg.de/tempObjects/person/"+str(id)
+while self.suggestedPersons.has_key(idstring):
+id = random.randint(0, 1000000);
+#idstring="http://ontologies.mpiwg-berlin.mpg.de/tempObjects/person/"+str(id);
+idstring=self.TEMP_PERSON_NS+str(id);
+self.suggestedPersons.update({idstring:(personName,personComment,projectID,personUserName)})
+self.createTempPersonInVirtuoso(projectID, idstring, personName, personComment) #TODO: add suername to the triplestore
+return self.addPersonToProject(projectID, idstring, personName);
+def addSameAsRelationToTripleStore(self,personID,masterID):
+cmdString ="insert in GRAPH <"+self.virtuosoGraph+">  {"
+cmdString +="<%s> <http://www.w3.org/2002/07/owl#sameAs> <%s>."%(personID,masterID)
+cmdString +="<%s> <http://www.w3.org/2002/07/owl#sameAs> <%s>."%(masterID,personID)
+cmdString+="}"
+auth_handler = urllib2.HTTPBasicAuthHandler()
+auth_handler.add_password(realm='sparql',
+uri=self.virtuosoServer+"/sparql",
+user=self.virtuosoDAVUser,
+passwd=self.virtuosoDAVPW)
+opener = urllib2.build_opener(auth_handler)
+opener.addheaders = [('Content-Type','application/sparql-query')]
+logging.debug(cmdString)
+try:
+r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':None}))
+logging.debug(r.read())
+except urllib2.URLError, e:
+logging.error(e.code)
+logging.error(e.read())
+return
+security.declareProtected('View management screens','createTempPersonInVirtuoso')
+def createTempPersonInVirtuoso(self,projectID,personURI, personName,personComment):
+"""add a new person to the triple store of tempory persons"""
+triples=[];
+personID="<"+personURI+">"
+triples.append((personID,"<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>","<http://ontologies.mpiwg-berlin.mpg.de/authorities/namedIdentities/Person>"))
+triples.append((personID,"<http://erlangen-crm.org/110404/P3_has_note>",'"'+personComment+'"'))
+triples.append((personID,"<http://xmlns.com/foaf/0.1/name>",'"'+personName+'"'))
+triples.append((personID,"<http://ontologies.mpiwg-berlin.mpg.de/general/isMentionedOn>","<http://www.mpiwg-berlin.mpg.de/en/research/projects/"+projectID+">"))
+cmdString ="insert in GRAPH <"+self.virtuosoGraph+">  {"
+for triple in triples:
+cmdString+=" ".join(triple)+"."
+cmdString+="}"
+auth_handler = urllib2.HTTPBasicAuthHandler()
+auth_handler.add_password(realm='sparql',
+uri=self.virtuosoServer+"/sparql",
+user=self.virtuosoDAVUser,
+passwd=self.virtuosoDAVPW)
+opener = urllib2.build_opener(auth_handler)
+opener.addheaders = [('Content-Type','application/sparql-query')]
+logging.debug(cmdString)
+try:
+r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':None}))
+logging.debug(r.read())
+except urllib2.URLError, e:
+logging.error(e.code)
+logging.error(e.read())
+return
+opener2 = urllib2.build_opener()
+personIDencoded=urllib.quote(personURI,safe="")
+graphEncoded=urllib.quote(self.additionalNamesGraphURL,safe="")
+url = self.personproviderURL+"id/"+personIDencoded+"/"+graphEncoded
+try:
+request = urllib2.Request(url);
+request.get_method = lambda : 'PUT'
+r= opener2.open(request);
+logging.debug(r.read())
+except urllib2.URLError, e:
+logging.error(e.code)
+logging.error(e.read())
+return
+return
+#  self.storeChange("removePerson",projectID,value)
+def storeChange(self,typeString,projectID,value):
+from time import gmtime,strftime
+fl = open(self.getLogpath(),"a")
+person = self.REQUEST.AUTHENTICATED_USER.getId()
+date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
+writeString ="\t".join((date,person,typeString,projectID,value))
+fl.write(writeString+"\n")
+fl.flush()
+fl.close()
+lastChangeInThesaurus = getattr(self,'lastChangeInThesaurus',OOBTree())
+lastChangeInThesaurus.update({projectID:date})
+self.lastChangeInThesaurus=lastChangeInThesaurus
+def redirect(RESPONSE,url):
+"""mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen"""
+timeStamp=time.time()
+if url.find("?")>-1: #giebt es schon parameter
+addStr="&time=%s"
+else:
+addStr="?time=%s"
+RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT')
+logging.error(email.Utils.formatdate()+' GMT')
+RESPONSE.redirect(url+addStr%timeStamp)
+def manage_addMPIWGThesaurusForm(self):
+"""form for adding the project"""
+pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGThesaurusForm.zpt')).__of__(self)
+return pt()
+def manage_addMPIWGThesaurus(self,id,RESPONSE=None):
+"""add it"""
+newObj=MPIWGThesaurus(id)
+self._setObject(id,newObj)
+if RESPONSE is not None:
+redirect(RESPONSE,'manage_main')

Mercurial > hg > MPIWGThesaurus

comparison MPIWGThesaurus_orig.py @ 45:efdbe9eb2403