Mercurial > hg > MPIWGThesaurus
annotate MPIWGThesaurus.py @ 44:a30307377ed9
add project active state to getAllProjectsAndTagsAsCSV.
| author | casties |
|---|---|
| date | Wed, 06 Nov 2013 15:03:36 +0100 |
| parents | f863fe7dc4e5 |
| children | efdbe9eb2403 |
| rev | line source |
|---|---|
| 1 | 1 #Klasse zum Taggen und Anzeigen der Tags von Projekte bzw. allgemein Webseiten des Institutes |
| 2 #Tags werden in der Instanz abgespeichert | |
| 3 #Personenname kommen aus dem Virtuoso-Triplestore , lokal erzeugte zusaetliche Name werden dort abgespeichert | |
| 10 | 4 #Fuer die Suche ueber die Personenname wird das MetaDataManagerRestlet benoetigt. |
| 1 | 5 #TODO: Zur Zeit werden die entsprechenden Server URLs hier in der Klasse definiert. |
| 6 | |
| 7 | |
| 0 | 8 # TODO: generell verwaltung der tags im triple store und nicht in zope. |
| 1 | 9 # TODO: mache server und namespaces konfigurierbar im project |
| 10 | |
| 11 | |
| 0 | 12 from OFS.Folder import Folder |
| 13 from Globals import package_home | |
| 14 from Products.PageTemplates.PageTemplateFile import PageTemplateFile | |
| 15 from BTrees.OOBTree import OOBTree | |
| 16 from BTrees.OOBTree import OOSet | |
| 2 | 17 from AccessControl import ClassSecurityInfo |
| 18 | |
| 0 | 19 #import os |
| 41 | 20 import re |
| 0 | 21 import os.path |
| 22 import logging | |
| 23 import time | |
| 24 import email.Utils | |
| 25 from types import ListType | |
| 26 import transaction | |
| 27 import random | |
| 28 import urllib2 | |
| 29 import urllib | |
| 20 | 30 |
| 41 | 31 from SrvTxtUtils import utf8ify |
| 0 | 32 |
| 17 | 33 class projectHolder: |
| 34 projectHolder="" | |
| 35 projectName="" | |
| 36 projectID="" | |
| 37 persons="" | |
| 38 tags={} | |
| 39 | |
| 40 def __init__(self,ID): | |
| 41 self.projectID=ID | |
| 42 self.tags={} | |
| 43 | |
| 1 | 44 #Entry beschreibt jeweils einen Tag mit dem Namen "title", entries enthaelt eine Liste von Subtags (der Klasse Entry), die diesem Tag untergeordnet sind. |
| 0 | 45 class Entry: |
| 46 """publicClass""" | |
| 1 | 47 |
| 48 #=========================================================================== | |
| 49 # __init__ | |
| 50 #=========================================================================== | |
| 0 | 51 def __init__(self,title,entries=[]): |
| 52 self.title=title | |
| 53 self.entries=entries | |
| 54 | |
| 55 def getTitle(self): | |
| 56 """getTitle""" | |
| 57 return self.title | |
| 58 | |
| 1 | 59 #Beschriebt einen von einem Benutzer vorgeschlagenen Tag |
| 0 | 60 class SuggestedTag: |
| 61 """publicClass""" | |
| 62 type="" | |
| 63 userName="" | |
| 64 def __init__(self,name,comment,type,userName): | |
| 65 self.name=name | |
| 66 self.comment=comment | |
| 67 self.type=type | |
| 68 self.userName=userName | |
| 69 | |
| 70 | |
| 71 class MPIWGThesaurus(Folder): | |
| 72 """MPIWGThesaurus main folder""" | |
| 2 | 73 security=ClassSecurityInfo() |
| 74 | |
| 0 | 75 meta_type="MPIWGThesaurus" |
| 76 | |
| 77 TMP_PERSON_NS="http://ontologies.mpiwg-berlin.mpg.de/tempObjects/person/" | |
| 78 ONTOLOGY_NS="http://ontologies.mpiwg-berlin.mpg.de/authorities/namedIdentities/" | |
| 7 | 79 personproviderURL="http://127.0.0.1:8280/MetaDataManagerRestlet/person/" |
| 80 #personproviderURL="http://virtuoso.mpiwg-berlin.mpg.de:8080/MetaDataManagerRestlet/person/" | |
| 81 #PERSONS_LOOKUP_URL="http://127.0.0.1:8280/MetaDataManagerRestlet/search/persons" | |
| 82 PERSONS_LOOKUP_URL="http://127.0.0.1:8280/MetaDataManagerRestlet/persons" | |
| 8 | 83 EDIT_URL="http://127.0.0.1:8280/MetaDataManagerRestlet/edit?id=" |
| 84 #PERSONS_LOOKUP_URL="http://virtuoso.mpiwg-berlin.mpg.de:8080/MetaDataManagerRestlet/person/" | |
| 7 | 85 |
| 0 | 86 additionalNamesGraphURL="file://newpersonsFromProjects" |
| 87 | |
| 88 #virtuosoServer="http://ontologies.mpiwg-berlin.mpg.de" | |
| 89 virtuosoServer="http://virtuoso.mpiwg-berlin.mpg.de:8890" | |
| 90 virtuosoDAV="/DAV/home/websiteuser/" | |
| 91 virtuosoDAVUser="websiteuser" | |
| 92 virtuosoDAVPW="w3s45us3" | |
| 93 virtuosoGraph="file://newpersonsFromProjects" | |
| 94 | |
| 15 | 95 logpathDefault="/var/tmp/tagchanges.log" |
| 96 | |
| 1 | 97 #BTrees fuer die Tags |
| 98 | |
| 7 | 99 projectPersons= OOBTree() #project --> personen IDs |
| 15 | 100 projectObjects= OOBTree() #project --> objects |
| 0 | 101 projectHistoricalPlaces= OOBTree() |
| 102 projectSuggestedTags= OOBTree() | |
| 7 | 103 persons2Projects= OOBTree() #personenID --> projects |
| 15 | 104 objects2Projects=OOBTree() #objects --> projects |
| 0 | 105 historicalPlaces2Projects=OOBTree() |
| 106 suggestedTags2Projects=OOBTree() | |
| 4 | 107 personIDtoNames=OOBTree() # weist den personenIDs Klartextnamen aus dem Triplestore zu |
| 5 | 108 personsIDForSort=[] # liste personenID sortiert nach dem tupel (nachname,vorname) |
| 109 personsIDForSortFull=[] # liste (personenID,(nachname,vorname)) nicht sortiert! | |
| 110 | |
| 0 | 111 suggestedPersons= OOBTree(); #TODO: das sollte die ueberfluessig werde und nur im triple store stehen. |
| 112 | |
| 113 tagList=[] | |
| 1 | 114 |
| 115 #default liste fuer tags, wird ueber das Managementinterface ueberschrieben | |
| 0 | 116 approachesTxt="""A |
| 117 --- | |
| 118 ent1 | |
| 119 --- | |
| 120 B | |
| 121 --- | |
| 122 enta | |
| 123 entb | |
| 124 entc | |
| 125 """ | |
| 126 | |
| 127 disciplines=[] | |
| 128 disciplinesTxt="""A | |
| 129 B | |
| 130 C | |
| 131 """ | |
| 132 | |
| 133 periods=[] | |
| 134 periodsTxt="""PA | |
| 135 PB | |
| 136 PC | |
| 137 """ | |
| 138 | |
| 139 spaces=[] | |
| 140 spacesTxt="""SPA | |
| 141 --- | |
| 142 sPent1 | |
| 143 --- | |
| 144 SPB | |
| 145 --- | |
| 146 SPenta | |
| 147 SPentb | |
| 148 SPentc | |
| 149 """ | |
| 150 technologies=[] | |
| 151 technologiesTxt="""TPA | |
| 152 --- | |
| 153 TPent1 | |
| 154 --- | |
| 155 TPB | |
| 156 --- | |
| 157 TPenta | |
| 158 TPentb | |
| 159 TPentc | |
| 160 """ | |
| 161 | |
| 162 knowledgeTransfers=[] | |
| 163 knowledgeTransfersTxt="""KTPA | |
| 164 --- | |
| 165 TPent1 | |
| 166 --- | |
| 167 TPB | |
| 168 --- | |
| 169 TPenta | |
| 170 TPentb | |
| 171 TPentc | |
| 172 """ | |
| 173 | |
| 174 | |
| 175 | |
| 176 | |
| 177 | |
| 178 | |
| 179 manage_options = Folder.manage_options+( | |
| 1 | 180 {'label':'Thesaurus entries','action':'changeMPIWGThesaurusForm'}, |
| 181 {'label':'Manage Thesaurus','action':'manageMPIWGThesaurus'}, | |
| 15 | 182 {'label':'Thesaurus Log','action':'manageMPIWGThesaurusLogs'}, |
| 0 | 183 #{'label':'Change Publications Special','action':'changePublications_specialForm'}, |
| 184 ) | |
| 185 | |
| 186 def __init__(self,id): | |
| 187 """init""" | |
| 188 self.id=id | |
| 189 | |
| 190 | |
| 191 def index_html(self): | |
| 192 """index file""" | |
| 1 | 193 |
| 0 | 194 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','index.html')).__of__(self) |
| 195 return pt() | |
| 196 | |
| 2 | 197 security.declareProtected('View management screens','changeMPIWGThesaurusForm') |
| 0 | 198 def changeMPIWGThesaurusForm(self): |
| 199 """form for changing the project""" | |
| 200 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeMPIWGThesaurusForm.zpt')).__of__(self) | |
| 201 return pt() | |
| 202 | |
| 2 | 203 security.declareProtected('View management screens','manageMPIWGThesaurus') |
| 1 | 204 def manageMPIWGThesaurus(self): |
| 205 """form for changing the project""" | |
| 206 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageMPIWGThesaurus.zpt')).__of__(self) | |
| 207 return pt() | |
| 208 | |
| 15 | 209 security.declareProtected('View management screens','manageMPIWGThesaurusLogs') |
| 210 def manageMPIWGThesaurusLogs(self): | |
| 211 """form for changing the project""" | |
| 212 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','manageMPIWGThesaurusLog.zpt')).__of__(self) | |
| 213 return pt() | |
| 214 | |
| 215 def changeMPIWGThesaurusLog(self,logpath,RESPONSE=None): | |
| 216 """change log file path""" | |
| 217 self.logpath=logpath | |
| 218 | |
| 219 if RESPONSE is not None: | |
| 220 redirect(RESPONSE,'manage_main') | |
| 221 | |
| 222 | |
| 2 | 223 security.declareProtected('View management screens','changeMPIWGThesaurus') |
| 0 | 224 def changeMPIWGThesaurus(self,approachesTxt,disciplinesTxt,periodsTxt,spacesTxt,technologiesTxt,knowledgeTransfersTxt,RESPONSE=None): |
| 225 """change it""" | |
| 226 self.approachesTxt=approachesTxt | |
| 227 self.disciplinesTxt=disciplinesTxt | |
| 228 self.periodsTxt=periodsTxt | |
| 229 self.spacesTxt=spacesTxt | |
| 230 self.technologiesTxt=technologiesTxt | |
| 231 self.knowledgeTransfersTxt=knowledgeTransfersTxt | |
| 232 | |
| 233 if RESPONSE is not None: | |
| 234 redirect(RESPONSE,'manage_main') | |
| 15 | 235 |
| 236 | |
| 24 | 237 # def getAllProjectsAndTagsAsCSV(self,archived=1): |
| 238 # """alle projekte auch die nicht getaggten""" | |
| 239 # retList=[] | |
| 240 # for project in self.getProjectFields('WEB_title_or_short'): | |
| 241 # proj = project[0] | |
| 242 # p_name = project[1] | |
| 243 # retProj=[] | |
| 244 # if (not proj.isArchivedProject() and archived==1) or (proj.isArchivedProject() and archived==2): | |
| 245 # retProj.append(self.utf8ify(p_name)) | |
| 246 # retProj.append(self.utf8ify(proj.getContent('xdata_01'))) | |
| 247 # retProj.append("|".join([person[1] for person in self.thesaurus.getPersonsFromProject(proj.getId())])) | |
| 248 # retProj.append("|".join([person[1] for person in self.thesaurus.getHistoricalPlacesFromProject(proj.getId())])) | |
| 249 # retProj.append("|".join([person[1] for person in self.thesaurus.getObjectsFromProject(proj.getId())])) | |
| 250 # retProj.append("|".join(self.thesaurus.getTags(proj.getId()))) | |
| 251 # retList.append("\t".join(retProj)) | |
| 252 # | |
| 253 # return "\n".join(retList); | |
| 254 # | |
| 17 | 255 def getProjectsAndTags(self): |
| 256 """projekte und tags""" | |
| 257 | |
| 258 | |
| 259 projectTags={} | |
| 260 for tag in self.tags.keys(): | |
| 261 logging.debug("getProjectsAndTags:"+tag) | |
| 262 # <div class="level1_projects" tal:repeat="proj | |
| 263 # python:here.getProjectsWithTag('approaches',here.getTitle(level1))"><a tal:attributes="href | |
| 264 # python:proj[0]"><span tal:content="python:proj[1]">my proj</span><tal:x define="person python:proj[2]"><span | |
| 265 # class="person_projects" tal:content="person"/></tal:x></a></div> | |
| 21 | 266 #</div> |
| 17 | 267 |
| 268 for subTag in self.tags.get(tag): | |
| 269 projs = self.getProjectsWithTag(tag,subTag) | |
| 270 if not isinstance(projs, ListType): | |
| 271 projs=[projs] | |
| 272 | |
| 273 for proj in projs: | |
| 25 | 274 if proj is None: |
| 275 continue | |
| 17 | 276 projectID=proj[0] |
| 277 logging.debug("PTS"+repr(projectTags)) | |
| 278 project=projectTags.get(projectID,projectHolder(projectID)) | |
| 279 project.projectName=proj[1] | |
| 280 project.persons=proj[2] | |
| 281 logging.debug(project) | |
| 282 logging.debug(tag) | |
| 283 logging.debug("PROTS"+repr(project.tags)) | |
| 284 tagsOfType=project.tags.get(tag,OOSet()) | |
| 285 logging.debug(tagsOfType) | |
| 286 tagsOfType.add(subTag.decode('utf-8')) | |
| 287 | |
| 288 logging.debug("Adding %s to %s"%(subTag,projectID)) | |
| 289 project.tags[tag]=tagsOfType | |
| 290 | |
| 291 projectTags[projectID]=project | |
| 292 logging.debug("Saved %s to %s"%(repr(list(tagsOfType)),projectID)) | |
| 293 logging.debug(projectTags) | |
| 294 | |
| 295 | |
| 296 | |
| 297 return projectTags | |
| 298 | |
| 22 | 299 def getProjectsAndTagsAsCSV(self): |
| 17 | 300 """get the projects as tab""" |
| 301 ret="" | |
| 302 | |
| 303 #genereate headers | |
| 304 headers=['date','projectPath','projectName','researchers resp'] | |
| 305 headers.extend(list(self.tags.keys())) | |
| 306 ret+="\t".join(headers)+"\n" | |
| 307 | |
| 308 projectTags = self.getProjectsAndTags() | |
| 309 for projectID in projectTags.keys(): | |
| 310 retarray=[] | |
| 311 splitted = projectID.split("/") # hiern nur die eingetliche ID ohne den Pfad | |
| 312 if len(splitted)>0: | |
| 313 projectIDShort=splitted[-1] | |
| 314 retarray.append(self.lastChangeInThesaurus.get(projectIDShort,'')) | |
| 315 else: | |
| 316 retarray.append('') | |
| 317 retarray.append(projectID) | |
| 318 project = projectTags.get(projectID) | |
| 319 retarray.append(project.projectName) | |
| 320 retarray.append(project.persons) | |
| 321 | |
| 322 for tagType in self.tags.keys(): | |
| 323 tags = project.tags.get(tagType,['']) | |
| 324 retarray.append(";".join(tags)) | |
| 325 | |
| 326 ret+="\t".join(retarray)+"\n" | |
| 327 | |
| 328 return ret | |
| 329 | |
| 41 | 330 |
|
43
f863fe7dc4e5
really show all projects in getAllProjectsAndTagsCSV.
casties
parents:
42
diff
changeset
|
331 def getAllProjectsAndTagsAsCSV(self,active=0,archived=0,RESPONSE=None): |
| 41 | 332 """alle projekte auch die nicht getaggten""" |
| 333 retList=[] | |
|
44
a30307377ed9
add project active state to getAllProjectsAndTagsAsCSV.
casties
parents:
43
diff
changeset
|
334 headers=['projectId','sortingNumber','projectName','scholars','startedAt','completedAt','lastChangeThesaurusAt','lastChangeProjectAt','projectCreatedAt','active','persons','objects'] |
| 41 | 335 headers.extend(list(self.tags.keys())) |
| 336 retList.append("\t".join(headers)) | |
| 337 | |
| 338 projectTags = self.getProjectsAndTags() | |
|
43
f863fe7dc4e5
really show all projects in getAllProjectsAndTagsCSV.
casties
parents:
42
diff
changeset
|
339 projects = self.getMPIWGRoot().getProjectFolder().getProjectsAsList(active=active,archived=archived) |
| 41 | 340 for proj in projects: |
| 341 p_name = proj.getLabel() | |
| 342 retProj=[] | |
| 343 #if (not proj.isArchivedProject() and archived==1) or (proj.isArchivedProject() and archived==2): | |
| 344 retProj.append(utf8ify(proj.getId())) | |
| 345 retProj.append(utf8ify(proj.getContent('xdata_05'))) | |
| 346 retProj.append(utf8ify(p_name)) | |
| 347 retProj.append(utf8ify(proj.getContent('xdata_01'))) | |
| 348 retProj.append(utf8ify(proj.getStartedAt())) | |
| 349 retProj.append(utf8ify(proj.getCompletedAt())) | |
| 350 changeDate=self.lastChangeInThesaurus.get(proj.getId(),'') | |
| 351 n = re.sub("[:\- ]","",str(changeDate)) | |
| 352 retProj.append(n) | |
| 353 retProj.append(utf8ify(getattr(proj,'creationTime','20050101000000'))) | |
|
44
a30307377ed9
add project active state to getAllProjectsAndTagsAsCSV.
casties
parents:
43
diff
changeset
|
354 retProj.append("")#TODO: project created at |
|
a30307377ed9
add project active state to getAllProjectsAndTagsAsCSV.
casties
parents:
43
diff
changeset
|
355 retProj.append(str(proj.isActiveProject())) |
| 41 | 356 retProj.append(";".join([person[1] for person in self.getPersonsFromProject(proj.getId())])) |
| 357 #retProj.append(";".join([person[1] for person in self.thesaurus.getHistoricalPlacesFromProject(proj.getId())])) | |
| 358 retProj.append(";".join([person[1] for person in self.getObjectsFromProject(proj.getId())])) | |
| 359 retProj+=self.getTags(proj.getId(),projectTags) | |
| 360 retList.append("\t".join(retProj)) | |
| 361 | |
| 362 if RESPONSE: | |
| 42 | 363 RESPONSE.setHeader('Content-Disposition','attachment; filename="ProjectsAndTags.tab"') |
| 41 | 364 RESPONSE.setHeader('Content-Type', "application/octet-stream") |
| 365 | |
| 366 return "\n".join(retList); | |
| 367 | |
| 368 | |
| 15 | 369 def getLogpath(self): |
| 370 return getattr(self,"logpath",self.logpathDefault) | |
| 371 | |
| 372 def getLogfile(self,projectID="",date=""): | |
| 373 | |
| 374 # logfile format : YYYY-MM-TT HH:mm:ss\tUSER\ttype\tprojectid\CHANGED_TAG_or_OBJECT_or_PERSON | |
| 375 if not os.path.exists(self.getLogpath()): | |
| 376 return "" | |
| 377 | |
| 378 fh = open(self.getLogpath(),"r") | |
| 379 lines=fh.readlines() | |
| 380 | |
| 381 if (projectID!=""): | |
| 382 ret=[] | |
| 383 for line in lines: | |
| 384 splitted=line.split("\t") | |
| 385 if splitted[3]==projectID: | |
| 386 ret.append(line) | |
| 387 | |
| 388 lines=ret[0:] | |
| 389 | |
| 390 if (date!=""): | |
| 391 ret=[] | |
| 392 for line in lines: | |
| 393 splitted=line.split("\t") | |
| 394 if splitted[0]>=date: | |
| 395 ret.append(line) | |
| 396 | |
| 397 | |
| 398 lines=ret[0:] | |
| 399 | |
| 400 txt= "".join(lines) | |
| 401 fh.close() | |
| 402 | |
| 403 | |
| 404 | |
| 405 | |
| 406 return txt | |
| 407 | |
| 0 | 408 #In der Anzeige soll der Name der zitierten Personen in Klartext angezeigt werden, ausserdem die Varianten, wie sie tatsaechlich |
| 409 #in den Projekten benutzt werden | |
| 2 | 410 |
| 5 | 411 |
| 412 def addPersonAndFirstNameFromTripleStore(self, personID): | |
| 413 mainName, sortName = self.getMainNameFromTripleStore(personID) # hole die hauptbezeichnung aus dem triplestore | |
| 414 personNames = [] | |
| 7 | 415 logging.debug("get person:"+ personID) |
| 416 logging.debug("names:"+repr(mainName)+":"+ repr(sortName)) | |
| 417 | |
| 418 projects=self.persons2Projects.get(personID) | |
| 419 logging.debug(repr(projects)) | |
| 420 if projects is None: | |
| 421 projects=[] | |
| 422 | |
| 423 for project in projects: #hole die personen aus dem projekte | |
| 5 | 424 logging.debug("Found:project:" + project) |
| 425 namesInProject = self.projectPersons.get(project) | |
| 426 for nameInProjectTuple in namesInProject: | |
| 427 logging.debug(repr(nameInProjectTuple)) | |
| 428 nameInProject = nameInProjectTuple[1] | |
| 429 logging.debug(nameInProjectTuple[0] + "??" + personID) | |
| 430 if nameInProjectTuple[0] == personID: | |
| 431 logging.debug("changing") | |
| 432 if mainName == "": # es gibt keinen Eintrag im Triplestore fuer name (sollte eigentlich nicht sein, ist dann ein Fehler dort) | |
| 433 mainName = nameInProject #nimm dann aber den ersten aus den projekten | |
| 434 if nameInProject != mainName: | |
| 435 personNames.append(nameInProject) | |
| 436 | |
| 437 logging.debug(str(mainName) + "- foundalso :" + ",".join(personNames)) | |
| 438 self.personIDtoNames.update({personID:(mainName, personNames)}) | |
| 439 self.personsIDForSortFull.append((personID, sortName)) | |
| 440 | |
| 441 | |
| 442 | |
| 443 def generateSortingOrderForPersonIDs(self): | |
| 444 def sort(x,y): | |
| 445 logging.debug("sort:") | |
| 446 logging.debug((x[1][0],y[1][0])) | |
| 447 return cmp(x[1][0],y[1][0]) | |
| 448 | |
| 449 self.personsIDForSortFull.sort(cmp=sort) | |
| 450 | |
| 451 self.personsIDForSort=[x[0] for x in self.personsIDForSortFull] | |
| 452 | |
| 453 self.personIDtoNames=self.personIDtoNames # make clear that it has changed #TODO: change this to variablen with names _p | |
| 454 | |
| 4 | 455 security.declareProtected('View management screens','collectPersonNamesToIds') |
| 0 | 456 def collectPersonNamesToIds(self): |
| 1 | 457 """Ordne Namen aus dem Triplestore bzw. die vergebenenden Label den Personen-Ids zu.""" |
| 5 | 458 #sollte z.B. gemacht werden, wenn im Triplestore editiert wurde. |
| 4 | 459 self.personIDtoNames=OOBTree() # loesche alle |
| 460 self.personsIDForSort=[] | |
| 5 | 461 self.personsIDForSortFull=[] |
| 0 | 462 for personID in self.persons2Projects: |
| 6 | 463 self.addPersonAndFirstNameFromTripleStore(personID) |
| 4 | 464 |
| 465 | |
| 466 | |
| 467 | |
| 468 #sortiere personIDs nach erstmal nach Nachnamene TODO: sortiere nach name,vorname | |
| 5 | 469 |
| 470 self.generateSortingOrderForPersonIDs(); | |
| 471 # def sort(x,y): | |
| 472 # logging.debug("sort:") | |
| 473 # logging.debug((x[1][0],y[1][0])) | |
| 474 # return cmp(x[1][0],y[1][0]) | |
| 475 # | |
| 476 # self.personsIDForSortFull.sort(cmp=sort) | |
| 477 # | |
| 478 # self.personsIDForSort=[x[0] for x in self.personsIDForSortFull] | |
| 479 # | |
| 480 # self.personIDtoNames=self.personIDtoNames # make clear that it has changed #TODO: change this to variablen with names _p | |
| 481 # | |
| 1 | 482 #Hole die Namen, die einer personID zugeordnet sind. |
| 0 | 483 def getNamesFromID(self,personID): |
| 7 | 484 personID=personID.rstrip().lstrip() #make sure no spaces |
| 485 logging.debug("<"+personID+">") | |
| 0 | 486 retStr="" |
| 7 | 487 |
| 488 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!! | |
| 8 | 489 #additionalNames = self.personIDtoNames.get(personID,['',[]])[1] |
| 490 #if len(additionalNames)>0: | |
| 491 # retStr+=" ("+",".join(additionalNames)+","+")" | |
| 0 | 492 return retStr |
| 493 | |
| 494 | |
| 1 | 495 #Hole die Hauptnamemsansetzung aus dem Triplestore ),falls vorhanden, wenn nicht ist der String leer. |
| 4 | 496 #ausserdem einen Namen zum sortieren, = Tupel(nachname, vorname) |
| 0 | 497 def getMainNameFromTripleStore(self,personID): |
| 498 | |
| 499 | |
| 500 cmdString ="""select * where { <%s> <http://xmlns.com/foaf/0.1/name> ?name}"""%personID | |
| 501 | |
| 4 | 502 names= self.callSparql(cmdString) |
| 503 | |
| 504 cmdString ="""select * where { <%s> <http://xmlns.com/foaf/0.1/lastName> ?name}"""%personID | |
| 505 | |
| 506 lastName= self.callSparql(cmdString) | |
| 507 | |
| 508 cmdString ="""select * where { <%s> <http://xmlns.com/foaf/0.1/firstName> ?name}"""%personID | |
| 509 | |
| 510 firstName= self.callSparql(cmdString) | |
| 511 | |
| 512 return names,(lastName,firstName) | |
| 513 | |
| 514 | |
| 7 | 515 def callSparqlAll(self,cmdString): |
| 516 """list of results""" | |
| 517 auth_handler = urllib2.HTTPBasicAuthHandler() | |
| 518 auth_handler.add_password(realm='sparql', | |
| 519 uri=self.virtuosoServer+"/sparql", | |
| 520 user=self.virtuosoDAVUser, | |
| 521 passwd=self.virtuosoDAVPW) | |
| 522 | |
| 523 opener = urllib2.build_opener(auth_handler) | |
| 524 opener.addheaders = [('Content-Type','application/sparql-query')] | |
| 525 | |
| 526 logging.debug(cmdString) | |
| 527 try: | |
| 528 logging.debug(self.virtuosoServer+"/sparql?" + urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':'','format':'text/csv'})) | |
| 529 #r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':'','format':'text/csv'})) | |
| 530 r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':'','named-graph-uri':'','format':'text/csv'})) | |
| 531 namesTxt=r.read() | |
| 532 except urllib2.URLError, e: | |
| 533 logging.error(e.code) | |
| 534 logging.error(e.read()) | |
| 535 | |
| 536 | |
| 537 return | |
| 538 logging.debug(namesTxt) | |
| 539 names=namesTxt.split("\n") | |
| 10 | 540 if len(names) < 2: #in der ersten Zeile stehen bei der Rueckgabe die Spaltennamen, <2 heiss also es gibt keinen Eintrag |
| 7 | 541 return [] |
| 542 | |
| 543 ret=[] | |
| 544 for name in names[1:]: | |
| 545 line=[] | |
| 546 for entry in name.split("\",\""): | |
| 547 | |
| 548 line.append(entry.replace('"','')); | |
| 549 ret.append(line); | |
| 550 return ret; | |
| 551 | |
| 4 | 552 def callSparql(self,cmdString): |
| 0 | 553 |
| 554 auth_handler = urllib2.HTTPBasicAuthHandler() | |
| 555 auth_handler.add_password(realm='sparql', | |
| 556 uri=self.virtuosoServer+"/sparql", | |
| 557 user=self.virtuosoDAVUser, | |
| 558 passwd=self.virtuosoDAVPW) | |
| 559 | |
| 560 opener = urllib2.build_opener(auth_handler) | |
| 561 opener.addheaders = [('Content-Type','application/sparql-query')] | |
| 562 | |
| 563 logging.debug(cmdString) | |
| 564 try: | |
| 4 | 565 logging.debug(self.virtuosoServer+"/sparql?" + urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':'','format':'text/csv'})) |
| 566 #r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':'','format':'text/csv'})) | |
| 567 r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':'','named-graph-uri':'','format':'text/csv'})) | |
| 0 | 568 namesTxt=r.read() |
| 569 except urllib2.URLError, e: | |
| 570 logging.error(e.code) | |
| 571 logging.error(e.read()) | |
| 4 | 572 |
| 573 | |
| 0 | 574 return |
| 4 | 575 logging.debug(namesTxt) |
| 0 | 576 names=namesTxt.split("\n") |
| 10 | 577 if len(names) < 2: #in der ersten Zeile stehen bei der Rueckgabe die Spaltennamen, <2 heiss also es gibt keinen Eintrag |
| 0 | 578 return |
| 579 | |
| 580 return names[1].replace('"','') # wir nehmen nur den ersten treffer | |
| 581 | |
| 582 | |
| 2 | 583 security.declareProtected('View management screens','changeTags') |
| 0 | 584 def changeTags(self,projectID,approaches=[],disciplines=[],periods=[],spaces=[],technologies=[],transfers=[],RESPONSE=None): |
| 585 """change tags""" | |
| 586 self.changeTagFromList(projectID,"approaches", approaches) | |
| 587 self.changeTagFromList(projectID,"disciplines", disciplines) | |
| 588 self.changeTagFromList(projectID,"periods", periods) | |
| 589 self.changeTagFromList(projectID,"spaces", spaces) | |
| 590 self.changeTagFromList(projectID,"technologies", technologies) | |
| 591 self.changeTagFromList(projectID,"transfers", transfers) | |
| 592 | |
| 593 self.projectObjects=self.projectObjects #necessesary to make the object persistent after the first call | |
| 594 self.projectHistoricalPlaces=self.projectHistoricalPlaces #necessesary to make the object persistent after the first call | |
| 595 self.projectPersons=self.projectPersons #necessesary to make the object persistent after the first call | |
| 596 self.projectSuggestedTags=self.projectSuggestedTags | |
| 597 | |
| 598 self.persons2Projects=self.persons2Projects | |
| 3 | 599 self.objects2Projects=self.objects2Projects |
| 0 | 600 self.historicalPlaces2Projects=self.historicalPlaces2Projects |
| 601 self.suggestedTags2Projects=self.suggestedTags2Projects; | |
| 602 | |
| 603 self.suggestedPersons=self.suggestedPersons; | |
| 604 | |
| 2 | 605 security.declareProtected('View management screens','deleteAllTags') |
| 0 | 606 def deleteAllTags(self): |
| 607 """deleteAllTags - TODO: take this out!!,""" | |
| 608 setattr(self,"tags",None) | |
| 609 | |
| 610 return "DONE!" | |
| 611 | |
| 2 | 612 security.declareProtected('View management screens','deleteAllPersons') |
| 0 | 613 def deleteAllPersons(self): |
| 614 """deleteAllTags - TODO: take this out!!,""" | |
| 615 self.projectPersons= OOBTree() | |
| 616 self.persons2Projects= OOBTree() | |
| 617 self.personIDtoNames=OOBTree() | |
| 618 self.suggestedPersons= OOBTree(); #TODO: das sollte die ueberfluessig werde und nur im triple store stehen. | |
| 619 | |
| 620 | |
| 621 return "DONE!" | |
| 2 | 622 |
| 3 | 623 security.declareProtected('View management screens','deleteAllObjects') |
| 624 def deleteAllObjects(self): | |
| 625 """deleteAllTags - TODO: take this out!!,""" | |
| 626 logging.debug("delete all objects") | |
| 627 self.projectObjects= OOBTree() | |
| 628 self.objects2Projects=OOBTree() | |
| 629 | |
| 630 | |
| 631 return "DONE!" | |
| 632 | |
| 0 | 633 def changeTagFromList(self,projectID,tagType,tagList): |
| 634 | |
| 635 logging.debug("changing:"+projectID) | |
| 636 logging.debug("asking tag::"+tagType) | |
| 637 if type(tagList) is not ListType: | |
| 638 tagList=[tagList] | |
| 639 | |
| 640 | |
| 641 tags = getattr(self,"tags",None) | |
| 642 if tags is None: | |
| 643 logging.debug("Create new tags") | |
| 644 tags=OOBTree() | |
| 645 setattr(self,"tags",tags) | |
| 646 | |
| 647 | |
| 648 tagsStored=tags.get(tagType,None) | |
| 649 if tagsStored is None: | |
| 650 tagsStored=OOBTree(); | |
| 651 | |
| 652 | |
| 653 | |
| 654 for tag in tagsStored.keys(): #gehe durch alle gespeichteren tags | |
| 655 logging.debug("checking:"+tag) | |
| 15 | 656 projectsOfTag = tagsStored.get(tag,None) |
| 657 logging.debug(projectsOfTag) | |
| 658 if projectsOfTag is None: | |
| 659 projectsOfTag=OOSet() | |
| 0 | 660 |
| 661 if tag in tagList: #dieser ist getagged | |
| 15 | 662 projectsOfTag.update([projectID]); |
| 663 self.storeChange("added",projectID,tag) | |
| 0 | 664 tagList.remove(tag); |
| 665 else: | |
| 15 | 666 if projectsOfTag.has_key(projectID): |
| 667 projectsOfTag.remove(projectID); | |
| 668 self.storeChange("remove",projectID,tag) | |
| 669 | |
| 670 tagsStored.update({tag:projectsOfTag}); | |
| 0 | 671 |
| 15 | 672 for tag in tagList: # alle Tags, die nicht abgearbeitet worden sind, muessen noch angelegt werden |
| 0 | 673 logging.debug("adding:"+tag) |
| 674 newApproach=OOSet() | |
| 675 newApproach.update([projectID]); | |
| 676 tagsStored.insert(tag, newApproach); | |
| 677 | |
| 678 tags.update({tagType:tagsStored}) | |
| 679 | |
| 680 transaction.commit() | |
| 681 | |
| 682 def getTitle(self,entry): | |
| 683 return entry.title | |
| 684 | |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
685 def thes_quote(self,txt): |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
686 import md5 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
687 logging.debug("@*%s*@"%txt) |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
688 return md5.md5(txt.lower()).hexdigest() |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
689 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
690 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
691 def formatTag(self,tag): |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
692 splitted= tag.split("_") |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
693 return splitted[-1] |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
694 |
| 15 | 695 def getEntriesFormatted(self,entries,formatType): |
| 12 | 696 if not hasattr(self,'levelFormatted'): |
| 32 | 697 pt=PageTemplateFile('zpt/levelFormatted', globals()).__of__(self) |
| 15 | 698 return pt(level1_entries=entries,type=formatType) |
| 12 | 699 |
| 32 | 700 pt = getattr(self,'levelFormatted') |
| 28 | 701 return pt(level1_entries=entries,type=formatType) |
| 702 | |
| 703 | |
| 704 #return self.levelFormatted(level1_entries=entries,type=formatType) | |
| 12 | 705 |
| 0 | 706 def getEntries(self,entry): |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
707 #logging.debug("GETENTRY:"+repr(entry)) |
| 0 | 708 return entry.entries |
| 709 | |
| 1 | 710 #nimmt ein eine Text der Form |
| 711 # TAG1 | |
| 712 # --- | |
| 713 # SUBTAG1_1 | |
| 714 # SUBTAG1_2 | |
| 715 # --- | |
| 716 # TAG2 | |
| 717 # --- | |
| 718 # SUBTAG2_1 | |
| 719 # SUBTAG2_2 | |
| 720 #.... | |
| 721 # und erzeugt daraus eine entsprechende Liste von Entries | |
| 0 | 722 def getEntriesFromTxt(self,txt): |
| 27 | 723 |
| 0 | 724 apps=[] |
| 725 lines=txt.split("\n"); | |
| 726 level=False | |
| 727 for line in lines: | |
| 728 line=line.rstrip().lstrip() | |
| 729 if line=="": | |
| 730 continue | |
| 731 if line=="---": | |
| 732 | |
| 733 if level: | |
| 734 level=False | |
| 735 else: | |
| 736 level=True | |
| 737 else: | |
| 738 if not level: | |
| 739 entry=Entry(line,[]) | |
| 740 apps.append(entry) | |
| 741 else: | |
| 742 entry.entries.append(Entry(line)) | |
| 743 | |
| 744 return apps[0:] | |
| 745 | |
| 746 def getApproaches(self): | |
| 747 | |
| 748 self.tagList=self.getEntriesFromTxt(self.approachesTxt) | |
| 749 return self.tagList | |
| 750 | |
| 2 | 751 |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
752 def getTagsAsHash(self,projectID,tagType=None): |
| 36 | 753 """get all tags as hash or None if no tag exists""" |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
754 retHash={} |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
755 |
| 36 | 756 tagCnt=0 |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
757 tags = getattr(self,"tags",None) |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
758 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
759 if tags is None: |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
760 return; |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
761 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
762 #falls nicht gesetzt |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
763 if tagType is None: |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
764 tagTypes = tags.keys() |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
765 else: |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
766 tagTypes = [tagType] |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
767 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
768 for tagType in tagTypes: |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
769 tagsStored=tags.get(tagType,None) |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
770 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
771 if tagsStored is None: |
| 39 | 772 # WTF: was: return |
| 773 continue | |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
774 |
| 39 | 775 retHash[tagType]=[] |
| 776 | |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
777 for tag in tagsStored.keys(): #gehe durch alle gespeichteren approached |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
778 logging.debug("checking:"+tag) |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
779 currentTag = tagsStored.get(tag,None) |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
780 if currentTag is None: |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
781 continue |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
782 if currentTag.has_key(projectID): |
| 36 | 783 tagCnt+=1 |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
784 retHash[tagType].append("""%s"""%tag) |
| 39 | 785 |
| 786 if len(retHash[tagType]) == 0: | |
| 787 # empty tag list | |
| 788 del retHash[tagType] | |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
789 |
| 36 | 790 if tagCnt==0: |
| 791 return None | |
| 792 | |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
793 return retHash |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
794 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
795 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
796 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
797 |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
798 |
| 0 | 799 def getTagsJSON(self,projectID,tagType,RESPONSE=None): |
| 800 """get all selected tagList""" | |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
801 #logging.debug("asking:"+projectID) |
|
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
802 #logging.debug("asking tag::"+tagType) |
| 0 | 803 retList=[] |
| 804 tags = getattr(self,"tags",None) | |
| 805 if tags is None: | |
| 806 return; | |
| 807 | |
| 808 tagsStored=tags.get(tagType,None) | |
| 809 if tagsStored is None: | |
| 810 return; | |
| 811 | |
| 812 for tag in tagsStored.keys(): #gehe durch alle gespeichteren approached | |
| 813 logging.debug("checking:"+tag) | |
| 814 currentTag = tagsStored.get(tag,None) | |
| 815 if currentTag is None: | |
| 816 continue | |
| 817 if currentTag.has_key(projectID): | |
| 818 retList.append(""" "%s" """%tag) | |
| 819 | |
| 820 if RESPONSE: | |
| 821 RESPONSE.setHeader('Content-Type', "application/json") | |
| 822 | |
| 823 logging.debug(retList) | |
| 824 return "["+",".join(retList)+"]" | |
| 825 | |
| 21 | 826 |
| 827 | |
| 828 | |
| 25 | 829 def getTags(self,projectID,projectTags,RESPONSE=None): |
| 21 | 830 """get all selected tagList""" |
| 831 | |
| 25 | 832 #projectTags = self.getProjectsAndTags() |
|
35
cfb5bb05253a
direct oeffne des thesaurus mit neuem parameter open
dwinter
parents:
32
diff
changeset
|
833 #logging.debug(projectTags) |
| 21 | 834 |
| 25 | 835 project = projectTags.get(projectID) |
| 836 if project is None: | |
| 837 project = projectTags.get("/en/research/projects/"+projectID) #TODO fix this projectTag list from getProjectsAndTags()contains fullpath | |
| 838 if project is None: | |
| 839 return [] | |
| 840 retarray=[] | |
| 21 | 841 for tagType in self.tags.keys(): |
| 25 | 842 tags = project.tags.get(tagType,['']) |
| 41 | 843 retarray.append(utf8ify(";".join(tags))) |
| 21 | 844 |
| 845 | |
| 25 | 846 return retarray |
| 847 # logging.debug("asking:"+projectID) | |
| 848 # | |
| 849 # | |
| 850 # apps = self.getApproaches()+ self.getDisciplines(); | |
| 851 # retList=[] | |
| 852 # for tagType in self.tags.keys(): | |
| 853 # | |
| 854 # logging.debug("asking tag::"+repr(tagType)) | |
| 855 # | |
| 856 # tags = getattr(self,"tags",None) | |
| 857 # if tags is None: | |
| 858 # continue; | |
| 859 # | |
| 860 # tagsStored=tags.get(tagType,None) | |
| 861 # if tagsStored is None: | |
| 862 # continue; | |
| 863 # | |
| 864 # for tag in tagsStored.keys(): #gehe durch alle gespeichteren approached | |
| 865 # logging.debug("checking:"+tag) | |
| 866 # currentTag = tagsStored.get(tag,None) | |
| 867 # if currentTag is None: | |
| 868 # continue | |
| 869 # if currentTag.has_key(projectID): | |
| 870 # retList.append(""" "%s" """%tag) | |
| 871 # | |
| 872 # if RESPONSE: | |
| 873 # RESPONSE.setHeader('Content-Type', "application/json") | |
| 874 # | |
| 875 # logging.debug(retList) | |
| 876 # return retList | |
| 21 | 877 |
| 0 | 878 def getDisciplines(self): |
| 879 | |
| 880 self.disciplines=self.getEntriesFromTxt(self.disciplinesTxt) | |
| 881 return self.disciplines | |
| 882 | |
| 883 | |
| 884 def getObjectsJSON(self,term="",RESPONSE=None): | |
| 885 """ get all stored objects as json list starting with term""" | |
| 886 term=term.lower(); | |
| 887 logging.debug("Asking:"+term) | |
| 888 #objectList=["baus","berg","lurg"] | |
| 889 objects = self.objects2Projects; | |
| 890 | |
| 891 objectList= [x for x in objects.keys()] | |
| 892 | |
| 893 logging.debug("Create:"+repr(objectList)) | |
| 894 retList=[] | |
| 895 for object in objectList: | |
| 896 if object.find(term)>-1: | |
| 897 retList.append(""" "%s" """%object) | |
| 898 ret="[" | |
| 899 ret+=",".join(retList) | |
| 900 ret+="]" | |
| 901 logging.debug("Objects:"+ret) | |
| 902 if RESPONSE: | |
| 903 RESPONSE.setHeader('Content-Type', "application/json") | |
| 904 return ret | |
| 905 | |
| 906 | |
| 907 def getHistoricalPlacesJSON(self,term="",RESPONSE=None): | |
| 908 """ get all stored historicalPlaces as json list starting with term""" | |
| 909 term=term.lower(); | |
| 910 logging.debug("Asking:"+term) | |
| 911 #historicalPlaceList=["baus","berg","lurg"] | |
| 912 historicalPlaces = self.historicalPlaces2Projects; | |
| 913 | |
| 914 historicalPlaceList= [x for x in historicalPlaces.keys()] | |
| 915 | |
| 916 logging.debug("Create:"+repr(historicalPlaceList)) | |
| 917 retList=[] | |
| 918 for historicalPlace in historicalPlaceList: | |
| 919 if historicalPlace.find(term)>-1: | |
| 920 retList.append(""" "%s" """%historicalPlace) | |
| 921 ret="[" | |
| 922 ret+=",".join(retList) | |
| 923 ret+="]" | |
| 924 logging.debug("historicalPlaces:"+ret) | |
| 925 if RESPONSE: | |
| 926 RESPONSE.setHeader('Content-Type', "application/json") | |
| 927 return ret | |
| 928 | |
| 929 | |
| 930 def getPeriods(self): | |
| 931 | |
| 932 self.periodes=self.getEntriesFromTxt(self.periodsTxt) | |
| 933 return self.periodes | |
| 934 | |
| 935 def getSpaces(self): | |
| 936 | |
| 937 self.spaces=self.getEntriesFromTxt(self.spacesTxt) | |
| 938 return self.spaces | |
| 939 | |
| 940 def getTechnologies(self): | |
| 941 | |
| 942 self.technologies=self.getEntriesFromTxt(self.technologiesTxt) | |
| 943 return self.technologies | |
| 944 | |
| 945 def getKnowledgeTransfers(self): | |
| 946 | |
| 947 self.knowledgeTransfers=self.getEntriesFromTxt(self.knowledgeTransfersTxt) | |
| 948 return self.knowledgeTransfers | |
| 949 | |
| 950 | |
| 951 def getObjectsFromProject(self,projectID): | |
| 952 return self.getFromProject(self.projectObjects,projectID); | |
| 953 | |
| 954 def getHistoricalPlacesFromProject(self,projectID): | |
| 955 return self.getFromProject(self.projectHistoricalPlaces,projectID); | |
| 956 | |
| 957 def getSuggestedTagsFromProject(self,projectID): | |
| 958 return self.getFromProject(self.projectSuggestedTags,projectID); | |
| 959 | |
| 960 | |
| 961 def getPersonsFromProject(self,projectID): | |
| 5 | 962 #hole alle personenID die zu einem Projekt gehoeren. |
| 963 #zurueckgegeben wird ein OOSet() | |
| 0 | 964 return self.getFromProject(self.projectPersons,projectID); |
| 965 | |
| 5 | 966 def getFromProject(self,objects,projectID): |
| 967 #holt die zu projectID gehoerigen objekte aus dem objects-set. | |
| 968 #oder legt einen neuen leeren Satz zu dieser ProjektID an. | |
| 969 #zuruecgegeben wird ein OOSet() | |
| 970 if objects.has_key(projectID): #wenn zu der ProjektID schon etwas abgespeichter ist, gieb es zurueck | |
| 0 | 971 logging.debug("key exists:"+projectID) |
| 972 persons=objects.get(projectID); | |
| 5 | 973 else: # andernfalls lege einen neuen Satz an. |
| 0 | 974 persons=OOSet() |
| 975 objects.update({projectID:persons}) | |
| 976 logging.debug("key does not exists:"+projectID) | |
| 977 | |
| 978 | |
| 979 return persons | |
| 980 | |
| 981 def getHistoricalPlacesFromProjectAsHTML(self,projectID): | |
| 982 """gertobjects""" | |
| 983 return self.getFromProjectAsHTML(self.projectHistoricalPlaces, projectID, "HistoricalPlace"); | |
| 984 | |
| 985 def getObjectsFromProjectAsHTML(self,projectID): | |
| 986 """gertobjects""" | |
| 987 return self.getFromProjectAsHTML(self.projectObjects, projectID, "Object"); | |
| 988 | |
| 989 def getPersonsFromProjectAsHTML(self,projectID): | |
| 990 """getpersons""" | |
| 991 return self.getFromProjectAsHTML(self.projectPersons, projectID, "Person"); | |
| 992 | |
| 993 | |
| 994 def getFromProjectAsHTML(self,objects,projectID,type): | |
| 995 """getpersons""" | |
| 996 ret="" | |
| 997 if objects.has_key(projectID): | |
| 998 persons=objects.get(projectID); | |
| 999 else: | |
| 1000 persons=OOSet() | |
| 1001 | |
| 1002 | |
| 1003 for person in persons: | |
| 1004 ret+="""<div class="removeButton"> | |
| 1005 <span>%s </span><div style="display:inline" class="remove%s"><span style="display:none" class="removeValue">%s</span>remove</div> | |
| 1006 </div>"""%(person[1],type,person[0]) | |
| 1007 | |
| 1008 | |
| 1009 # ret+="""<div> | |
| 1010 # <input type="checkbox" name="persons_remove" | |
| 1011 # value="%s"> | |
| 1012 # <span>%s</span> | |
| 1013 # </div>"""%(person[0],person[1]) | |
| 1014 # | |
| 1015 logging.debug(type+":"+ret) | |
| 1016 return ret | |
| 1017 | |
| 2 | 1018 security.declareProtected('View management screens','removeHistoricalPlaceFromProject') |
| 0 | 1019 def removeHistoricalPlaceFromProject(self,projectID,value): |
| 1020 """remove""" | |
| 1021 logging.debug("removeHP:"+projectID+":"+value); | |
| 1022 | |
| 1023 HistoricalPlaces = self.getHistoricalPlacesFromProject(projectID) | |
| 1024 for HistoricalPlace in HistoricalPlaces.keys(): | |
| 1025 | |
| 1026 logging.debug("trying:"+repr(HistoricalPlace[0])+"::"+repr(value)+"__") | |
| 1027 if HistoricalPlace[0]==value: | |
| 1028 logging.debug("---removed!") | |
| 1029 HistoricalPlaces.remove(HistoricalPlace) | |
| 1030 | |
| 1031 self.projectHistoricalPlaces.update({projectID:HistoricalPlaces}) | |
| 1032 retstring = self.getHistoricalPlacesFromProjectAsHTML(projectID) | |
| 1033 logging.debug(retstring) | |
| 1034 return retstring | |
| 1035 | |
| 2 | 1036 security.declareProtected('View management screens','removeObjectFromProject') |
| 0 | 1037 def removeObjectFromProject(self,projectID,value): |
| 1038 """remove""" | |
| 1039 logging.debug("remove:"+projectID+":"+value); | |
| 1040 | |
| 15 | 1041 |
| 1042 self.storeChange("removeObject",projectID,value) | |
| 1043 | |
| 0 | 1044 objects = self.getObjectsFromProject(projectID) |
| 1045 for object in objects.keys(): | |
| 1046 | |
| 1047 logging.debug("trying:"+repr(object[0])+"::"+repr(value)+"__") | |
| 1048 if object[0]==value: | |
| 1049 logging.debug("---removed!") | |
| 1050 objects.remove(object) | |
| 1051 | |
| 15 | 1052 #now also delete the project from the object. |
| 1053 objectsOfPerson=self.objects2Projects.get(object[0]) | |
| 1054 | |
| 1055 | |
| 1056 if projectID in list(objectsOfPerson): | |
| 1057 objectsOfPerson.remove(projectID) | |
| 1058 #self.persons2Projects.update({person:projectsList}) | |
| 1059 if (len(objectsOfPerson)==0): #loesche person aus der liste wenn keine Projekte dazu existieren. | |
| 1060 del self.objects2Projects[object[0]] | |
| 1061 | |
| 0 | 1062 self.projectObjects.update({projectID:objects}) |
| 1063 retstring = self.getObjectsFromProjectAsHTML(projectID) | |
| 1064 logging.debug(retstring) | |
| 1065 return retstring | |
| 1066 | |
| 2 | 1067 security.declareProtected('View management screens','removePersonFromProject') |
| 0 | 1068 def removePersonFromProject(self,projectID,value): |
| 5 | 1069 """remove a person from the projeckt""" |
| 0 | 1070 logging.debug("remove:"+projectID+":"+value); |
| 15 | 1071 self.storeChange("removePerson",projectID,value) |
| 0 | 1072 |
| 5 | 1073 persons = self.getPersonsFromProject(projectID) # hole alle personen die mit dem Projekt verbunden sind. |
| 0 | 1074 for person in persons.keys(): |
| 1075 | |
| 1076 logging.debug("trying:"+repr(person[0])+"::"+repr(value)+"__") | |
| 5 | 1077 if person[0]==value:#person ist die zuloeschende, dann raus damit |
| 1078 | |
| 0 | 1079 logging.debug("---removed!") |
| 1080 persons.remove(person) | |
| 5 | 1081 |
| 1082 #now also delete the project from the person. | |
| 1083 projectsOfPerson=self.persons2Projects.get(person[0]) | |
| 1084 logging.debug(projectsOfPerson) | |
| 1085 if projectID in list(projectsOfPerson): | |
| 1086 projectsOfPerson.remove(projectID) | |
| 1087 #self.persons2Projects.update({person:projectsList}) | |
| 1088 if (len(projectsOfPerson)==0): #loesche person aus der liste wenn keine Projekte dazu existieren. | |
| 1089 del self.persons2Projects[person[0]] | |
| 1090 | |
| 1091 | |
| 1092 #self.projectPersons.update({projectID:persons}) | |
| 0 | 1093 retstring = self.getPersonsFromProjectAsHTML(projectID) |
| 1094 logging.debug(retstring) | |
| 1095 return retstring | |
| 1096 | |
| 10 | 1097 |
| 1098 #fuegt die neue Person zur personIDtoNames hinzu, fuer die spaetere Anzeige in der Personenliste | |
| 0 | 1099 def addNameTOPersonIDNames(self,personID,label): |
| 1100 personName = self.personIDtoNames.get(personID) | |
| 1101 if personName==None: # Anlegen falls noch nicht existent | |
| 1102 personName=(label,[]) | |
| 1103 else: | |
| 1104 if (not label in personName[1]) and (not label==personName[0]): # hinzufuegen falls der neuen name noch nicht als bezeichnugn fuer personID eingetragen ist | |
| 1105 personName[1].append(label) | |
| 1106 | |
| 1107 self.personIDtoNames.update({personID:personName}) | |
| 1108 | |
| 2 | 1109 security.declareProtected('View management screens','addPersonToProject') |
| 0 | 1110 def addPersonToProject(self,projectID,value,label): |
| 1111 """ add a person so the project""" | |
| 15 | 1112 self.storeChange("addPerson",projectID,value+":"+label) |
| 1113 | |
| 0 | 1114 persons=self.getPersonsFromProject(projectID); |
| 1115 | |
| 1116 logging.debug("adding:"+projectID+":"+value+":"+label); | |
| 1117 | |
| 1118 persons.insert([value,label]) | |
| 1119 self.projectPersons.update({projectID:persons}) | |
| 1120 | |
| 1121 for personTuple in persons: | |
| 1122 #hole die abgespeicherten Projekte zu einer Person | |
| 1123 person=personTuple[0] #hole die ID | |
| 1124 | |
| 1125 | |
| 1126 if getattr(self,"persons2Projects",None)==None: | |
| 1127 setattr(self,"persons2Projects",OOBTree()) | |
| 1128 | |
| 1129 projects = self.persons2Projects.get(person,None) | |
| 7 | 1130 logging.debug("found projects:"+ repr(projects)) |
| 1131 if projects is None: #person hatte noch keine projekte | |
| 0 | 1132 projects=OOSet(); |
| 5 | 1133 |
| 0 | 1134 projects.insert(projectID ) |
| 1135 logging.debug("update:"+person) | |
| 1136 self.persons2Projects.update({person:projects}) | |
| 7 | 1137 |
| 1138 self.addPersonAndFirstNameFromTripleStore(person) | |
| 1139 self.generateSortingOrderForPersonIDs(); | |
| 1140 | |
| 0 | 1141 self.addNameTOPersonIDNames(value,label) |
| 1142 retstring = self.getPersonsFromProjectAsHTML(projectID) | |
| 1143 logging.debug(retstring) | |
| 1144 transaction.commit() | |
| 1145 return retstring | |
| 1146 | |
| 7 | 1147 |
| 1148 | |
| 1149 def rearangePersonIDsHTML(self,REQUEST=None): | |
| 1150 """setze neue ID zu personen""" | |
| 1151 ret=[] | |
| 1152 for personID in self.persons2Projects.keys(): | |
| 1153 logging.debug(personID) | |
| 1154 | |
| 1155 masterID,name=self.findMasterIDAndName(personID.rstrip().lstrip()) | |
| 1156 logging.debug(" masterID -appending") | |
| 1157 logging.debug(repr(name)) | |
| 1158 if len(name)==0: | |
| 1159 name=[''] | |
| 1160 ret.append((personID,self.personIDtoNames.get(personID,[''])[0],masterID,self.personIDtoNames.get(masterID,name)[0])) | |
| 1161 | |
| 1162 | |
| 1163 if REQUEST: | |
| 1164 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','rearrangePersons.zpt')).__of__(self) | |
| 8 | 1165 return pt(changeList=ret,lookupUrl=self.PERSONS_LOOKUP_URL,editURL=self.EDIT_URL); |
| 7 | 1166 else: |
| 1167 return ret; | |
| 1168 | |
| 1169 def rearangePersonIDs(self,REQUEST): | |
| 1170 """unify a list of persons""" | |
| 1171 | |
| 1172 argv=REQUEST.form; | |
| 1173 logging.debug(repr(argv)) | |
| 1174 changes=argv['changes'] | |
| 1175 if isinstance(changes,str): | |
| 1176 changes=[changes] | |
| 1177 | |
| 1178 changeList=self.rearangePersonIDsHTML() | |
| 1179 personToMaster={} | |
| 1180 logging.debug("changelist:"+repr(changeList)) | |
| 1181 #aendere person2project | |
| 1182 for change in changes: | |
| 1183 changeItem=changeList[int(change)]; | |
| 1184 masterID=argv['newID_'+change].lstrip().rstrip() #make sure no spaces | |
| 1185 personID=changeItem[0] | |
| 1186 | |
| 1187 personToMaster[personID]=masterID | |
| 1188 masterIDProjects = self.persons2Projects.get(masterID,None); | |
| 1189 if masterIDProjects==None: | |
| 1190 masterIDProjects=OOSet(); | |
| 1191 #ret.append((personID,self.personIDtoNames.get(personID,[''])[0],masterID,self.personIDtoNames.get(masterID,[''])[0])) | |
| 1192 | |
| 1193 oldProjects= self.persons2Projects.get(personID) | |
| 1194 logging.debug("personID:"+repr(personID)) | |
| 1195 logging.debug("masterID:"+repr(masterID)) | |
| 1196 logging.debug("keys:"+repr(self.persons2Projects.keys())) | |
| 1197 logging.debug("oldProjects:"+repr(oldProjects)) | |
| 1198 masterIDProjects.update(oldProjects) | |
| 1199 self.persons2Projects.update({masterID:masterIDProjects}) | |
| 1200 self.persons2Projects.pop(personID) | |
| 1201 | |
| 1202 self.addPersonAndFirstNameFromTripleStore(masterID) #addpersontotiplestore | |
| 1203 | |
| 1204 logging.debug("Change:" +personID+":"+ masterID) | |
| 1205 | |
| 1206 if personID!=masterID: | |
| 1207 self.addSameAsRelationToTripleStore(personID,masterID) | |
| 1208 | |
| 1209 #aendere nun projectperson | |
| 1210 logging.debug(personToMaster) | |
| 1211 for project in self.projectPersons.keys(): | |
| 1212 personsNew=OOSet() | |
| 1213 | |
| 1214 persons=self.projectPersons.get(project) | |
| 1215 for person in persons: | |
| 1216 personsNew.insert([personToMaster.get(person[0],person[0]),person[1]]) | |
| 1217 logging.debug("REPLACE in:"+project+":" +repr(person)+" by "+ repr(personToMaster.get(person[0],person[0]))) | |
| 1218 self.projectPersons.update({project:personsNew}) | |
| 1219 | |
| 1220 self.generateSortingOrderForPersonIDs(); #now sort the new names | |
| 1221 return personToMaster | |
| 1222 #fuehre personen zusammen die ueber owl:sameAs verbunden sind | |
| 1223 def getUnifyPersonsList(self,REQUEST=None): | |
| 1224 """vereinheitlichung der personen auf eine ID aus der GND, wenn moeglich""" | |
| 1225 ret=[] | |
| 1226 for personID in self.persons2Projects.keys(): | |
| 1227 masterID,name=self.findMasterIDAndName(personID) | |
| 1228 logging.debug("masterID:"+masterID) | |
| 1229 if (masterID is not None) and (masterID is not "") and (not personID==masterID): | |
| 1230 #masterIDProjects = self.persons2Projects.get(masterID,None); | |
| 1231 ##if masterIDProjects==None: | |
| 1232 # masterIDProjects=OOSet(); | |
| 1233 logging.debug(" masterID -appending") | |
| 1234 logging.debug(repr(name)) | |
| 1235 | |
| 1236 | |
| 1237 ret.append((personID,self.personIDtoNames.get(personID,[''])[0],masterID,self.personIDtoNames.get(masterID,name)[0])) | |
| 1238 #masterIDProjects.update(self.persons2Projects.get(personID)); | |
| 1239 #self.persons2Projects.update({masterID:masterIDProjects}); | |
| 1240 | |
| 1241 | |
| 1242 if REQUEST: | |
| 1243 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','unifyPersons.zpt')).__of__(self) | |
| 1244 return pt(changeList=ret); | |
| 1245 | |
| 1246 else: | |
| 1247 return ret; | |
| 1248 | |
| 1249 def unifyPersons(self,changes,REQUEST=None): | |
| 1250 """unify a list of persons""" | |
| 1251 | |
| 1252 if isinstance(changes,str): | |
| 1253 changes=[changes] | |
| 1254 | |
| 1255 changeList=self.getUnifyPersonsList(); | |
| 1256 personToMaster={} | |
| 1257 logging.debug("changelist:"+repr(changeList)) | |
| 1258 #aendere person2project | |
| 1259 for change in changes: | |
| 1260 changeItem=changeList[int(change)]; | |
| 1261 masterID=changeItem[2] | |
| 1262 personID=changeItem[0] | |
| 1263 | |
| 1264 personToMaster[personID]=masterID | |
| 1265 masterIDProjects = self.persons2Projects.get(masterID,None); | |
| 1266 if masterIDProjects==None: | |
| 1267 masterIDProjects=OOSet(); | |
| 1268 #ret.append((personID,self.personIDtoNames.get(personID,[''])[0],masterID,self.personIDtoNames.get(masterID,[''])[0])) | |
| 1269 | |
| 1270 oldProjects= self.persons2Projects.get(personID) | |
| 1271 logging.debug("personID:"+repr(personID)) | |
| 1272 logging.debug("masterID:"+repr(masterID)) | |
| 1273 logging.debug("keys:"+repr(self.persons2Projects.keys())) | |
| 1274 logging.debug("oldProjects:"+repr(oldProjects)) | |
| 1275 masterIDProjects.update(oldProjects) | |
| 1276 self.persons2Projects.update({masterID:masterIDProjects}) | |
| 1277 self.persons2Projects.pop(personID) | |
| 1278 | |
| 1279 self.addPersonAndFirstNameFromTripleStore(masterID) #addpersontotiplestore | |
| 1280 | |
| 1281 logging.debug("Change:" +personID+":"+ masterID) | |
| 1282 | |
| 1283 #aendere nun projectperson | |
| 1284 logging.debug(personToMaster) | |
| 1285 for project in self.projectPersons.keys(): | |
| 1286 personsNew=OOSet() | |
| 1287 | |
| 1288 persons=self.projectPersons.get(project) | |
| 1289 for person in persons: | |
| 1290 personsNew.insert([personToMaster.get(person[0],person[0]),person[1]]) | |
| 1291 logging.debug("REPLACE in:"+project+":" +repr(person)+" by "+ repr(personToMaster.get(person[0],person[0]))) | |
| 1292 self.projectPersons.update({project:personsNew}) | |
| 1293 | |
| 1294 self.generateSortingOrderForPersonIDs(); #now sort the new names | |
| 1295 return personToMaster | |
| 1296 | |
| 1297 | |
| 1298 | |
| 1299 def findMasterIDAndName(self,ressourceID): | |
| 1300 queryString="""select * | |
| 1301 FROM <file://mpiwg_persons_dnb.rdf> | |
| 1302 FROM <file://mpiwg_persons_2.rdf> | |
| 1303 FROM <file:///GND.rdf> | |
| 1304 FROM <http://identifiedNames> | |
| 1305 where { | |
| 1306 ?person <http://www.w3.org/2002/07/owl#sameAs> <%s>. | |
| 1307 | |
| 1308 ?ident <http://ontologies.mpiwg-berlin.mpg.de/authorities/namedIdentities/identifies_NamedEntity> ?person. | |
| 1309 ?gnd crm:P1_is_identified_by ?ident. | |
| 1310 | |
| 1311 ?gnd <http://RDVocab.info/ElementsGr2/dateOfBirth> ?birthDate. | |
| 1312 ?gnd <http://RDVocab.info/ElementsGr2/dateOfDeath> ?deathDate. | |
| 1313 ?person <http://xmlns.com/foaf/0.1/name> ?name. | |
| 1314 ?person <http://xmlns.com/foaf/0.1/lastName> ?lastName. | |
| 1315 ?person <http://xmlns.com/foaf/0.1/firstName> ?firstName. | |
| 1316 } | |
| 1317 """%ressourceID | |
| 1318 entries = self.callSparqlAll(queryString); | |
| 1319 if len(entries)>0: | |
| 1320 return entries[0][0],entries[0][5:8] #nur den ersten Treffer und nur die personID | |
| 1321 | |
| 1322 | |
| 1323 return None,None | |
| 1324 | |
| 9 | 1325 security.declareProtected('View','getPersonsWithProjectIDs') |
| 5 | 1326 def getPersonsWithProjectIDs(self,check=False): |
| 0 | 1327 """holt die getaggted Personen mit Projekten""" |
| 1328 persons = self.persons2Projects; | |
| 1329 ret={} | |
| 4 | 1330 |
| 0 | 1331 logging.debug("Check Person:"+repr(persons.keys())) |
| 4 | 1332 personsList=[x for x in persons.keys()] |
| 1333 | |
| 1334 def sort(x,y): | |
| 7 | 1335 try: |
| 1336 sortNrx=self.personsIDForSort.index(x) | |
| 1337 except: | |
| 1338 logging.warn("couldn't find personsIDForSort:"+x) | |
| 1339 sortNrx=0 | |
| 1340 | |
| 1341 try: | |
| 1342 sortNry=self.personsIDForSort.index(y) | |
| 1343 except: | |
| 1344 logging.warn("couldn't find personsIDForSort:"+y) | |
| 1345 sortNry=0 | |
| 4 | 1346 #logging.debug("INSORT***") |
| 1347 #logging.debug((sortNrx,sortNry)) | |
| 1348 return cmp(sortNrx,sortNry) | |
| 1349 | |
| 1350 logging.debug("SORT***") | |
| 1351 logging.debug(self.personsIDForSort) | |
| 1352 logging.debug("SORT.list") | |
| 1353 logging.debug(personsList) | |
| 1354 personsList.sort(cmp=sort) | |
| 1355 #for person in persons.keys(): | |
| 1356 logging.debug("AFTERSORT***") | |
| 1357 logging.debug(personsList) | |
| 1358 for person in personsList: | |
| 0 | 1359 logging.debug("Check:"+person) |
| 4 | 1360 #TODO: person muss duch den namen von provider geholt werden |
| 5 | 1361 retlist=[] |
| 1362 projectsList=persons.get(person) | |
| 7 | 1363 if projectsList is None: |
| 1364 projectsList=[] | |
| 5 | 1365 for projectID in list(projectsList): #list notwendig da projectList in der folgenden iteration veraendert wird. |
| 1366 if check: #teste ob im Projekt noch ein Verweis auf den Namen steht | |
| 1367 #sollte eigentlich nicht sein. | |
| 1368 personsProjects=self.getPersonsFromProject(projectID) | |
| 1369 logging.debug("persons check mode") | |
| 1370 personsProjectsCheck=[x[0] for x in personsProjects] | |
| 1371 if not person in personsProjectsCheck: #falls es so ist korrigiere die Projektliste der Person | |
| 1372 #loesche die person von projectListe | |
| 1373 projectsList.remove(projectID) | |
| 1374 persons.update({person:projectsList}) | |
| 1375 | |
| 1376 retlist.append(self.getProjectDetails(projectID)) | |
| 1377 | |
| 1378 if check and (len(projectsList)==0): #loesche person aus der liste wenn keine Projekte dazu existieren. | |
| 1379 del persons[person] | |
| 1380 | |
| 1381 ret[person]=retlist[0:] | |
| 4 | 1382 |
| 1383 logging.debug("AFTERSORT-ret***") | |
| 1384 logging.debug(ret.keys()) | |
| 1385 return ret,personsList | |
| 0 | 1386 |
| 1387 def getHistoricalPlacesWithProjectIDs(self): | |
| 1388 """holt die getaggted Personen mit Projekten""" | |
| 1389 HistoricalPlaces = self.HistoricalPlaces2Projects; | |
| 1390 ret={} | |
| 1391 logging.debug("Check HistoricalPlace:"+repr(HistoricalPlaces.keys())) | |
| 1392 for HistoricalPlace in HistoricalPlaces.keys(): | |
| 1393 logging.debug("Check:"+HistoricalPlace) | |
| 1394 #TODO: HistoricalPlace muss duch den namen von provuder geholt werden | |
| 1395 list=[] | |
| 1396 for projectID in HistoricalPlaces.get(HistoricalPlace): | |
| 1397 list.append(self.getProjectDetails(projectID)) | |
| 1398 | |
| 1399 ret[HistoricalPlace]=list[0:] | |
| 1400 return ret | |
| 1401 | |
| 12 | 1402 def getObjectsWithProjectIDsSortedkeys(self): |
| 1403 | |
| 1404 def sortF(x,y): | |
| 1405 return cmp(x.lower(),y.lower()) | |
| 1406 keys = [x for x in self.getObjectsWithProjectIDs().keys()] | |
| 1407 keys.sort(sortF) | |
| 1408 return keys | |
| 1409 | |
| 0 | 1410 def getObjectsWithProjectIDs(self): |
| 15 | 1411 """holt die getagten Personen mit Projekten""" |
| 0 | 1412 objects = self.objects2Projects; |
| 1413 ret={} | |
| 1414 logging.debug("Check Object:"+repr(objects.keys())) | |
| 1415 for object in objects.keys(): | |
| 1416 logging.debug("Check:"+object) | |
| 1417 #TODO: object muss duch den namen von provuder geholt werden | |
| 1418 list=[] | |
| 1419 for projectID in objects.get(object): | |
| 1420 list.append(self.getProjectDetails(projectID)) | |
| 1421 | |
| 1422 ret[object]=list[0:] | |
| 28 | 1423 |
| 1424 logging.debug(ret) | |
| 0 | 1425 return ret |
| 1426 | |
| 2 | 1427 security.declareProtected('View management screens','listAllSuggestedTags') |
| 0 | 1428 def listAllSuggestedTags(self): |
| 1429 """list all tags""" | |
| 1430 ret="<html><body>" | |
| 1431 for projectID in self.projectSuggestedTags: | |
| 1432 ret+="<h3>"+projectID+"</h3><table>" | |
| 1433 for tags in self.projectSuggestedTags.get(projectID): | |
| 1434 ret+="<tr><td>"+tags[0]+"</td><td>"+tags[1].type+"</td><td>"+tags[1].comment+"</td><td>"+tags[1].userName+"</td></tr>" | |
| 1435 ret+="</table>" | |
| 1436 ret+="</body></html>" | |
| 1437 logging.debug(ret); | |
| 1438 return ret | |
| 2 | 1439 |
| 1440 security.declareProtected('View management screens','suggestTag') | |
| 0 | 1441 def suggestTag(self,projectID,tagName,tagComment,tagType,tagUserName): |
| 1442 """suggest a new tag""" | |
| 1443 """ add a person so the project""" | |
| 1444 SuggestedTags=self.getSuggestedTagsFromProject(projectID); | |
| 1445 | |
| 1446 logging.debug("suggested:"+projectID+":"+tagName); | |
| 1447 | |
| 1448 | |
| 1449 #TODO: Im moment noch keine Zuordnung zu einer ID. | |
| 1450 newTag = SuggestedTag(tagName,tagComment,tagType,tagUserName) | |
| 1451 SuggestedTags.insert([tagName,newTag]) | |
| 1452 self.projectSuggestedTags.update({projectID:SuggestedTags}) | |
| 1453 | |
| 1454 | |
| 1455 | |
| 1456 for SuggestedTagTuple in SuggestedTags: | |
| 1457 #hole die abgespeicherten Projekte zu einer Person | |
| 1458 person=SuggestedTagTuple[0] #hile die ID | |
| 1459 | |
| 1460 | |
| 1461 if getattr(self,"SuggestedTags2Projects",None)==None: | |
| 1462 setattr(self,"SuggestedTags2Projects",OOBTree()) | |
| 1463 | |
| 1464 projects = self.SuggestedTags2Projects.get(person,None) | |
| 1465 | |
| 1466 if projects==None: | |
| 1467 projects=OOSet(); | |
| 1468 | |
| 1469 projects.insert(projectID ) | |
| 1470 logging.debug("update:"+person) | |
| 1471 self.SuggestedTags2Projects.update({person:projects}) | |
| 1472 | |
| 1473 | |
| 1474 | |
| 1475 #retstring = self.getSuggestedTagsFromProjectAsHTML(projectID) | |
| 1476 #logging.debug(retstring) | |
| 1477 | |
| 1478 | |
| 1479 | |
| 1480 #return retstring | |
| 1481 | |
| 2 | 1482 security.declareProtected('View management screens','addHistoricalPlaceToProject') |
| 0 | 1483 def addHistoricalPlaceToProject(self,projectID,value): |
| 1484 """ add a person so the project""" | |
| 1485 HistoricalPlaces=self.getHistoricalPlacesFromProject(projectID); | |
| 1486 | |
| 1487 logging.debug("adding:"+projectID+":"+value); | |
| 1488 | |
| 1489 | |
| 1490 #TODO: Im moment noch keine Zuordnung zu einer ID. | |
| 1491 HistoricalPlaces.insert([value,value]) | |
| 1492 self.projectHistoricalPlaces.update({projectID:HistoricalPlaces}) | |
| 1493 | |
| 1494 | |
| 1495 | |
| 1496 for HistoricalPlaceTuple in HistoricalPlaces: | |
| 1497 #hole die abgespeicherten Projekte zu einer Person | |
| 1498 person=HistoricalPlaceTuple[0] #hile die ID | |
| 1499 | |
| 1500 | |
| 1501 if getattr(self,"HistoricalPlaces2Projects",None)==None: | |
| 1502 setattr(self,"HistoricalPlaces2Projects",OOBTree()) | |
| 1503 | |
| 1504 projects = self.HistoricalPlaces2Projects.get(person,None) | |
| 1505 | |
| 1506 if projects==None: | |
| 1507 projects=OOSet(); | |
| 1508 | |
| 1509 projects.insert(projectID ) | |
| 1510 logging.debug("update:"+person) | |
| 1511 self.HistoricalPlaces2Projects.update({person:projects}) | |
| 1512 | |
| 1513 | |
| 1514 | |
| 1515 retstring = self.getHistoricalPlacesFromProjectAsHTML(projectID) | |
| 1516 logging.debug(retstring) | |
| 1517 | |
| 1518 | |
| 1519 | |
| 1520 return retstring | |
| 1521 | |
| 2 | 1522 security.declareProtected('View management screens','addObjectToProject') |
| 0 | 1523 def addObjectToProject(self,projectID,value): |
| 1524 """ add a person so the project""" | |
| 1525 objects=self.getObjectsFromProject(projectID); | |
| 1526 | |
| 1527 logging.debug("adding:"+projectID+":"+value); | |
| 1528 | |
| 15 | 1529 self.storeChange("addObject",projectID,value) |
| 0 | 1530 |
| 1531 #TODO: Im moment noch keine Zuordnung zu einer ID. | |
| 1532 objects.insert([value,value]) | |
| 1533 self.projectObjects.update({projectID:objects}) | |
| 1534 | |
| 1535 | |
| 1536 | |
| 1537 for objectTuple in objects: | |
| 1538 #hole die abgespeicherten Projekte zu einer Person | |
| 1539 person=objectTuple[0] #hile die ID | |
| 1540 | |
| 1541 | |
| 1542 if getattr(self,"objects2Projects",None)==None: | |
| 1543 setattr(self,"objects2Projects",OOBTree()) | |
| 1544 | |
| 1545 projects = self.objects2Projects.get(person,None) | |
| 1546 | |
| 1547 if projects==None: | |
| 1548 projects=OOSet(); | |
| 1549 | |
| 1550 projects.insert(projectID ) | |
| 1551 logging.debug("update:"+person) | |
| 1552 self.objects2Projects.update({person:projects}) | |
| 1553 | |
| 1554 | |
| 1555 | |
| 1556 retstring = self.getObjectsFromProjectAsHTML(projectID) | |
| 1557 logging.debug(retstring) | |
| 1558 | |
| 1559 | |
| 1560 | |
| 1561 return retstring | |
| 1562 | |
| 1563 | |
| 1564 def getProjectsWithTag(self,tagType,tagName): | |
| 1565 tags = getattr(self,"tags",None) | |
| 1566 if tags is None: | |
| 1567 logging.debug("can't find Tags") | |
| 1568 return [] | |
| 1569 | |
| 1570 tagsStored=tags.get(tagType,None) | |
| 1571 if tagsStored is None: | |
| 1572 logging.debug("can't find Tag:"+tagType) | |
| 1573 return [] | |
| 1574 | |
| 1575 projects = tagsStored.get(tagName,None) | |
| 1576 if projects is None: | |
| 1577 logging.debug("can't find any projects for Tag:"+tagName+"("+tagType+")") | |
| 1578 return [] | |
| 1579 | |
| 1580 ret=[] | |
| 1581 for project in projects: | |
| 1582 logging.debug("found:"+project) | |
| 30 | 1583 proj =self.getProjectDetails(project); |
| 1584 if proj is not None: | |
| 1585 ret.append(proj) | |
| 0 | 1586 |
| 1587 return ret | |
| 1588 | |
| 38 | 1589 def getProjectDetails(self,projectId): |
| 41 | 1590 pf = self.getMPIWGRoot().getProjectFolder() |
| 1591 project=pf.get(projectId,None) | |
| 0 | 1592 if project is None: |
| 38 | 1593 logging.debug("no project!! " +projectId) |
| 30 | 1594 return None |
| 0 | 1595 |
| 38 | 1596 link=projectId |
| 0 | 1597 |
| 27 | 1598 title=project.getContent("WEB_title") |
| 0 | 1599 #persons=project.getPersonKeyList() |
| 1600 persons=project.getContent('xdata_01') | |
| 1601 logging.debug("%s %s %s"%(link,title,persons)) | |
| 28 | 1602 |
| 1603 thumb = project.getThumbUrl() | |
| 1604 | |
| 1605 return link,title,persons,thumb | |
| 0 | 1606 |
| 1607 # $.post("addNewPerson",{"projectID": | |
| 1608 # $('#projectID').val(), | |
| 1609 # "personName":$("#suggest_newPerson").val(), | |
| 1610 # "personComment":$("#suggest_newPerson_comment").val()} | |
| 1611 # | |
| 1612 # ); | |
| 1613 # | |
| 2 | 1614 |
| 1615 security.declareProtected('View management screens','addAndCreateNewPerson') | |
| 0 | 1616 def addAndCreateNewPerson(self,projectID,personName,personComment,personUserName): |
| 1617 """adds anew person to the project which is not in the authority file""" | |
| 1618 | |
| 1619 id = random.randint(0, 1000000); | |
| 1620 idstring="http://ontologies.mpiwg-berlin.mpg.de/tempObjects/person/"+str(id) | |
| 1621 while self.suggestedPersons.has_key(idstring): | |
| 1622 id = random.randint(0, 1000000); | |
| 1623 #idstring="http://ontologies.mpiwg-berlin.mpg.de/tempObjects/person/"+str(id); | |
| 1624 idstring=self.TEMP_PERSON_NS+str(id); | |
| 1625 | |
| 1626 | |
| 1627 self.suggestedPersons.update({idstring:(personName,personComment,projectID,personUserName)}) | |
| 1628 self.createTempPersonInVirtuoso(projectID, idstring, personName, personComment) #TODO: add suername to the triplestore | |
| 1629 return self.addPersonToProject(projectID, idstring, personName); | |
| 2 | 1630 |
| 7 | 1631 def addSameAsRelationToTripleStore(self,personID,masterID): |
| 1632 cmdString ="insert in GRAPH <"+self.virtuosoGraph+"> {" | |
| 1633 cmdString +="<%s> <http://www.w3.org/2002/07/owl#sameAs> <%s>."%(personID,masterID) | |
| 1634 cmdString +="<%s> <http://www.w3.org/2002/07/owl#sameAs> <%s>."%(masterID,personID) | |
| 1635 cmdString+="}" | |
| 1636 | |
| 1637 auth_handler = urllib2.HTTPBasicAuthHandler() | |
| 1638 auth_handler.add_password(realm='sparql', | |
| 1639 uri=self.virtuosoServer+"/sparql", | |
| 1640 user=self.virtuosoDAVUser, | |
| 1641 passwd=self.virtuosoDAVPW) | |
| 1642 | |
| 1643 opener = urllib2.build_opener(auth_handler) | |
| 1644 opener.addheaders = [('Content-Type','application/sparql-query')] | |
| 1645 | |
| 1646 logging.debug(cmdString) | |
| 1647 try: | |
| 1648 r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':None})) | |
| 1649 logging.debug(r.read()) | |
| 1650 except urllib2.URLError, e: | |
| 1651 logging.error(e.code) | |
| 1652 logging.error(e.read()) | |
| 1653 return | |
| 1654 | |
| 1655 | |
| 2 | 1656 security.declareProtected('View management screens','createTempPersonInVirtuoso') |
| 0 | 1657 def createTempPersonInVirtuoso(self,projectID,personURI, personName,personComment): |
| 1658 """add a new person to the triple store of tempory persons""" | |
| 1659 triples=[]; | |
| 1660 personID="<"+personURI+">" | |
| 1661 triples.append((personID,"<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>","<http://ontologies.mpiwg-berlin.mpg.de/authorities/namedIdentities/Person>")) | |
| 1662 triples.append((personID,"<http://erlangen-crm.org/110404/P3_has_note>",'"'+personComment+'"')) | |
| 1663 triples.append((personID,"<http://xmlns.com/foaf/0.1/name>",'"'+personName+'"')) | |
| 1664 triples.append((personID,"<http://ontologies.mpiwg-berlin.mpg.de/general/isMentionedOn>","<http://www.mpiwg-berlin.mpg.de/en/research/projects/"+projectID+">")) | |
| 1665 | |
| 1666 cmdString ="insert in GRAPH <"+self.virtuosoGraph+"> {" | |
| 1667 for triple in triples: | |
| 1668 cmdString+=" ".join(triple)+"." | |
| 1669 | |
| 1670 cmdString+="}" | |
| 1671 | |
| 1672 auth_handler = urllib2.HTTPBasicAuthHandler() | |
| 1673 auth_handler.add_password(realm='sparql', | |
| 1674 uri=self.virtuosoServer+"/sparql", | |
| 1675 user=self.virtuosoDAVUser, | |
| 1676 passwd=self.virtuosoDAVPW) | |
| 1677 | |
| 1678 opener = urllib2.build_opener(auth_handler) | |
| 1679 opener.addheaders = [('Content-Type','application/sparql-query')] | |
| 1680 | |
| 1681 logging.debug(cmdString) | |
| 1682 try: | |
| 1683 r= opener.open(self.virtuosoServer+"/sparql", urllib.urlencode({'query':cmdString,'default-graph-uri':self.virtuosoGraph,'named-graph-uri':None})) | |
| 1684 logging.debug(r.read()) | |
| 1685 except urllib2.URLError, e: | |
| 1686 logging.error(e.code) | |
| 1687 logging.error(e.read()) | |
| 1688 return | |
| 1689 | |
| 1690 opener2 = urllib2.build_opener() | |
| 1691 | |
| 1692 personIDencoded=urllib.quote(personURI,safe="") | |
| 1693 graphEncoded=urllib.quote(self.additionalNamesGraphURL,safe="") | |
| 1694 url = self.personproviderURL+"id/"+personIDencoded+"/"+graphEncoded | |
| 1695 | |
| 1696 try: | |
| 1697 request = urllib2.Request(url); | |
| 1698 request.get_method = lambda : 'PUT' | |
| 1699 r= opener2.open(request); | |
| 1700 logging.debug(r.read()) | |
| 1701 except urllib2.URLError, e: | |
| 1702 logging.error(e.code) | |
| 1703 logging.error(e.read()) | |
| 1704 return | |
| 1705 | |
| 1706 return | |
| 15 | 1707 |
| 1708 # self.storeChange("removePerson",projectID,value) | |
| 1709 def storeChange(self,typeString,projectID,value): | |
| 1710 | |
| 1711 from time import gmtime,strftime | |
| 1712 fl = open(self.getLogpath(),"a") | |
| 1713 person = self.REQUEST.AUTHENTICATED_USER.getId() | |
| 1714 date = strftime("%Y-%m-%d %H:%M:%S", gmtime()) | |
| 1715 writeString ="\t".join((date,person,typeString,projectID,value)) | |
| 1716 fl.write(writeString+"\n") | |
| 1717 fl.flush() | |
| 1718 fl.close() | |
| 0 | 1719 |
| 17 | 1720 lastChangeInThesaurus = getattr(self,'lastChangeInThesaurus',OOBTree()) |
| 1721 lastChangeInThesaurus.update({projectID:date}) | |
| 1722 self.lastChangeInThesaurus=lastChangeInThesaurus | |
| 1723 | |
| 0 | 1724 def redirect(RESPONSE,url): |
| 1725 """mache ein redirect mit einem angehaengten time stamp um ein reload zu erzwingen""" | |
| 1726 | |
| 1727 timeStamp=time.time() | |
| 1728 | |
| 1729 if url.find("?")>-1: #giebt es schon parameter | |
| 1730 addStr="&time=%s" | |
| 1731 else: | |
| 1732 addStr="?time=%s" | |
| 1733 | |
| 1734 RESPONSE.setHeader('Last-Modified',email.Utils.formatdate().split("-")[0]+'GMT') | |
| 1735 logging.error(email.Utils.formatdate()+' GMT') | |
| 1736 RESPONSE.redirect(url+addStr%timeStamp) | |
| 1737 | |
| 1738 def manage_addMPIWGThesaurusForm(self): | |
| 1739 """form for adding the project""" | |
| 1740 pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','addMPIWGThesaurusForm.zpt')).__of__(self) | |
| 1741 return pt() | |
| 1742 | |
| 1743 | |
| 1744 | |
| 1745 def manage_addMPIWGThesaurus(self,id,RESPONSE=None): | |
| 1746 """add it""" | |
| 1747 newObj=MPIWGThesaurus(id) | |
| 1748 | |
| 1749 self._setObject(id,newObj) | |
| 1750 | |
| 1751 | |
| 1752 if RESPONSE is not None: | |
| 24 | 1753 redirect(RESPONSE,'manage_main') |