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