class BdrAuthorizationMiddleware(SimpleItem):
recheck_interval = 300
def __init__(self, url):
self.recheck_interval = 300
self.lockedDownCollections = PersistentMapping()
def setServiceRecheckInterval(self, seconds):
self.recheck_interval = seconds
@ram.cache(lambda *args, **kwargs: args[2] + str(time() // kwargs['recheck_interval']))
def getUserCollectionPaths(self, username, recheck_interval=recheck_interval):
logger.debug("Get companies from middleware for ecas user: %s" % username)
accessiblePaths = self.FGASRegistryAPI.getCollectionPaths(username)
return accessiblePaths
def authorizedUser(self, username, path):
if self.lockedCollection(path):
logger.warning("This collection is locked down: %s!" % path)
return False
accessiblePaths = self.getUserCollectionPaths(username, recheck_interval=self.recheck_interval)
if path in accessiblePaths.get('paths'):
return "RW"
if path in accessiblePaths.get('prev_paths'):
return "RO"
def lockDownCollection(self, path, user):
if path not in self.lockedDownCollections:
self.lockedDownCollections[path] = None
self.lockedDownCollections[path] = {'state': 'locked',
'ts': time(),
'user': user}
def unlockCollection(self, path, user):
if path not in self.lockedDownCollections:
# log unlock without lock
self.lockedDownCollections[path] = None
self.lockedDownCollections[path] = {'state': 'unlocked',
'ts': time(),
'user': user}
def lockedCollection(self, path):
lockedItem = self.lockedDownCollections.get(path)
return lockedItem and lockedItem['state'] == 'locked'
class Query(object):
def __init__(self):
self.searchValues = PersistentMapping()
def getSearchSchema(self):
return getUtility(IFindService).getSearchSchema()
def getResultsSchema(self):
return getUtility(IFindService).getResultsSchema()
def getSearchFields(self):
return self.getSearchSchema().getFields()
def getResultFields(self):
return self.getResultsSchema().getFields()
def getCriterionValue(self, name):
searchSchema = self.getSearchSchema()
if searchSchema.hasField(name):
return self.searchValues.get(name, None)
else:
raise ValueError(
u'No field named %s defined in search schema' %
name)
def deleteCriterionValue(self, name):
searchSchema = self.getSearchSchema()
if searchSchema.hasField(name):
if name in self.searchValues:
del self.searchValues[name]
def setCriterionValue(self, name, value):
searchSchema = self.getSearchSchema()
if searchSchema.hasField(name):
self.searchValues[name] = value
else:
raise ValueError(
u'No field named %s defined in search schema' %
name)
class Query(object):
def __init__(self):
self.searchValues = PersistentMapping()
def getSearchSchema(self):
return getUtility(IFindService).getSearchSchema()
def getResultsSchema(self):
return getUtility(IFindService).getResultsSchema()
def getSearchFields(self):
return self.getSearchSchema().getFields()
def getResultFields(self):
return self.getResultsSchema().getFields()
def getCriterionValue(self, name):
searchSchema = self.getSearchSchema()
if searchSchema.hasField(name):
return self.searchValues.get(name, None)
else:
raise ValueError('No field named %s defined in search schema' %
name)
def deleteCriterionValue(self, name):
searchSchema = self.getSearchSchema()
if searchSchema.hasField(name):
if name in self.searchValues:
del self.searchValues[name]
def setCriterionValue(self, name, value):
searchSchema = self.getSearchSchema()
if searchSchema.hasField(name):
self.searchValues[name] = value
else:
raise ValueError('No field named %s defined in search schema' %
name)
class SilvaFind(Query, Content, SimpleItem):
__doc__ = _("""Silva Find is a powerful search feature that allows easy
creation of search forms and result pages. Users can add a Find
anywhere and define which fields to make searchable by site visitors
and/or which fields to limit to a preset value. Users also can
determine which fields should be displayed in the search results. All
metadata sets/fields are supported.""")
security = ClassSecurityInfo()
meta_type = "Silva Find"
grok.implements(IFind)
silvaconf.icon('SilvaFind.png')
def __init__(self, id):
Content.__init__(self, id)
Query.__init__(self)
self.shownFields = PersistentMapping()
self.shownResultsFields = PersistentMapping()
# by default we only show fulltext search
# and a couple of resultfields
self.shownFields['fulltext'] = True
self.shownResultsFields['link'] = True
self.shownResultsFields['ranking'] = True
self.shownResultsFields['resultcount'] = True
self.shownResultsFields['icon'] = True
self.shownResultsFields['date'] = True
self.shownResultsFields['textsnippet'] = True
self.shownResultsFields['thumbnail'] = True
self.shownResultsFields['breadcrumbs'] = True
# ACCESSORS
security.declareProtected(SilvaPermissions.View, 'getPublicResultFields')
def getPublicResultFields(self):
return filter(lambda field: self.isResultShown(field.getName()),
self.getResultFields())
security.declareProtected(SilvaPermissions.View, 'getPublicSearchFields')
def getPublicSearchFields(self):
return filter(lambda field: self.isCriterionShown(field.getName()),
self.getSearchFields())
security.declareProtected(SilvaPermissions.View, 'isCriterionShown')
def isCriterionShown(self, fieldName):
return self.shownFields.get(fieldName, False)
security.declareProtected(SilvaPermissions.View, 'isResultShown')
def isResultShown(self, fieldName):
return self.shownResultsFields.get(fieldName, False)
security.declareProtected(SilvaPermissions.View, 'havePublicSearchFields')
def havePublicSearchFields(self):
# BBB map(bool) is here for previously non-boolean stored values
return reduce(operator.or_, map(bool, self.shownFields.values()))
security.declareProtected(SilvaPermissions.View, 'searchResults')
def searchResults(self, request={}, validate=True):
options = self.getSearchCriterias(request)
if validate:
queryEmpty = True
for key, value in options.items():
if key in ['path', 'meta_type']:
# these fields do not count as a real search query
# they are always there to filter unwanted results
continue
if type(value) is unicode and value.strip():
queryEmpty = False
break
elif type(value) is list:
queryEmpty = False
break
query = options.get('fulltext', '').strip()
if query and query[0] in ['?', '*']:
raise ValueError(
_(u'Search query can not start with wildcard character.'))
if queryEmpty:
raise ValueError(
_(u'You need to fill at least one field in the search form.'))
options['publication_status'] = ['public']
catalog = self.get_root().service_catalog
try:
results = catalog.searchResults(options)
except ParseError:
raise ValueError(
_(u'Search query contains only common or reserved words.'))
return results
def getSearchCriterias(self, request):
options = {}
for field in self.getSearchFields():
name = field.getName()
if (self.shownFields.get(name, False) or name == 'path'):
queryPart = getMultiAdapter((field, self, request), IQueryPart)
value = queryPart.getIndexValue()
if value is None:
value = ''
options[queryPart.getIndexId()] = value
return options
class Concepts(SimpleItem, session_manager):
""" Concepts """
meta_type = CONCEPTS_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/concepts.gif'
manage_options = (
{'label':'Properties', 'action':'properties_html'},
{'label':'Management', 'action':'concepts_html'},
{'label':'Import', 'action':'import_html'},
{'label':'Statistics', 'action':'statistics_html'},
{'label':'Undo', 'action':'manage_UndoForm'},)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.concepts = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for Concepts """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#concepts management
def __add_concept(self, concept_id):
#create a new item
item = ConceptItem(concept_id)
self.concepts[concept_id] = item
self.catalog.CatalogObject(item)
def __update_concept(self, concept_id, old_concept_id):
#modify an item
item = self.concepts.get(old_concept_id)
if item is not None:
self.__delete_concept(old_concept_id)
self.__add_concept(concept_id)
def __delete_concept(self, ids):
#delete 1 or more items
ids = th_utils().utConvertToList(ids)
collection = self.get_concepts()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#concept constraints
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.concepts.keys()
return th_utils().getIdsList(ids)
#concepts getters
def get_concepts(self):
#get all concepts
return self.concepts
def get_concepts_sorted(self):
#get all concepts sorted
return th_utils().utSortObjsListByAttr(self.concepts.values(), 'concept_id', 0)
def get_concept_by_id(self, concept_id):
#get an item
try: return self.concepts[concept_id]
except: return None
def get_concept_item_data(self, concept_id):
#get an item data
item = self.get_concept_by_id(concept_id)
if item is not None:
return ['update', item.concept_id]
else:
return ['add', '']
#concepts api
security.declareProtected(view_management_screens, 'manage_add_concept')
def manage_add_concept(self, concept_id='', REQUEST=None):
""" manage concepts """
if not concept_id: concept_id = th_utils().utGenRandomId()
self.__add_concept(concept_id)
if REQUEST:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('concepts_html')
security.declareProtected(view_management_screens, 'manage_update_concept')
def manage_update_concept(self, concept_id='', old_concept_id='', REQUEST=None):
""" update concept """
self.__update_concept(concept_id, old_concept_id)
if REQUEST:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('concepts_html')
security.declareProtected(view_management_screens, 'manage_delete_concepts')
def manage_delete_concepts(self, ids=[], delete_all='', REQUEST=None):
""" delete concepts """
del_count = 0
#TODO: uncomment when Groups will be implemented
# if delete_all: ids = self.getIdsList(ids, 1)
# else: ids = self.getIdsList(ids)
if delete_all: ids = self.getIdsList(ids, 1)
ids = th_utils().utConvertToList(ids)
self.__delete_concept(ids)
#delete all related data
for concept_id in ids:
#delete all related terms
query = [('meta_type',TERM_ITEM_METATYPE),
('concept_id',concept_id)]
term_list = self.catalog.searchCatalog(query)
term_folder = self.getTermsFolder()
for term_ob in term_list:
term_folder.manage_delete_terms(['%s###%s' % (term_ob.concept_id, term_ob.langcode)])
del_count += 1
#delete all related definitions
query = [('meta_type',DEFINITION_ITEM_METATYPE),
('concept_id',concept_id)]
def_list = self.catalog.searchCatalog(query)
def_folder = self.getDefinitionsFolder()
for def_ob in def_list:
def_folder.manage_delete_definitions(['%s###%s' % (def_ob.concept_id, def_ob.langcode)])
del_count += 1
#delete all related altterms
query = [('meta_type',ALTTERM_ITEM_METATYPE),
('concept_id',concept_id)]
alt_list = self.catalog.searchCatalog(query)
alt_folder = self.getAltTermsFolder()
for alt_ob in alt_list:
alt_folder.manage_delete_altterms(['%s###%s' % (alt_ob.concept_id, alt_ob.langcode)])
del_count += 1
#delete all related scopes
query = [('meta_type',SCOPE_ITEM_METATYPE),
('concept_id',concept_id)]
scope_list = self.catalog.searchCatalog(query)
scope_folder = self.getScopeNotesFolder()
for scope_ob in scope_list:
scope_folder.manage_delete_scopes(['%s###%s' % (scope_ob.concept_id, scope_ob.langcode)])
del_count += 1
#delete all related theme relations
query = [('meta_type',THEME_RELATION_ITEM_METATYPE),
('concept_id',concept_id)]
threl_list = self.catalog.searchCatalog(query)
threl_folder = self.getThemeRelationsFolder()
for threl_ob in threl_list:
threl_folder.manage_delete_threlations(['%s###%s' % (threl_ob.concept_id, threl_ob.theme_id)])
del_count += 1
#delete all related concept relations
query = [('meta_type',CONCEPT_RELATION_ITEM_METATYPE),
('concept_id',concept_id)]
cprel_list = self.catalog.searchCatalog(query)
cprel_folder = self.getConceptRelationsFolder()
for cprel_ob in cprel_list:
cprel_folder.manage_delete_relations(['%s###%s###%s' % (cprel_ob.concept_id, cprel_ob.relation_id, cprel_ob.relation_type)])
del_count += 1
query = [('meta_type',CONCEPT_RELATION_ITEM_METATYPE),
('relation_id',concept_id)]
cprel_list = self.catalog.searchCatalog(query)
cprel_folder = self.getConceptRelationsFolder()
for cprel_ob in cprel_list:
cprel_folder.manage_delete_relations(['%s###%s###%s' % (cprel_ob.concept_id, cprel_ob.relation_id, cprel_ob.relation_type)])
del_count += 1
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.',
('${del_count} related records were deleted.', {'del_count': del_count}, ))
REQUEST.RESPONSE.redirect('concepts_html')
security.declareProtected(view_management_screens, 'getConceptItemData')
def getConceptItemData(self):
""" return a concept based on its ID """
return self.get_concept_item_data(self.REQUEST.get('concept_id', None))
#import related
def skos_import(self, file, REQUEST=None):
""" """
parser = concept_parser()
#parse the SKOS information
chandler = parser.parseHeader(file)
if chandler is None:
if REQUEST:
self.setSessionErrorsTrans('Parsing error. The file could not be parsed.')
return REQUEST.RESPONSE.redirect('import_html')
#get data
concept_info = chandler.getConcepts()
theme_relation_info = chandler.getThemes()
#info
count_concepts = 0
count_themes_rel = 0
#set Concepts
for id, data in concept_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id != '':
count_concepts += 1
self.__add_concept(concept_id)
#set ThemeRelations
for id, data in theme_relation_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
theme_id = data['theme_id'].encode('utf-8').split('/')[-1]
if concept_id and theme_id:
count_themes_rel += 1
theme_relations_folder = self.getThemeRelationsFolder()
theme_relations_folder.manage_add_threlation(concept_id, theme_id)
if REQUEST:
self.setSessionInfoTrans(['File imported successfully.',
('Concepts added: ${count_concepts}', {'count_concepts': count_concepts}, ),
('ThemeRelations added: ${count_themes_rel}', {'count_themes_rel': count_themes_rel}, )])
return REQUEST.RESPONSE.redirect('import_html')
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile("%s/zpt/Concepts/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'concepts_html')
concepts_html = PageTemplateFile("%s/zpt/Concepts/concepts" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile("%s/zpt/Concepts/statistics" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'import_html')
import_html = PageTemplateFile("%s/zpt/Concepts/import" % NAAYATHESAURUS_PATH, globals())
class Terms(SimpleItem, session_manager):
""" Terms """
meta_type = TERMS_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/terms.gif'
manage_options = (
{
'label': 'Properties',
'action': 'properties_html'
},
{
'label': 'Management',
'action': 'terms_html'
},
{
'label': 'Import',
'action': 'import_html'
},
{
'label': 'Statistics',
'action': 'statistics_html'
},
{
'label': 'Undo',
'action': 'manage_UndoForm'
},
)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.terms = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for Terms """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#terms management
def __add_term(self, concept_id, langcode, concept_name, source_id):
#create a new item
item = TermItem(concept_id, langcode, concept_name, source_id)
self.terms[(concept_id, langcode)] = item
self.catalog.CatalogObject(item)
def __update_term(self, concept_id, old_concept_id, langcode, old_langcode,
concept_name, source_id):
#modify an item
item = self.terms.get((old_concept_id, old_langcode))
if item is not None:
self.__delete_term((old_concept_id, old_langcode))
self.__add_term(concept_id, langcode, concept_name, source_id)
security.declareProtected(view_management_screens, 'update_source_id')
def update_source_id(self, concept_id, langcode, source_id):
""" update the source_id list """
term_ob = self.get_term_by_id((concept_id, langcode))
if term_ob.source_id:
upd_source_id = "%s %s" % (term_ob.source_id, source_id)
else:
upd_source_id = source_id
self.__update_term(concept_id, concept_id, langcode, langcode,
term_ob.concept_name, upd_source_id)
def __delete_term(self, ids):
#delete 1 or more items
if type(ids) != type((1, 1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_terms()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#term constraints
security.declareProtected(view_management_screens, 'checkTerm')
def checkTerm(self, concept_id):
""" """
if self.getConceptsFolder().get_concept_by_id(concept_id):
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.terms.keys()
return th_utils().getIdsList(ids)
#terms getters
def get_terms(self):
#get all terms
return self.terms
def get_terms_sorted(self):
#get all terms sorted
return th_utils().utSortObjsListByAttr(self.terms.values(),
'concept_id', 0)
def get_term_by_id(self, id):
#get an item
try:
return self.terms[id]
except:
return None
def get_term_item_data(self, concept_id, langcode, orig_concept_id,
orig_langcode, concept_name, source_id):
#get an item data
item = self.get_term_by_id((orig_concept_id, orig_langcode))
if item is not None:
if concept_name is None:
concept_name = item.concept_name
if source_id is None:
source_id = item.source_id
return [
'update', concept_id, langcode, concept_name, source_id,
orig_concept_id, orig_langcode
]
else:
return [
'add', concept_id, langcode, concept_name, source_id, '', ''
]
#terms api
security.declareProtected(view_management_screens, 'manage_add_term')
def manage_add_term(self,
concept_id='',
langcode='',
concept_name='',
source_id='',
REQUEST=None):
""" manage terms """
err = 0
if self.checkTerm(concept_id):
self.__add_term(concept_id, langcode, concept_name, source_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionConceptName(concept_name)
self.setSessionSourceId(source_id)
self.setSessionErrorsTrans(
'${concept_id} is not a valid concept ID.',
concept_id=concept_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('terms_html')
security.declareProtected(view_management_screens, 'manage_update_term')
def manage_update_term(self,
concept_id='',
old_concept_id='',
langcode='',
old_langcode='',
concept_name='',
source_id='',
REQUEST=None):
""" update term """
err = 0
if self.checkTerm(concept_id):
self.__update_term(concept_id, old_concept_id, langcode,
old_langcode, concept_name, source_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionConceptName(concept_name)
self.setSessionSourceId(source_id)
self.setSessionErrorsTrans(
'${concept_id} is not a valid concept ID.',
concept_id=concept_id)
REQUEST.RESPONSE.redirect(
'terms_html?concept_id=%s&langcode=%s' %
(old_concept_id, old_langcode))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('terms_html')
security.declareProtected(view_management_screens, 'manage_delete_terms')
def manage_delete_terms(self, ids=[], delete_all='', REQUEST=None):
""" delete terms """
if delete_all: ids = self.getIdsList(ids, 1)
else: ids = self.getIdsList(ids)
self.__delete_term(ids)
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.')
REQUEST.RESPONSE.redirect('terms_html')
security.declareProtected(view_management_screens, 'getTermItemData')
def getTermItemData(self):
""" return a term based on its ID """
if self.isSessionConceptId():
concept_id = self.getSessionConceptId()
langcode = self.getSessionLangcode()
concept_name = self.getSessionConceptName()
source_id = self.getSessionSourceId()
orig_concept_id = self.REQUEST.get('concept_id', None)
orig_langcode = self.REQUEST.get('langcode', None)
else:
concept_id = self.REQUEST.get('concept_id',
self.getSessionConceptId())
langcode = self.REQUEST.get('langcode', self.getSessionLangcode())
concept_name = self.getSessionConceptName()
source_id = self.getSessionSourceId()
orig_concept_id = concept_id
orig_langcode = langcode
self.delSessionConceptId()
self.delSessionLangcode()
self.delSessionConceptName()
self.delSessionSourceId()
return self.get_term_item_data(concept_id, langcode, orig_concept_id,
orig_langcode, concept_name, source_id)
#import related
def skos_import(self, file, langcode, REQUEST=None):
""" """
parser = term_parser()
#parse the SKOS information
chandler = parser.parseHeader(file)
if chandler is None:
if REQUEST:
self.setSessionErrorsTrans(
'Parsing error. The file could not be parsed.')
return REQUEST.RESPONSE.redirect('import_html')
#get the target language
skos_lang = chandler.getLanguage()
if skos_lang: langcode = skos_lang.encode('utf-8')
#get data
pref_info = chandler.getPref()
alt_info = chandler.getAlt()
def_info = chandler.getDef()
scope_info = chandler.getScope()
src_info = chandler.getSrc()
def_src_info = chandler.getDefSrc()
#info
count_terms = 0
err_terms = []
count_altterms = 0
err_altterms = []
count_def = 0
err_defs = []
count_scope = 0
err_scope = []
count_src = 0
err_src = []
count_def_src = 0
err_def_src = []
#set Terms
for id, data in pref_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
concept_name = data['concept_name']
source_id = ''
if self.checkTerm(concept_id):
self.__add_term(concept_id, langcode, concept_name,
source_id)
count_terms += 1
else:
err_terms.append(concept_id)
else:
err_terms.append('None')
#set Alternatives terms
for id, data in alt_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
alt_terms_folder = self.getAltTermsFolder()
alt_name = data['alt_name']
if self.checkTerm(concept_id):
alt_terms_folder.manage_add_altterm(
concept_id, langcode, alt_name)
count_altterms += 1
else:
err_altterms.append(concept_id)
else:
err_altterms.append('None')
#set Definitions
for id, data in def_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
definitions_folder = self.getDefinitionsFolder()
definition = data['definition']
if self.checkTerm(concept_id):
#TODO: implement source
definitions_folder.manage_add_definition(
concept_id, langcode, definition, '')
count_def += 1
else:
err_defs.append(concept_id)
else:
err_defs.append('None')
#set ScopeNotes
for id, data in scope_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
scopenotes_folder = self.getScopeNotesFolder()
scope_note = data['scope_note']
if self.checkTerm(concept_id):
scopenotes_folder.manage_add_scope(concept_id, langcode,
scope_note)
count_scope += 1
else:
err_scope.append(concept_id)
else:
err_scope.append('None')
#set Terms sources
for id, data in src_info.items():
source_id = data['source_id']
source_name = data['source_name']
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
if self.checkTerm(concept_id):
sources_folder = self.getSourceFolder()
#add source record
sources_folder.manage_add_source(source_id, source_name)
#update term record
self.update_source_id(concept_id, langcode, source_id)
count_src += 1
else:
err_src.append(concept_id)
else:
err_src.append('None')
#set Definitions sources
for id, data in def_src_info.items():
source_id = data['source_id']
source_name = data['source_name']
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
if self.checkTerm(concept_id):
sources_folder = self.getSourceFolder()
definitions_folder = self.getDefinitionsFolder()
#add source record
sources_folder.manage_add_source(source_id, source_name)
#update definition record
definitions_folder.update_source_id(
concept_id, langcode, source_id)
count_def_src += 1
else:
err_def_src.append(concept_id)
else:
err_def_src.append('None')
if REQUEST:
self.setSessionInfoTrans([
'File imported successfully.',
(
'Translations added: ${count_terms}',
{
'count_terms': count_terms
},
),
(
'Alternative terms added: ${count_altterms}',
{
'count_altterms': count_altterms
},
),
(
'Definitions added: ${count_def}',
{
'count_def': count_def
},
),
(
'ScopeNotes added: ${count_scope}',
{
'count_scope': count_scope
},
),
(
'Terms Sources added: ${count_src}',
{
'count_src': count_src
},
),
(
'Definitions Sources added: ${count_def_src}',
{
'count_def_src': count_def_src
},
),
])
msg_err = []
if err_terms:
msg_err.append((
'Translations not imported because the specified concept_id does not exist: ${err_terms}',
{
'err_terms':
th_utils().utJoinToString(err_terms, ', ')
},
))
if err_altterms:
msg_err.append((
'Alternative terms not imported because the specified concept_id does not exist: ${err_altterms}',
{
'err_altterms':
th_utils().utJoinToString(err_altterms, ', ')
},
))
if err_defs:
msg_err.append((
'Definitions not imported because the specified concept_id does not exist: ${err_defs}',
{
'err_defs': th_utils().utJoinToString(err_defs, ', ')
},
))
if err_scope:
msg_err.append((
'ScopeNotes not imported because the specified concept_id does not exist: ${err_scope}',
{
'err_scope':
th_utils().utJoinToString(err_scope, ', ')
},
))
if err_src:
msg_err.append((
'Term sources not imported because the specified concept_id does not exist: ${err_src}',
{
'err_src': th_utils().utJoinToString(err_src, ', ')
},
))
if err_def_src:
msg_err.append((
'Definition sources not imported because the specified concept_id does not exist: ${err_def_src}',
{
'err_def_src':
th_utils().utJoinToString(err_def_src, ', ')
},
))
if msg_err:
self.setSessionErrorsTrans(msg_err)
return REQUEST.RESPONSE.redirect('import_html')
#statistics
def getAllTerms(self):
query = [('meta_type', TERM_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getTermsNumber(self):
return len(self.getAllTerms())
def getTermsTransNumber(self):
results = {}
for term_ob in self.getAllTerms():
try:
tr_count = results[term_ob.langcode][0]
except:
tr_count = 0
tr_count += 1
try:
src_count = results[term_ob.langcode][1]
except:
src_count = 0
if term_ob.source_id: src_count += 1
results[term_ob.langcode] = (tr_count, src_count)
return results
def getTermsWithSource(self):
count = 0
for term_ob in self.getAllTerms():
if len(term_ob.source_id): count += 1
return count
def getEmptyTrans(self):
empty_count = 0
for term_ob in self.getAllTerms():
if not term_ob.concept_name:
empty_count += 1
return empty_count
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile(
"%s/zpt/Terms/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'terms_html')
terms_html = PageTemplateFile("%s/zpt/Terms/terms" % NAAYATHESAURUS_PATH,
globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile(
"%s/zpt/Terms/statistics" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'import_html')
import_html = PageTemplateFile("%s/zpt/Terms/import" % NAAYATHESAURUS_PATH,
globals())
class Concepts(SimpleItem, session_manager):
""" Concepts """
meta_type = CONCEPTS_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/concepts.gif'
manage_options = (
{
'label': 'Properties',
'action': 'properties_html'
},
{
'label': 'Management',
'action': 'concepts_html'
},
{
'label': 'Import',
'action': 'import_html'
},
{
'label': 'Statistics',
'action': 'statistics_html'
},
{
'label': 'Undo',
'action': 'manage_UndoForm'
},
)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.concepts = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for Concepts """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#concepts management
def __add_concept(self, concept_id):
#create a new item
item = ConceptItem(concept_id)
self.concepts[concept_id] = item
self.catalog.CatalogObject(item)
def __update_concept(self, concept_id, old_concept_id):
#modify an item
item = self.concepts.get(old_concept_id)
if item is not None:
self.__delete_concept(old_concept_id)
self.__add_concept(concept_id)
def __delete_concept(self, ids):
#delete 1 or more items
ids = th_utils().utConvertToList(ids)
collection = self.get_concepts()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#concept constraints
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.concepts.keys()
return th_utils().getIdsList(ids)
#concepts getters
def get_concepts(self):
#get all concepts
return self.concepts
def get_concepts_sorted(self):
#get all concepts sorted
return th_utils().utSortObjsListByAttr(self.concepts.values(),
'concept_id', 0)
def get_concept_by_id(self, concept_id):
#get an item
try:
return self.concepts[concept_id]
except:
return None
def get_concept_item_data(self, concept_id):
#get an item data
item = self.get_concept_by_id(concept_id)
if item is not None:
return ['update', item.concept_id]
else:
return ['add', '']
#concepts api
security.declareProtected(view_management_screens, 'manage_add_concept')
def manage_add_concept(self, concept_id='', REQUEST=None):
""" manage concepts """
if not concept_id: concept_id = th_utils().utGenRandomId()
self.__add_concept(concept_id)
if REQUEST:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('concepts_html')
security.declareProtected(view_management_screens, 'manage_update_concept')
def manage_update_concept(self,
concept_id='',
old_concept_id='',
REQUEST=None):
""" update concept """
self.__update_concept(concept_id, old_concept_id)
if REQUEST:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('concepts_html')
security.declareProtected(view_management_screens,
'manage_delete_concepts')
def manage_delete_concepts(self, ids=[], delete_all='', REQUEST=None):
""" delete concepts """
del_count = 0
#TODO: uncomment when Groups will be implemented
# if delete_all: ids = self.getIdsList(ids, 1)
# else: ids = self.getIdsList(ids)
if delete_all: ids = self.getIdsList(ids, 1)
ids = th_utils().utConvertToList(ids)
self.__delete_concept(ids)
#delete all related data
for concept_id in ids:
#delete all related terms
query = [('meta_type', TERM_ITEM_METATYPE),
('concept_id', concept_id)]
term_list = self.catalog.searchCatalog(query)
term_folder = self.getTermsFolder()
for term_ob in term_list:
term_folder.manage_delete_terms(
['%s###%s' % (term_ob.concept_id, term_ob.langcode)])
del_count += 1
#delete all related definitions
query = [('meta_type', DEFINITION_ITEM_METATYPE),
('concept_id', concept_id)]
def_list = self.catalog.searchCatalog(query)
def_folder = self.getDefinitionsFolder()
for def_ob in def_list:
def_folder.manage_delete_definitions(
['%s###%s' % (def_ob.concept_id, def_ob.langcode)])
del_count += 1
#delete all related altterms
query = [('meta_type', ALTTERM_ITEM_METATYPE),
('concept_id', concept_id)]
alt_list = self.catalog.searchCatalog(query)
alt_folder = self.getAltTermsFolder()
for alt_ob in alt_list:
alt_folder.manage_delete_altterms(
['%s###%s' % (alt_ob.concept_id, alt_ob.langcode)])
del_count += 1
#delete all related scopes
query = [('meta_type', SCOPE_ITEM_METATYPE),
('concept_id', concept_id)]
scope_list = self.catalog.searchCatalog(query)
scope_folder = self.getScopeNotesFolder()
for scope_ob in scope_list:
scope_folder.manage_delete_scopes(
['%s###%s' % (scope_ob.concept_id, scope_ob.langcode)])
del_count += 1
#delete all related theme relations
query = [('meta_type', THEME_RELATION_ITEM_METATYPE),
('concept_id', concept_id)]
threl_list = self.catalog.searchCatalog(query)
threl_folder = self.getThemeRelationsFolder()
for threl_ob in threl_list:
threl_folder.manage_delete_threlations(
['%s###%s' % (threl_ob.concept_id, threl_ob.theme_id)])
del_count += 1
#delete all related concept relations
query = [('meta_type', CONCEPT_RELATION_ITEM_METATYPE),
('concept_id', concept_id)]
cprel_list = self.catalog.searchCatalog(query)
cprel_folder = self.getConceptRelationsFolder()
for cprel_ob in cprel_list:
cprel_folder.manage_delete_relations([
'%s###%s###%s' %
(cprel_ob.concept_id, cprel_ob.relation_id,
cprel_ob.relation_type)
])
del_count += 1
query = [('meta_type', CONCEPT_RELATION_ITEM_METATYPE),
('relation_id', concept_id)]
cprel_list = self.catalog.searchCatalog(query)
cprel_folder = self.getConceptRelationsFolder()
for cprel_ob in cprel_list:
cprel_folder.manage_delete_relations([
'%s###%s###%s' %
(cprel_ob.concept_id, cprel_ob.relation_id,
cprel_ob.relation_type)
])
del_count += 1
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.', (
'${del_count} related records were deleted.',
{
'del_count': del_count
},
))
REQUEST.RESPONSE.redirect('concepts_html')
security.declareProtected(view_management_screens, 'getConceptItemData')
def getConceptItemData(self):
""" return a concept based on its ID """
return self.get_concept_item_data(self.REQUEST.get('concept_id', None))
#import related
def skos_import(self, file, REQUEST=None):
""" """
parser = concept_parser()
#parse the SKOS information
chandler = parser.parseHeader(file)
if chandler is None:
if REQUEST:
self.setSessionErrorsTrans(
'Parsing error. The file could not be parsed.')
return REQUEST.RESPONSE.redirect('import_html')
#get data
concept_info = chandler.getConcepts()
theme_relation_info = chandler.getThemes()
#info
count_concepts = 0
count_themes_rel = 0
#set Concepts
for id, data in concept_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id != '':
count_concepts += 1
self.__add_concept(concept_id)
#set ThemeRelations
for id, data in theme_relation_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
theme_id = data['theme_id'].encode('utf-8').split('/')[-1]
if concept_id and theme_id:
count_themes_rel += 1
theme_relations_folder = self.getThemeRelationsFolder()
theme_relations_folder.manage_add_threlation(
concept_id, theme_id)
if REQUEST:
self.setSessionInfoTrans([
'File imported successfully.',
(
'Concepts added: ${count_concepts}',
{
'count_concepts': count_concepts
},
),
(
'ThemeRelations added: ${count_themes_rel}',
{
'count_themes_rel': count_themes_rel
},
)
])
return REQUEST.RESPONSE.redirect('import_html')
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile(
"%s/zpt/Concepts/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'concepts_html')
concepts_html = PageTemplateFile(
"%s/zpt/Concepts/concepts" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile(
"%s/zpt/Concepts/statistics" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'import_html')
import_html = PageTemplateFile(
"%s/zpt/Concepts/import" % NAAYATHESAURUS_PATH, globals())
class ThemeRelations(SimpleItem, session_manager):
""" ThemeRelations """
meta_type = THEME_RELATION_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/theme_relations.gif'
manage_options = (
{
'label': 'Properties',
'action': 'properties_html'
},
{
'label': 'Management',
'action': 'theme_relations_html'
},
{
'label': 'Statistics',
'action': 'statistics_html'
},
{
'label': 'Undo',
'action': 'manage_UndoForm'
},
)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.theme_relations = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for ThemeRelations """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#theme relations management
def __add_threlation(self, concept_id, theme_id):
#create a new item
item = ThemeRelationItem(concept_id, theme_id)
self.theme_relations[(concept_id, theme_id)] = item
self.catalog.CatalogObject(item)
def __update_threlation(self, concept_id, old_concept_id, theme_id,
old_theme_id):
#modify an item
item = self.theme_relations.get((old_concept_id, old_theme_id))
if item is not None:
self.__delete_threlation((old_concept_id, old_theme_id))
self.__add_threlation(concept_id, theme_id)
def __delete_threlation(self, ids):
#delete 1 or more items
if type(ids) != type((1, 1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_threlations()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#theme relations constraints
security.declareProtected(view_management_screens, 'checkThRel')
def checkThRel(self, concept_id):
""" """
if self.getConceptsFolder().get_concept_by_id(concept_id):
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.theme_relations.keys()
return th_utils().getIdsList(ids)
security.declareProtected(view_management_screens, 'infoOnDelete')
def infoOnDelete(self, ids, all=0):
""" """
results = []
dic_cp = {}
lst_cp = []
for rel_id in self.getIdsList(ids, all):
rel_ob = self.get_threlation_by_id(rel_id)
try:
lst_cp = dic_cp[rel_ob.concept_id]
except:
lst_cp = []
lst_cp.append(rel_ob)
dic_cp[rel_ob.concept_id] = lst_cp
results.append(rel_ob)
for concept_id in dic_cp.keys():
query = [('meta_type', THEME_RELATION_ITEM_METATYPE),
('concept_id', concept_id)]
if len(dic_cp[concept_id]) == len(
self.catalog.searchCatalog(query)):
dic_cp[concept_id] = 1
else:
dic_cp[concept_id] = 0
return (results, dic_cp)
#theme relations getters
def get_threlations(self):
#get all theme relations
return self.theme_relations
def get_threlations_sorted(self):
#get all theme relations sorted
return th_utils().utSortObjsListByAttr(self.theme_relations.values(),
'concept_id', 0)
def get_threlation_by_id(self, id):
#get an item
try:
return self.theme_relations[id]
except:
return None
def get_threlation_item_data(self, concept_id, theme_id, orig_concept_id,
orig_theme_id):
#get an item data
item = self.get_threlation_by_id((orig_concept_id, orig_theme_id))
if item is not None:
return [
'update', concept_id, theme_id, orig_concept_id, orig_theme_id
]
else:
return ['add', concept_id, theme_id, '', '']
#themes api
security.declareProtected(view_management_screens, 'manage_add_threlation')
def manage_add_threlation(self, concept_id='', theme_id='', REQUEST=None):
""" manage theme relations """
err = 0
if self.checkThRel(concept_id):
self.__add_threlation(concept_id, theme_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionThemeId(theme_id)
self.setSessionErrorsTrans(
'${concept_id} is not a valid concept ID.',
concept_id=concept_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('theme_relations_html')
security.declareProtected(view_management_screens,
'manage_update_threlation')
def manage_update_threlation(self,
concept_id='',
old_concept_id='',
theme_id='',
old_theme_id='',
REQUEST=None):
""" update theme relation """
err = 0
if self.checkThRel(concept_id):
self.__update_threlation(concept_id, old_concept_id, theme_id,
old_theme_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionThemeId(theme_id)
self.setSessionErrorsTrans(
'${concept_id} is not a valid concept ID.',
concept_id=concept_id)
REQUEST.RESPONSE.redirect(
'theme_relations_html?concept_id=%s&theme_id=%s' %
(old_concept_id, old_theme_id))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('theme_relations_html')
security.declareProtected(view_management_screens,
'manage_delete_threlations')
def manage_delete_threlations(self, ids=[], REQUEST=None):
""" delete theme relations """
del_count = 0
self.__delete_threlation(self.getIdsList(ids))
query = [('meta_type', THEME_ITEM_METATYPE)]
th_list = self.catalog.searchCatalog(query)
for th_ob in th_list:
query = [('meta_type', THEME_RELATION_ITEM_METATYPE),
('theme_id', th_ob.theme_id)]
if not self.catalog.searchCatalog(query):
theme_folder = self.getThemesFolder()
theme_folder.manage_delete_themes(
['%s###%s' % (th_ob.theme_id, th_ob.langcode)])
del_count += 1
if REQUEST:
self.setSessionInfoTrans([
'Selected records deleted.',
(
'${del_count} related records were deleted.',
{
'del_count': del_count
},
)
])
REQUEST.RESPONSE.redirect('theme_relations_html')
security.declareProtected(view_management_screens, 'getThRelationItemData')
def getThRelationItemData(self):
""" return a theme relation based on its ID """
if self.isSessionConceptId():
concept_id = self.getSessionConceptId()
theme_id = self.getSessionThemeId()
orig_concept_id = self.REQUEST.get('concept_id', None)
orig_theme_id = self.REQUEST.get('theme_id', None)
else:
concept_id = self.REQUEST.get('concept_id',
self.getSessionConceptId())
theme_id = self.REQUEST.get('theme_id', self.getSessionThemeId())
orig_concept_id = concept_id
orig_theme_id = theme_id
self.delSessionConceptId()
self.delSessionThemeId()
return self.get_threlation_item_data(concept_id, theme_id,
orig_concept_id, orig_theme_id)
#statistics
def getAllRelTh(self):
query = [('meta_type', THEME_RELATION_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getRelThNumber(self):
return len(self.getAllRelTh())
def getDistinctThNumber(self):
return len(self.getDistinctThemes())
def getDistinctThemes(self):
themes_list = []
add_theme_id = themes_list.append
query = [('meta_type', THEME_RELATION_ITEM_METATYPE)]
th_relations = self.catalog.searchCatalog(query)
for rel_ob in th_relations:
theme_id = rel_ob.theme_id
if theme_id not in themes_list: add_theme_id(theme_id)
return themes_list
def getUntranslatedThemes(self):
th_count = 0
for theme_id in self.getDistinctThemes():
query = [('meta_type', THEME_ITEM_METATYPE),
('theme_id', theme_id)]
if not self.catalog.searchCatalog(query):
th_count += 1
return th_count
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile(
"%s/zpt/ThemeRelations/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'theme_relations_html')
theme_relations_html = PageTemplateFile(
"%s/zpt/ThemeRelations/theme_relations" % NAAYATHESAURUS_PATH,
globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile(
"%s/zpt/ThemeRelations/statistics" % NAAYATHESAURUS_PATH, globals())
class ConceptRelations(SimpleItem, session_manager):
""" ConceptRelations """
meta_type = CONCEPT_RELATIONS_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/concept_relations.gif'
manage_options = (
{
'label': 'Properties',
'action': 'properties_html'
},
{
'label': 'Management',
'action': 'concept_relations_html'
},
{
'label': 'Import',
'action': 'import_html'
},
{
'label': 'Statistics',
'action': 'statistics_html'
},
{
'label': 'Undo',
'action': 'manage_UndoForm'
},
)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.concept_relations = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for ConceptRelations """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#concept relations management
def __add_relation(self, concept_id, relation_id, relation_type):
#create a new item
item = ConceptRelationsItem(concept_id, relation_id, relation_type)
self.concept_relations[(concept_id, relation_id, relation_type)] = item
self.catalog.CatalogObject(item)
def __update_relation(self, concept_id, old_concept_id, relation_id,
old_relation_id, relation_type, old_relation_type):
#modify an item
l_old_id = (old_concept_id, old_relation_id, old_relation_type)
item = self.concept_relations.get(l_old_id)
if item is not None:
self.__delete_relation(l_old_id)
self.__add_relation(concept_id, relation_id, relation_type)
def __delete_relation(self, ids):
#delete 1 or more items
if type(ids) != type((1, 1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_relations()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#concept relations constraints
security.declareProtected(view_management_screens, 'checkCpRel')
def checkCpRel(self, concept_id):
""" """
if self.getConceptsFolder().get_concept_by_id(concept_id):
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.concept_relations.keys()
return th_utils().getIdsList(ids)
#relations getters
def get_relations(self):
#get all relations
return self.concept_relations
def get_relations_sorted(self):
#get all relations sorted
return th_utils().utSortObjsListByAttr(self.concept_relations.values(),
'concept_id', 0)
def get_relation_by_id(self, id):
#get an item
try:
return self.concept_relations[id]
except:
return None
def get_relations_item_data(self, concept_id, relation_id, relation_type,
orig_concept_id, orig_relation_id,
orig_relation_type):
#get an item data
item = self.get_relation_by_id(
(orig_concept_id, orig_relation_id, orig_relation_type))
if item is not None:
return [
'update', concept_id, relation_id, relation_type,
orig_concept_id, orig_relation_id, orig_relation_type
]
else:
return ['add', concept_id, relation_id, relation_type, '', '', '']
#concept relations api
security.declareProtected(view_management_screens, 'manage_add_relation')
def manage_add_relation(self,
concept_id='',
relation_id='',
relation_type='',
REQUEST=None):
""" manage relations """
err = 0
if self.checkCpRel(concept_id) and self.checkCpRel(relation_id):
self.__add_relation(concept_id, relation_id, relation_type)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionRelationId(relation_id)
self.setSessionRelationType(relation_type)
self.setSessionErrorsTrans(
'${concept_id} is not a valid concept ID.',
concept_id=concept_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('concept_relations_html')
security.declareProtected(view_management_screens,
'manage_update_relation')
def manage_update_relation(self,
concept_id='',
old_concept_id='',
relation_id='',
old_relation_id='',
relation_type='',
old_relation_type='',
REQUEST=None):
""" update relation """
err = 0
if self.checkCpRel(concept_id) and self.checkCpRel(relation_id):
self.__update_relation(concept_id, old_concept_id, relation_id,
old_relation_id, relation_type,
old_relation_type)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionRelationId(relation_id)
self.setSessionRelationType(relation_type)
self.setSessionErrorsTrans(
'${concept_id} is not a valid concept ID.',
concept_id=concept_id)
REQUEST.RESPONSE.redirect(
'concept_relations_html?concept_id=%s&relation_id=%s&relation_type=%s'
% (old_concept_id, old_relation_id, old_relation_type))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('concept_relations_html')
security.declareProtected(view_management_screens,
'manage_delete_relations')
def manage_delete_relations(self, ids=[], delete_all='', REQUEST=None):
""" delete relations """
if delete_all: ids = self.getIdsList(ids, 1)
else: ids = self.getIdsList(ids)
self.__delete_relation(ids)
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.')
REQUEST.RESPONSE.redirect('concept_relations_html')
security.declareProtected(view_management_screens, 'getRelationItemData')
def getRelationItemData(self):
""" return a relation based on its ID """
if self.isSessionConceptId():
concept_id = self.getSessionConceptId()
relation_id = self.getSessionRelationId()
relation_type = self.getSessionRelationType()
orig_concept_id = self.REQUEST.get('concept_id', None)
orig_relation_id = self.REQUEST.get('relation_id', None)
orig_relation_type = self.REQUEST.get('relation_type', None)
else:
concept_id = self.REQUEST.get('concept_id',
self.getSessionConceptId())
relation_id = self.REQUEST.get('relation_id',
self.getSessionRelationId())
relation_type = self.REQUEST.get('relation_type',
self.getSessionRelationType())
orig_concept_id = concept_id
orig_relation_id = relation_id
orig_relation_type = relation_type
self.delSessionConceptId()
self.delSessionRelationId()
self.delSessionRelationType()
return self.get_relations_item_data(concept_id, relation_id,
relation_type, orig_concept_id,
orig_relation_id,
orig_relation_type)
#import related
def skos_import(self, file, REQUEST=None):
""" """
parser = relation_parser()
#parse the SKOS information
chandler = parser.parseHeader(file)
if chandler is None:
if REQUEST:
self.setSessionErrorsTrans(
'Parsing error. The file could not be parsed.')
return REQUEST.RESPONSE.redirect('import_html')
#info
count_rel = 0
err_list = []
#set data
for data in chandler.getBody():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
relation_id = data['relation_id'].encode('utf-8').split('/')[-1]
relation_type = data['relation_type']
if concept_id:
if self.checkCpRel(concept_id) and self.checkCpRel(
relation_id):
self.__add_relation(concept_id, relation_id, relation_type)
count_rel += 1
else:
if not relation_id:
err_list.append((
'(${content_id}, None) - relation_id not specified',
{
'concept_id': concept_id
},
))
else:
err_list.append((
'(${concept_id}, ${relation_id}) - at least one of the concept_id or relation_id does not exist',
{
'concept_id': concept_id,
'relation_id': relation_id
}))
else:
err_list.append('None - concept_id not specified')
if REQUEST:
self.setSessionInfoTrans([
'File imported successfully.',
(
'Translations added: ${count_rel}',
{
'count_rel': count_rel
},
)
])
if err_list:
self.setSessionErrorsTrans([
'Relations not imported (by its (concept_id, relation_id)):',
err_list,
])
return REQUEST.RESPONSE.redirect('import_html')
#relation type related
def getRelTypes(self):
""" """
return RELATION_TYPES
def getRelTypesIDs(self):
""" """
return self.getRelTypes().keys()
def getRelTypeByID(self, id):
""" """
return self.getRelTypes()[id]
#statistics
def getAllConRel(self):
query = [('meta_type', CONCEPT_RELATION_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getConRelNumber(self):
return len(self.getAllConRel())
def getRelationsNumber(self):
results = {}
for conrel_ob in self.getAllConRel():
try:
br_count = results[1]
except:
br_count = 0
try:
nr_count = results[2]
except:
nr_count = 0
try:
re_count = results[3]
except:
re_count = 0
if conrel_ob.relation_type == '1':
results[1] = br_count + 1
elif conrel_ob.relation_type == '2':
results[2] = nr_count + 1
elif conrel_ob.relation_type == '3':
results[3] = re_count + 1
return results
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile(
"%s/zpt/ConceptRelations/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens,
'concept_relations_html')
concept_relations_html = PageTemplateFile(
"%s/zpt/ConceptRelations/concept_relations" % NAAYATHESAURUS_PATH,
globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile(
"%s/zpt/ConceptRelations/statistics" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'import_html')
import_html = PageTemplateFile(
"%s/zpt/ConceptRelations/import" % NAAYATHESAURUS_PATH, globals())
class Definitions(SimpleItem, session_manager):
""" Definitions """
meta_type = DEFINITIONS_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/definitions.gif'
manage_options = (
{
'label': 'Properties',
'action': 'properties_html'
},
{
'label': 'Management',
'action': 'definitions_html'
},
{
'label': 'Statistics',
'action': 'statistics_html'
},
{
'label': 'Undo',
'action': 'manage_UndoForm'
},
)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.definitions = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for Definitions """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#definitions management
def __add_definition(self, concept_id, langcode, definition, source_id):
#create a new item
item = DefinitionItem(concept_id, langcode, definition, source_id)
self.definitions[(concept_id, langcode)] = item
self.catalog.CatalogObject(item)
def __update_definition(self, concept_id, old_concept_id, langcode,
old_langcode, definition, source_id):
#modify an item
item = self.definitions.get((old_concept_id, old_langcode))
if item is not None:
self.__delete_definition((old_concept_id, old_langcode))
self.__add_definition(concept_id, langcode, definition, source_id)
security.declareProtected(view_management_screens, 'update_source_id')
def update_source_id(self, concept_id, langcode, source_id):
""" update the source_id list """
definition_ob = self.get_definition_by_id((concept_id, langcode))
if definition_ob.source_id:
upd_source_id = "%s %s" % (definition_ob.source_id, source_id)
else:
upd_source_id = source_id
self.__update_definition(concept_id, concept_id, langcode, langcode,
definition_ob.definition, upd_source_id)
def __delete_definition(self, ids):
#delete 1 or more items
if type(ids) != type((1, 1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_definitions()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#definition constraints
security.declareProtected(view_management_screens, 'checkDefinition')
def checkDefinition(self, concept_id):
""" """
if self.getConceptsFolder().get_concept_by_id(concept_id):
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.definitions.keys()
return th_utils().getIdsList(ids)
#definitions getters
def get_definitions(self):
#get all definitions
return self.definitions
def get_definitions_sorted(self):
#get all definitions sorted
return th_utils().utSortObjsListByAttr(self.definitions.values(),
'concept_id', 0)
def get_definition_by_id(self, id):
#get an item
try:
return self.definitions[id]
except:
return None
def get_definition_item_data(self, concept_id, langcode, orig_concept_id,
orig_langcode, definition, source_id):
#get an item data
item = self.get_definition_by_id((orig_concept_id, orig_langcode))
if item is not None:
if definition is None:
definition = item.definition
if source_id is None:
source_id = item.source_id
return [
'update', concept_id, langcode, definition, source_id,
orig_concept_id, orig_langcode
]
else:
return ['add', concept_id, langcode, definition, source_id, '', '']
#definitions api
security.declareProtected(view_management_screens, 'manage_add_definition')
def manage_add_definition(self,
concept_id='',
langcode='',
definition='',
source_id='',
REQUEST=None):
""" manage definitions """
err = 0
if self.checkDefinition(concept_id):
self.__add_definition(concept_id, langcode, definition, source_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionDefinition(definition)
self.setSessionSourceId(source_id)
self.setSessionErrorsTrans(
'${concept_id} is not a valid concept ID.',
concept_id=concept_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('definitions_html')
security.declareProtected(view_management_screens,
'manage_update_definition')
def manage_update_definition(self,
concept_id='',
old_concept_id='',
langcode='',
old_langcode='',
definition='',
source_id='',
REQUEST=None):
""" update definition """
err = 0
if self.checkDefinition(concept_id):
self.__update_definition(concept_id, old_concept_id, langcode,
old_langcode, definition, source_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionDefinition(definition)
self.setSessionSourceId(source_id)
self.setSessionErrorsTrans(
'${concept_id} is not a valid concept ID.',
concept_id=concept_id)
REQUEST.RESPONSE.redirect(
'definitions_html?concept_id=%s&langcode=%s' %
(old_concept_id, old_langcode))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('definitions_html')
security.declareProtected(view_management_screens,
'manage_delete_definitions')
def manage_delete_definitions(self, ids=[], delete_all='', REQUEST=None):
""" delete definitions """
if delete_all: ids = self.getIdsList(ids, 1)
else: ids = self.getIdsList(ids)
self.__delete_definition(ids)
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.')
REQUEST.RESPONSE.redirect('definitions_html')
security.declareProtected(view_management_screens, 'getDefinitionItemData')
def getDefinitionItemData(self):
""" return a definition based on its ID """
if self.isSessionConceptId():
concept_id = self.getSessionConceptId()
langcode = self.getSessionLangcode()
definition = self.getSessionDefinition()
source_id = self.getSessionSourceId()
orig_concept_id = self.REQUEST.get('concept_id', None)
orig_langcode = self.REQUEST.get('langcode', None)
else:
concept_id = self.REQUEST.get('concept_id',
self.getSessionConceptId())
langcode = self.REQUEST.get('langcode', self.getSessionLangcode())
definition = self.getSessionDefinition()
source_id = self.getSessionSourceId()
orig_concept_id = concept_id
orig_langcode = langcode
self.delSessionConceptId()
self.delSessionLangcode()
self.delSessionDefinition()
self.delSessionSourceId()
return self.get_definition_item_data(concept_id, langcode,
orig_concept_id, orig_langcode,
definition, source_id)
return self.get_definition_item_data(
self.REQUEST.get('concept_id', None),
self.REQUEST.get('langcode', None))
#statistics
def getAllDef(self):
query = [('meta_type', DEFINITION_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getDefNumber(self):
return len(self.getAllDef())
def getDefTransNumber(self):
results = {}
for def_ob in self.getAllDef():
try:
tr_count = results[def_ob.langcode][0]
except:
tr_count = 0
tr_count += 1
try:
src_count = results[def_ob.langcode][1]
except:
src_count = 0
if def_ob.source_id: src_count += 1
results[def_ob.langcode] = (tr_count, src_count)
return results
def getDefWithSource(self):
count = 0
for def_ob in self.getAllDef():
if len(def_ob.source_id): count += 1
return count
def getEmptyDefs(self):
empty_count = 0
for def_ob in self.getAllDef():
if not def_ob.definition:
empty_count += 1
return empty_count
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile(
"%s/zpt/Definitions/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'definitions_html')
definitions_html = PageTemplateFile(
"%s/zpt/Definitions/definitions" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile(
"%s/zpt/Definitions/statistics" % NAAYATHESAURUS_PATH, globals())
class Themes(SimpleItem, session_manager):
""" Themes """
meta_type = THEMES_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/themes.gif'
manage_options = (
{
'label': 'Basic properties',
'action': 'properties_html'
},
{
'label': 'Management',
'action': 'themes_html'
},
{
'label': 'Import',
'action': 'import_html'
},
{
'label': 'Statistics',
'action': 'statistics_html'
},
{
'label': 'Undo',
'action': 'manage_UndoForm'
},
)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.themes = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for Themes """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#themes management
def __add_theme(self, theme_id, langcode, name):
#create a new item
item = ThemeItem(theme_id, langcode, name)
self.themes[(theme_id, langcode)] = item
self.catalog.CatalogObject(item)
def __update_theme(self, theme_id, old_theme_id, langcode, old_langcode,
name):
#modify an item
item = self.themes.get((old_theme_id, old_langcode))
if item is not None:
self.__delete_theme((old_theme_id, old_langcode))
self.__add_theme(theme_id, langcode, name)
def __delete_theme(self, ids):
#delete 1 or more items
if type(ids) != type((1, 1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_themes()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#theme constraints
security.declareProtected(view_management_screens, 'checkTheme')
def checkTheme(self, theme_id):
""" """
if theme_id in self.getThemeRelationsFolder().getDistinctThemes():
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.themes.keys()
return th_utils().getIdsList(ids)
#themes getters
def get_themes(self):
#get all themes
return self.themes
def get_themes_sorted(self):
#get all themes sorted
return th_utils().utSortObjsListByAttr(self.themes.values(),
'langcode', 0)
def get_theme_by_id(self, id):
#get an item
try:
return self.themes[id]
except:
return None
def get_theme_item_data(self, theme_id, langcode, orig_theme_id,
orig_langcode, theme_name):
#get an item data
item = self.get_theme_by_id((orig_theme_id, orig_langcode))
if item is not None:
if theme_name is None:
theme_name = item.theme_name
return [
'update', theme_id, langcode, theme_name, orig_theme_id,
orig_langcode
]
else:
return ['add', theme_id, langcode, theme_name, '', '']
#themes api
security.declareProtected(view_management_screens, 'manage_add_theme')
def manage_add_theme(self,
theme_id='',
langcode='',
theme_name='',
REQUEST=None):
""" manage themes """
err = 0
if self.checkTheme(theme_id):
self.__add_theme(theme_id, langcode, theme_name)
else:
err = 1
if REQUEST:
if err:
self.setSessionThemeId(theme_id)
self.setSessionLangcode(langcode)
self.setSessionThemeName(theme_name)
self.setSessionErrorsTrans(
'${theme_id} is not a valid theme ID.', theme_id=theme_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('themes_html')
security.declareProtected(view_management_screens, 'manage_update_theme')
def manage_update_theme(self,
theme_id='',
old_theme_id='',
langcode='',
old_langcode='',
theme_name='',
REQUEST=None):
""" update theme """
err = 0
if self.checkTheme(theme_id):
self.__update_theme(theme_id, old_theme_id, langcode, old_langcode,
theme_name)
else:
err = 1
if REQUEST:
if err:
self.setSessionThemeId(theme_id)
self.setSessionLangcode(langcode)
self.setSessionThemeName(theme_name)
self.setSessionErrorsTrans(
'${theme_id} is not a valid theme ID.', theme_id=theme_id)
REQUEST.RESPONSE.redirect(
'themes_html?theme_id=%s&langcode=%s' %
(old_theme_id, old_langcode))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('themes_html')
security.declareProtected(view_management_screens, 'manage_delete_themes')
def manage_delete_themes(self, ids=[], delete_all='', REQUEST=None):
""" delete themes """
if delete_all: ids = self.getIdsList(ids, 1)
else: ids = self.getIdsList(ids)
self.__delete_theme(ids)
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.')
REQUEST.RESPONSE.redirect('themes_html')
security.declareProtected(view_management_screens, 'getThemeItemData')
def getThemeItemData(self):
""" return a theme based on its ID """
if self.isSessionThemeId():
theme_id = self.getSessionThemeId()
langcode = self.getSessionLangcode()
theme_name = self.getSessionThemeName()
orig_theme_id = self.REQUEST.get('theme_id', None)
orig_langcode = self.REQUEST.get('langcode', None)
else:
theme_id = self.REQUEST.get('theme_id', self.getSessionThemeId())
langcode = self.REQUEST.get('langcode', self.getSessionLangcode())
theme_name = self.getSessionThemeName()
orig_theme_id = theme_id
orig_langcode = langcode
self.delSessionThemeId()
self.delSessionLangcode()
self.delSessionThemeName()
return self.get_theme_item_data(theme_id, langcode, orig_theme_id,
orig_langcode, theme_name)
#import related
def skos_import(self, file, langcode, REQUEST=None):
""" """
parser = theme_parser()
#parse the SKOS information
chandler = parser.parseHeader(file)
if chandler is None:
if REQUEST:
self.setSessionErrorsTrans(
'Parsing error. The file could not be parsed.')
return REQUEST.RESPONSE.redirect('import_html')
#get the target language
skos_lang = chandler.getLanguage()
if skos_lang: target_language = skos_lang.encode('utf-8')
else: target_language = langcode
#get data
body_info = chandler.getBody()
#info
count_themes = 0
err_themes = []
#set data
for id, data in body_info.items():
theme_id = id.encode('utf-8').split('/')[-1]
if theme_id:
if self.checkTheme(theme_id):
theme_name = data['name']
self.__add_theme(theme_id, target_language, theme_name)
count_themes += 1
else:
err_themes.append(theme_id)
else:
err_themes.append('None')
if REQUEST:
self.setSessionInfoTrans([
'File imported successfully.',
(
'Translations added: ${count_themes}',
{
'count_themes': count_themes
},
)
])
if err_themes:
self.setSessionErrorsTrans([
'Translations not imported (by its theme_id):',
(
'Errors: ${err_themes}',
{
'err_themes':
th_utils().utJoinToString(err_themes, ', ')
},
)
])
return REQUEST.RESPONSE.redirect('import_html?msg=done')
#statistics
def getAllThemes(self):
query = [('meta_type', THEME_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getThemesNumber(self):
return len(self.getAllThemes())
def getThemesTransNumber(self):
results = {}
for theme_ob in self.getAllThemes():
try:
tr_count = results[theme_ob.langcode]
except:
tr_count = 0
results[theme_ob.langcode] = tr_count + 1
return results
def getEmptyTrans(self):
empty_count = 0
for theme_ob in self.getAllThemes():
if not theme_ob.theme_name:
empty_count += 1
return empty_count
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile(
"%s/zpt/Themes/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'themes_html')
themes_html = PageTemplateFile(
"%s/zpt/Themes/themes" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile(
"%s/zpt/Themes/statistics" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'import_html')
import_html = PageTemplateFile(
"%s/zpt/Themes/import" % NAAYATHESAURUS_PATH, globals())
class ThemeRelations(SimpleItem, session_manager):
""" ThemeRelations """
meta_type = THEME_RELATION_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/theme_relations.gif'
manage_options = (
{'label':'Properties', 'action':'properties_html'},
{'label':'Management', 'action':'theme_relations_html'},
{'label':'Statistics', 'action':'statistics_html'},
{'label':'Undo', 'action':'manage_UndoForm'},)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.theme_relations = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for ThemeRelations """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#theme relations management
def __add_threlation(self, concept_id, theme_id):
#create a new item
item = ThemeRelationItem(concept_id, theme_id)
self.theme_relations[(concept_id, theme_id)] = item
self.catalog.CatalogObject(item)
def __update_threlation(self, concept_id, old_concept_id, theme_id, old_theme_id):
#modify an item
item = self.theme_relations.get((old_concept_id, old_theme_id))
if item is not None:
self.__delete_threlation((old_concept_id, old_theme_id))
self.__add_threlation(concept_id, theme_id)
def __delete_threlation(self, ids):
#delete 1 or more items
if type(ids) != type((1,1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_threlations()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#theme relations constraints
security.declareProtected(view_management_screens, 'checkThRel')
def checkThRel(self, concept_id):
""" """
if self.getConceptsFolder().get_concept_by_id(concept_id):
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.theme_relations.keys()
return th_utils().getIdsList(ids)
security.declareProtected(view_management_screens, 'infoOnDelete')
def infoOnDelete(self, ids, all=0):
""" """
results = []
dic_cp = {}
lst_cp = []
for rel_id in self.getIdsList(ids, all):
rel_ob = self.get_threlation_by_id(rel_id)
try: lst_cp = dic_cp[rel_ob.concept_id]
except: lst_cp= []
lst_cp.append(rel_ob)
dic_cp[rel_ob.concept_id] = lst_cp
results.append(rel_ob)
for concept_id in dic_cp.keys():
query = [('meta_type',THEME_RELATION_ITEM_METATYPE),
('concept_id',concept_id)]
if len(dic_cp[concept_id]) == len(self.catalog.searchCatalog(query)):
dic_cp[concept_id] = 1
else:
dic_cp[concept_id] = 0
return (results, dic_cp)
#theme relations getters
def get_threlations(self):
#get all theme relations
return self.theme_relations
def get_threlations_sorted(self):
#get all theme relations sorted
return th_utils().utSortObjsListByAttr(self.theme_relations.values(), 'concept_id', 0)
def get_threlation_by_id(self, id):
#get an item
try: return self.theme_relations[id]
except: return None
def get_threlation_item_data(self, concept_id, theme_id, orig_concept_id, orig_theme_id):
#get an item data
item = self.get_threlation_by_id((orig_concept_id, orig_theme_id))
if item is not None:
return ['update', concept_id, theme_id, orig_concept_id, orig_theme_id]
else:
return ['add', concept_id, theme_id, '', '']
#themes api
security.declareProtected(view_management_screens, 'manage_add_threlation')
def manage_add_threlation(self, concept_id='', theme_id='', REQUEST=None):
""" manage theme relations """
err = 0
if self.checkThRel(concept_id):
self.__add_threlation(concept_id, theme_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionThemeId(theme_id)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('theme_relations_html')
security.declareProtected(view_management_screens, 'manage_update_threlation')
def manage_update_threlation(self, concept_id='', old_concept_id='', theme_id='', old_theme_id='', REQUEST=None):
""" update theme relation """
err = 0
if self.checkThRel(concept_id):
self.__update_threlation(concept_id, old_concept_id, theme_id, old_theme_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionThemeId(theme_id)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
REQUEST.RESPONSE.redirect('theme_relations_html?concept_id=%s&theme_id=%s' % (old_concept_id, old_theme_id))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('theme_relations_html')
security.declareProtected(view_management_screens, 'manage_delete_threlations')
def manage_delete_threlations(self, ids=[], REQUEST=None):
""" delete theme relations """
del_count = 0
self.__delete_threlation(self.getIdsList(ids))
query = [('meta_type',THEME_ITEM_METATYPE)]
th_list = self.catalog.searchCatalog(query)
for th_ob in th_list:
query = [('meta_type',THEME_RELATION_ITEM_METATYPE),
('theme_id',th_ob.theme_id)]
if not self.catalog.searchCatalog(query):
theme_folder = self.getThemesFolder()
theme_folder.manage_delete_themes(['%s###%s' % (th_ob.theme_id, th_ob.langcode)])
del_count += 1
if REQUEST:
self.setSessionInfoTrans(['Selected records deleted.',
('${del_count} related records were deleted.', {'del_count': del_count}, )])
REQUEST.RESPONSE.redirect('theme_relations_html')
security.declareProtected(view_management_screens, 'getThRelationItemData')
def getThRelationItemData(self):
""" return a theme relation based on its ID """
if self.isSessionConceptId():
concept_id = self.getSessionConceptId()
theme_id = self.getSessionThemeId()
orig_concept_id = self.REQUEST.get('concept_id', None)
orig_theme_id = self.REQUEST.get('theme_id', None)
else:
concept_id = self.REQUEST.get('concept_id', self.getSessionConceptId())
theme_id = self.REQUEST.get('theme_id', self.getSessionThemeId())
orig_concept_id = concept_id
orig_theme_id = theme_id
self.delSessionConceptId()
self.delSessionThemeId()
return self.get_threlation_item_data(concept_id, theme_id, orig_concept_id, orig_theme_id)
#statistics
def getAllRelTh(self):
query = [('meta_type',THEME_RELATION_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getRelThNumber(self):
return len(self.getAllRelTh())
def getDistinctThNumber(self):
return len(self.getDistinctThemes())
def getDistinctThemes(self):
themes_list = []
add_theme_id = themes_list.append
query = [('meta_type',THEME_RELATION_ITEM_METATYPE)]
th_relations = self.catalog.searchCatalog(query)
for rel_ob in th_relations:
theme_id = rel_ob.theme_id
if theme_id not in themes_list: add_theme_id(theme_id)
return themes_list
def getUntranslatedThemes(self):
th_count = 0
for theme_id in self.getDistinctThemes():
query = [('meta_type',THEME_ITEM_METATYPE),
('theme_id',theme_id)]
if not self.catalog.searchCatalog(query):
th_count += 1
return th_count
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile("%s/zpt/ThemeRelations/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'theme_relations_html')
theme_relations_html = PageTemplateFile("%s/zpt/ThemeRelations/theme_relations" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile("%s/zpt/ThemeRelations/statistics" % NAAYATHESAURUS_PATH, globals())
class Source(SimpleItem):
""" Source """
meta_type = SOURCE_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/source.gif'
manage_options = (
{'label':'Properties', 'action':'properties_html'},
{'label':'Management', 'action':'sources_html'},
{'label':'Statistics', 'action':'statistics_html'},
{'label':'Undo', 'action':'manage_UndoForm'},)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.sources = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for Source """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#sources management
def __add_source(self, source_id, source_name):
#create a new item
item = SourceItem(source_id, source_name)
self.sources[source_id] = item
self.catalog.CatalogObject(item)
def __update_source(self, source_id, old_source_id, source_name):
#modify an item
item = self.sources.get(old_source_id)
if item is not None:
self.__delete_source(old_source_id)
self.__add_source(source_id, source_name)
def __delete_source(self, ids):
#delete 1 or more items
ids = th_utils().utConvertToList(ids)
collection = self.get_sources()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#source constrints
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.sources.keys()
return th_utils().getIdsList(ids)
#sources getters
def get_sources(self):
#get all sources
return self.sources
def get_sources_sorted(self):
#get all sources sorted
return th_utils().utSortObjsListByAttr(self.sources.values(), 'source_id', 0)
def get_source_by_id(self, id):
#get an item
try: return self.sources[id]
except: return None
def get_source_item_data(self, id):
#get an item data
item = self.get_source_by_id(id)
if item is not None:
return ['update', item.source_id, item.source_name]
else:
return ['add', '', '']
#sources api
security.declareProtected(view_management_screens, 'manage_add_source')
def manage_add_source(self, source_id='', source_name='', REQUEST=None):
""" manage sources """
if not source_id: source_id = th_utils().utGenRandomId()
self.__add_source(source_id, source_name)
if REQUEST:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('sources_html')
security.declareProtected(view_management_screens, 'manage_update_source')
def manage_update_source(self, source_id='', old_source_id='', source_name='', REQUEST=None):
""" update source """
self.__update_source(source_id, old_source_id, source_name)
if REQUEST:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('sources_html')
security.declareProtected(view_management_screens, 'manage_delete_sources')
def manage_delete_sources(self, ids=[], delete_all='', REQUEST=None):
""" delete sources """
if delete_all: ids = self.getIdsList(ids, 1)
else: ids = self.getIdsList(ids)
self.__delete_source(ids)
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.')
REQUEST.RESPONSE.redirect('sources_html')
security.declareProtected(view_management_screens, 'getSourceItemData')
def getSourceItemData(self):
""" return a source based on its ID """
return self.get_source_item_data(self.REQUEST.get('source_id', None))
#statistics
def getAllSrc(self):
query = [('meta_type',SOURCE_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getSrcNumber(self):
return len(self.getAllSrc())
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile("%s/zpt/Source/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'sources_html')
sources_html = PageTemplateFile("%s/zpt/Source/sources" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile("%s/zpt/Source/statistics" % NAAYATHESAURUS_PATH, globals())
class SilvaFind(Query, Content, SimpleItem):
__doc__ = _("""Silva Find is a powerful search feature that allows easy
creation of search forms and result pages. Users can add a Find
anywhere and define which fields to make searchable by site visitors
and/or which fields to limit to a preset value. Users also can
determine which fields should be displayed in the search results. All
metadata sets/fields are supported.""")
security = ClassSecurityInfo()
meta_type = "Silva Find"
grok.implements(IFind)
silvaconf.icon('SilvaFind.png')
def __init__(self, id):
Content.__init__(self, id)
Query.__init__(self)
self.shownFields = PersistentMapping()
self.shownResultsFields = PersistentMapping()
# by default we only show fulltext search
# and a couple of resultfields
self.shownFields['fulltext'] = True
self.shownResultsFields['link'] = True
self.shownResultsFields['ranking'] = True
self.shownResultsFields['resultcount'] = True
self.shownResultsFields['icon'] = True
self.shownResultsFields['date'] = True
self.shownResultsFields['textsnippet'] = True
self.shownResultsFields['thumbnail'] = True
self.shownResultsFields['breadcrumbs'] = True
# ACCESSORS
security.declareProtected(SilvaPermissions.View, 'getPublicResultFields')
def getPublicResultFields(self):
return filter(lambda field: self.isResultShown(field.getName()),
self.getResultFields())
security.declareProtected(SilvaPermissions.View, 'getPublicSearchFields')
def getPublicSearchFields(self):
return filter(lambda field: self.isCriterionShown(field.getName()),
self.getSearchFields())
security.declareProtected(SilvaPermissions.View, 'isCriterionShown')
def isCriterionShown(self, fieldName):
return self.shownFields.get(fieldName, False)
security.declareProtected(SilvaPermissions.View, 'isResultShown')
def isResultShown(self, fieldName):
return self.shownResultsFields.get(fieldName, False)
security.declareProtected(SilvaPermissions.View, 'havePublicSearchFields')
def havePublicSearchFields(self):
# BBB map(bool) is here for previously non-boolean stored values
return reduce(operator.or_, map(bool, self.shownFields.values()))
security.declareProtected(SilvaPermissions.View, 'searchResults')
def searchResults(self, request={}, validate=True):
options = self.getSearchCriterias(request)
if validate:
queryEmpty = True
for key, value in options.items():
if key in ['path', 'meta_type']:
# these fields do not count as a real search query
# they are always there to filter unwanted results
continue
if type(value) is unicode and value.strip():
queryEmpty = False
break
elif type(value) is list:
queryEmpty = False
break
query = options.get('fulltext', '').strip()
if query and query[0] in ['?', '*']:
raise ValueError(
_(u'Search query can not start with wildcard character.'))
if queryEmpty:
raise ValueError(
_(u'You need to fill at least one field in the search form.'
))
options['publication_status'] = ['public']
catalog = self.get_root().service_catalog
try:
results = catalog.searchResults(options)
except ParseError:
raise ValueError(
_(u'Search query contains only common or reserved words.'))
return results
def getSearchCriterias(self, request):
options = {}
for field in self.getSearchFields():
name = field.getName()
if (self.shownFields.get(name, False) or name == 'path'):
queryPart = getMultiAdapter((field, self, request), IQueryPart)
value = queryPart.getIndexValue()
if value is None:
value = ''
options[queryPart.getIndexId()] = value
return options
class Terms(SimpleItem, session_manager):
""" Terms """
meta_type = TERMS_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/terms.gif'
manage_options = (
{'label':'Properties', 'action':'properties_html'},
{'label':'Management', 'action':'terms_html'},
{'label':'Import', 'action':'import_html'},
{'label':'Statistics', 'action':'statistics_html'},
{'label':'Undo', 'action':'manage_UndoForm'},)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.terms = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for Terms """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#terms management
def __add_term(self, concept_id, langcode, concept_name, source_id):
#create a new item
item = TermItem(concept_id, langcode, concept_name, source_id)
self.terms[(concept_id, langcode)] = item
self.catalog.CatalogObject(item)
def __update_term(self, concept_id, old_concept_id, langcode, old_langcode,
concept_name, source_id):
#modify an item
item = self.terms.get((old_concept_id, old_langcode))
if item is not None:
self.__delete_term((old_concept_id, old_langcode))
self.__add_term(concept_id, langcode, concept_name, source_id)
security.declareProtected(view_management_screens, 'update_source_id')
def update_source_id(self, concept_id, langcode, source_id):
""" update the source_id list """
term_ob = self.get_term_by_id((concept_id, langcode))
if term_ob.source_id: upd_source_id = "%s %s" % (term_ob.source_id, source_id)
else: upd_source_id = source_id
self.__update_term(concept_id, concept_id, langcode, langcode, term_ob.concept_name, upd_source_id)
def __delete_term(self, ids):
#delete 1 or more items
if type(ids) != type((1,1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_terms()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#term constraints
security.declareProtected(view_management_screens, 'checkTerm')
def checkTerm(self, concept_id):
""" """
if self.getConceptsFolder().get_concept_by_id(concept_id):
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.terms.keys()
return th_utils().getIdsList(ids)
#terms getters
def get_terms(self):
#get all terms
return self.terms
def get_terms_sorted(self):
#get all terms sorted
return th_utils().utSortObjsListByAttr(self.terms.values(), 'concept_id', 0)
def get_term_by_id(self, id):
#get an item
try: return self.terms[id]
except: return None
def get_term_item_data(self, concept_id, langcode, orig_concept_id, orig_langcode, concept_name, source_id):
#get an item data
item = self.get_term_by_id((orig_concept_id, orig_langcode))
if item is not None:
if concept_name is None:
concept_name = item.concept_name
if source_id is None:
source_id = item.source_id
return ['update', concept_id, langcode, concept_name, source_id, orig_concept_id, orig_langcode]
else:
return ['add', concept_id, langcode, concept_name, source_id, '', '']
#terms api
security.declareProtected(view_management_screens, 'manage_add_term')
def manage_add_term(self, concept_id='', langcode='', concept_name='', source_id='', REQUEST=None):
""" manage terms """
err = 0
if self.checkTerm(concept_id):
self.__add_term(concept_id, langcode, concept_name, source_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionConceptName(concept_name)
self.setSessionSourceId(source_id)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('terms_html')
security.declareProtected(view_management_screens, 'manage_update_term')
def manage_update_term(self, concept_id='', old_concept_id='', langcode='', old_langcode='',
concept_name='', source_id='', REQUEST=None):
""" update term """
err = 0
if self.checkTerm(concept_id):
self.__update_term(concept_id, old_concept_id, langcode, old_langcode, concept_name, source_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionConceptName(concept_name)
self.setSessionSourceId(source_id)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
REQUEST.RESPONSE.redirect('terms_html?concept_id=%s&langcode=%s' % (old_concept_id, old_langcode))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('terms_html')
security.declareProtected(view_management_screens, 'manage_delete_terms')
def manage_delete_terms(self, ids=[], delete_all='', REQUEST=None):
""" delete terms """
if delete_all: ids = self.getIdsList(ids, 1)
else: ids = self.getIdsList(ids)
self.__delete_term(ids)
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.')
REQUEST.RESPONSE.redirect('terms_html')
security.declareProtected(view_management_screens, 'getTermItemData')
def getTermItemData(self):
""" return a term based on its ID """
if self.isSessionConceptId():
concept_id = self.getSessionConceptId()
langcode = self.getSessionLangcode()
concept_name = self.getSessionConceptName()
source_id = self.getSessionSourceId()
orig_concept_id = self.REQUEST.get('concept_id', None)
orig_langcode = self.REQUEST.get('langcode', None)
else:
concept_id = self.REQUEST.get('concept_id', self.getSessionConceptId())
langcode = self.REQUEST.get('langcode', self.getSessionLangcode())
concept_name = self.getSessionConceptName()
source_id = self.getSessionSourceId()
orig_concept_id = concept_id
orig_langcode = langcode
self.delSessionConceptId()
self.delSessionLangcode()
self.delSessionConceptName()
self.delSessionSourceId()
return self.get_term_item_data(concept_id, langcode, orig_concept_id, orig_langcode, concept_name, source_id)
#import related
def skos_import(self, file, langcode, REQUEST=None):
""" """
parser = term_parser()
#parse the SKOS information
chandler = parser.parseHeader(file)
if chandler is None:
if REQUEST:
self.setSessionErrorsTrans('Parsing error. The file could not be parsed.')
return REQUEST.RESPONSE.redirect('import_html')
#get the target language
skos_lang = chandler.getLanguage()
if skos_lang: langcode = skos_lang.encode('utf-8')
#get data
pref_info = chandler.getPref()
alt_info = chandler.getAlt()
def_info = chandler.getDef()
scope_info = chandler.getScope()
src_info = chandler.getSrc()
def_src_info = chandler.getDefSrc()
#info
count_terms = 0
err_terms = []
count_altterms = 0
err_altterms = []
count_def = 0
err_defs = []
count_scope = 0
err_scope = []
count_src = 0
err_src = []
count_def_src = 0
err_def_src = []
#set Terms
for id, data in pref_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
concept_name = data['concept_name']
source_id = ''
if self.checkTerm(concept_id):
self.__add_term(concept_id, langcode, concept_name, source_id)
count_terms += 1
else:
err_terms.append(concept_id)
else:
err_terms.append('None')
#set Alternatives terms
for id, data in alt_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
alt_terms_folder = self.getAltTermsFolder()
alt_name = data['alt_name']
if self.checkTerm(concept_id):
alt_terms_folder.manage_add_altterm(concept_id, langcode, alt_name)
count_altterms += 1
else:
err_altterms.append(concept_id)
else:
err_altterms.append('None')
#set Definitions
for id, data in def_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
definitions_folder = self.getDefinitionsFolder()
definition = data['definition']
if self.checkTerm(concept_id):
#TODO: implement source
definitions_folder.manage_add_definition(concept_id, langcode, definition, '')
count_def += 1
else:
err_defs.append(concept_id)
else:
err_defs.append('None')
#set ScopeNotes
for id, data in scope_info.items():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
scopenotes_folder = self.getScopeNotesFolder()
scope_note = data['scope_note']
if self.checkTerm(concept_id):
scopenotes_folder.manage_add_scope(concept_id, langcode, scope_note)
count_scope += 1
else:
err_scope.append(concept_id)
else:
err_scope.append('None')
#set Terms sources
for id, data in src_info.items():
source_id = data['source_id']
source_name = data['source_name']
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
if self.checkTerm(concept_id):
sources_folder = self.getSourceFolder()
#add source record
sources_folder.manage_add_source(source_id, source_name)
#update term record
self.update_source_id(concept_id, langcode, source_id)
count_src += 1
else:
err_src.append(concept_id)
else:
err_src.append('None')
#set Definitions sources
for id, data in def_src_info.items():
source_id = data['source_id']
source_name = data['source_name']
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
if concept_id:
if self.checkTerm(concept_id):
sources_folder = self.getSourceFolder()
definitions_folder = self.getDefinitionsFolder()
#add source record
sources_folder.manage_add_source(source_id, source_name)
#update definition record
definitions_folder.update_source_id(concept_id, langcode, source_id)
count_def_src += 1
else:
err_def_src.append(concept_id)
else:
err_def_src.append('None')
if REQUEST:
self.setSessionInfoTrans(['File imported successfully.',
('Translations added: ${count_terms}', {'count_terms': count_terms}, ),
('Alternative terms added: ${count_altterms}', {'count_altterms': count_altterms}, ),
('Definitions added: ${count_def}', {'count_def': count_def}, ),
('ScopeNotes added: ${count_scope}', {'count_scope': count_scope}, ),
('Terms Sources added: ${count_src}', {'count_src': count_src}, ),
('Definitions Sources added: ${count_def_src}', {'count_def_src': count_def_src}, ),
])
msg_err = []
if err_terms:
msg_err.append(('Translations not imported because the specified concept_id does not exist: ${err_terms}',
{'err_terms': th_utils().utJoinToString(err_terms, ', ')}, ))
if err_altterms:
msg_err.append(('Alternative terms not imported because the specified concept_id does not exist: ${err_altterms}',
{'err_altterms': th_utils().utJoinToString(err_altterms, ', ')}, ))
if err_defs:
msg_err.append(('Definitions not imported because the specified concept_id does not exist: ${err_defs}',
{'err_defs': th_utils().utJoinToString(err_defs, ', ')}, ))
if err_scope:
msg_err.append(('ScopeNotes not imported because the specified concept_id does not exist: ${err_scope}',
{'err_scope': th_utils().utJoinToString(err_scope, ', ')}, ))
if err_src:
msg_err.append(('Term sources not imported because the specified concept_id does not exist: ${err_src}',
{'err_src': th_utils().utJoinToString(err_src, ', ')}, ))
if err_def_src:
msg_err.append(('Definition sources not imported because the specified concept_id does not exist: ${err_def_src}',
{'err_def_src': th_utils().utJoinToString(err_def_src, ', ')}, ))
if msg_err:
self.setSessionErrorsTrans(msg_err)
return REQUEST.RESPONSE.redirect('import_html')
#statistics
def getAllTerms(self):
query = [('meta_type',TERM_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getTermsNumber(self):
return len(self.getAllTerms())
def getTermsTransNumber(self):
results = {}
for term_ob in self.getAllTerms():
try: tr_count = results[term_ob.langcode][0]
except: tr_count = 0
tr_count += 1
try: src_count = results[term_ob.langcode][1]
except: src_count = 0
if term_ob.source_id: src_count += 1
results[term_ob.langcode] = (tr_count, src_count)
return results
def getTermsWithSource(self):
count = 0
for term_ob in self.getAllTerms():
if len(term_ob.source_id): count += 1
return count
def getEmptyTrans(self):
empty_count = 0
for term_ob in self.getAllTerms():
if not term_ob.concept_name:
empty_count += 1
return empty_count
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile("%s/zpt/Terms/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'terms_html')
terms_html = PageTemplateFile("%s/zpt/Terms/terms" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile("%s/zpt/Terms/statistics" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'import_html')
import_html = PageTemplateFile("%s/zpt/Terms/import" % NAAYATHESAURUS_PATH, globals())
class Themes(SimpleItem, session_manager):
""" Themes """
meta_type = THEMES_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = "misc_/NaayaThesaurus/themes.gif"
manage_options = (
{"label": "Basic properties", "action": "properties_html"},
{"label": "Management", "action": "themes_html"},
{"label": "Import", "action": "import_html"},
{"label": "Statistics", "action": "statistics_html"},
{"label": "Undo", "action": "manage_UndoForm"},
)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.themes = PersistentMapping()
# basic properties
security.declareProtected(view_management_screens, "manageBasicProperties")
def manageBasicProperties(self, title="", REQUEST=None):
""" manage basic properties for Themes """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans("Saved changes.")
return REQUEST.RESPONSE.redirect("properties_html")
# themes management
def __add_theme(self, theme_id, langcode, name):
# create a new item
item = ThemeItem(theme_id, langcode, name)
self.themes[(theme_id, langcode)] = item
self.catalog.CatalogObject(item)
def __update_theme(self, theme_id, old_theme_id, langcode, old_langcode, name):
# modify an item
item = self.themes.get((old_theme_id, old_langcode))
if item is not None:
self.__delete_theme((old_theme_id, old_langcode))
self.__add_theme(theme_id, langcode, name)
def __delete_theme(self, ids):
# delete 1 or more items
if type(ids) != type((1, 1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_themes()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
# theme constraints
security.declareProtected(view_management_screens, "checkTheme")
def checkTheme(self, theme_id):
""" """
if theme_id in self.getThemeRelationsFolder().getDistinctThemes():
return 1
return 0
security.declareProtected(view_management_screens, "getIdsList")
def getIdsList(self, ids, all=0):
""" """
if all:
return self.themes.keys()
return th_utils().getIdsList(ids)
# themes getters
def get_themes(self):
# get all themes
return self.themes
def get_themes_sorted(self):
# get all themes sorted
return th_utils().utSortObjsListByAttr(self.themes.values(), "langcode", 0)
def get_theme_by_id(self, id):
# get an item
try:
return self.themes[id]
except:
return None
def get_theme_item_data(self, theme_id, langcode, orig_theme_id, orig_langcode, theme_name):
# get an item data
item = self.get_theme_by_id((orig_theme_id, orig_langcode))
if item is not None:
if theme_name is None:
theme_name = item.theme_name
return ["update", theme_id, langcode, theme_name, orig_theme_id, orig_langcode]
else:
return ["add", theme_id, langcode, theme_name, "", ""]
# themes api
security.declareProtected(view_management_screens, "manage_add_theme")
def manage_add_theme(self, theme_id="", langcode="", theme_name="", REQUEST=None):
""" manage themes """
err = 0
if self.checkTheme(theme_id):
self.__add_theme(theme_id, langcode, theme_name)
else:
err = 1
if REQUEST:
if err:
self.setSessionThemeId(theme_id)
self.setSessionLangcode(langcode)
self.setSessionThemeName(theme_name)
self.setSessionErrorsTrans("${theme_id} is not a valid theme ID.", theme_id=theme_id)
else:
self.setSessionInfoTrans("Record added.")
REQUEST.RESPONSE.redirect("themes_html")
security.declareProtected(view_management_screens, "manage_update_theme")
def manage_update_theme(
self, theme_id="", old_theme_id="", langcode="", old_langcode="", theme_name="", REQUEST=None
):
""" update theme """
err = 0
if self.checkTheme(theme_id):
self.__update_theme(theme_id, old_theme_id, langcode, old_langcode, theme_name)
else:
err = 1
if REQUEST:
if err:
self.setSessionThemeId(theme_id)
self.setSessionLangcode(langcode)
self.setSessionThemeName(theme_name)
self.setSessionErrorsTrans("${theme_id} is not a valid theme ID.", theme_id=theme_id)
REQUEST.RESPONSE.redirect("themes_html?theme_id=%s&langcode=%s" % (old_theme_id, old_langcode))
else:
self.setSessionInfoTrans("Record updated.")
REQUEST.RESPONSE.redirect("themes_html")
security.declareProtected(view_management_screens, "manage_delete_themes")
def manage_delete_themes(self, ids=[], delete_all="", REQUEST=None):
""" delete themes """
if delete_all:
ids = self.getIdsList(ids, 1)
else:
ids = self.getIdsList(ids)
self.__delete_theme(ids)
if REQUEST:
self.setSessionInfoTrans("Selected records deleted.")
REQUEST.RESPONSE.redirect("themes_html")
security.declareProtected(view_management_screens, "getThemeItemData")
def getThemeItemData(self):
""" return a theme based on its ID """
if self.isSessionThemeId():
theme_id = self.getSessionThemeId()
langcode = self.getSessionLangcode()
theme_name = self.getSessionThemeName()
orig_theme_id = self.REQUEST.get("theme_id", None)
orig_langcode = self.REQUEST.get("langcode", None)
else:
theme_id = self.REQUEST.get("theme_id", self.getSessionThemeId())
langcode = self.REQUEST.get("langcode", self.getSessionLangcode())
theme_name = self.getSessionThemeName()
orig_theme_id = theme_id
orig_langcode = langcode
self.delSessionThemeId()
self.delSessionLangcode()
self.delSessionThemeName()
return self.get_theme_item_data(theme_id, langcode, orig_theme_id, orig_langcode, theme_name)
# import related
def skos_import(self, file, langcode, REQUEST=None):
""" """
parser = theme_parser()
# parse the SKOS information
chandler = parser.parseHeader(file)
if chandler is None:
if REQUEST:
self.setSessionErrorsTrans("Parsing error. The file could not be parsed.")
return REQUEST.RESPONSE.redirect("import_html")
# get the target language
skos_lang = chandler.getLanguage()
if skos_lang:
target_language = skos_lang.encode("utf-8")
else:
target_language = langcode
# get data
body_info = chandler.getBody()
# info
count_themes = 0
err_themes = []
# set data
for id, data in body_info.items():
theme_id = id.encode("utf-8").split("/")[-1]
if theme_id:
if self.checkTheme(theme_id):
theme_name = data["name"]
self.__add_theme(theme_id, target_language, theme_name)
count_themes += 1
else:
err_themes.append(theme_id)
else:
err_themes.append("None")
if REQUEST:
self.setSessionInfoTrans(
["File imported successfully.", ("Translations added: ${count_themes}", {"count_themes": count_themes})]
)
if err_themes:
self.setSessionErrorsTrans(
[
"Translations not imported (by its theme_id):",
("Errors: ${err_themes}", {"err_themes": th_utils().utJoinToString(err_themes, ", ")}),
]
)
return REQUEST.RESPONSE.redirect("import_html?msg=done")
# statistics
def getAllThemes(self):
query = [("meta_type", THEME_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getThemesNumber(self):
return len(self.getAllThemes())
def getThemesTransNumber(self):
results = {}
for theme_ob in self.getAllThemes():
try:
tr_count = results[theme_ob.langcode]
except:
tr_count = 0
results[theme_ob.langcode] = tr_count + 1
return results
def getEmptyTrans(self):
empty_count = 0
for theme_ob in self.getAllThemes():
if not theme_ob.theme_name:
empty_count += 1
return empty_count
# management tabs
security.declareProtected(view_management_screens, "properties_html")
properties_html = PageTemplateFile("%s/zpt/Themes/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, "themes_html")
themes_html = PageTemplateFile("%s/zpt/Themes/themes" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, "statistics_html")
statistics_html = PageTemplateFile("%s/zpt/Themes/statistics" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, "import_html")
import_html = PageTemplateFile("%s/zpt/Themes/import" % NAAYATHESAURUS_PATH, globals())
class Definitions(SimpleItem, session_manager):
""" Definitions """
meta_type = DEFINITIONS_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/definitions.gif'
manage_options = (
{'label':'Properties', 'action':'properties_html'},
{'label':'Management', 'action':'definitions_html'},
{'label':'Statistics', 'action':'statistics_html'},
{'label':'Undo', 'action':'manage_UndoForm'},)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.definitions = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for Definitions """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#definitions management
def __add_definition(self, concept_id, langcode, definition, source_id):
#create a new item
item = DefinitionItem(concept_id, langcode, definition, source_id)
self.definitions[(concept_id, langcode)] = item
self.catalog.CatalogObject(item)
def __update_definition(self, concept_id, old_concept_id, langcode, old_langcode,
definition, source_id):
#modify an item
item = self.definitions.get((old_concept_id, old_langcode))
if item is not None:
self.__delete_definition((old_concept_id, old_langcode))
self.__add_definition(concept_id, langcode, definition, source_id)
security.declareProtected(view_management_screens, 'update_source_id')
def update_source_id(self, concept_id, langcode, source_id):
""" update the source_id list """
definition_ob = self.get_definition_by_id((concept_id, langcode))
if definition_ob.source_id: upd_source_id = "%s %s" % (definition_ob.source_id, source_id)
else: upd_source_id = source_id
self.__update_definition(concept_id, concept_id, langcode, langcode, definition_ob.definition, upd_source_id)
def __delete_definition(self, ids):
#delete 1 or more items
if type(ids) != type((1,1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_definitions()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#definition constraints
security.declareProtected(view_management_screens, 'checkDefinition')
def checkDefinition(self, concept_id):
""" """
if self.getConceptsFolder().get_concept_by_id(concept_id):
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.definitions.keys()
return th_utils().getIdsList(ids)
#definitions getters
def get_definitions(self):
#get all definitions
return self.definitions
def get_definitions_sorted(self):
#get all definitions sorted
return th_utils().utSortObjsListByAttr(self.definitions.values(), 'concept_id', 0)
def get_definition_by_id(self, id):
#get an item
try: return self.definitions[id]
except: return None
def get_definition_item_data(self, concept_id, langcode, orig_concept_id, orig_langcode, definition, source_id):
#get an item data
item = self.get_definition_by_id((orig_concept_id, orig_langcode))
if item is not None:
if definition is None:
definition = item.definition
if source_id is None:
source_id = item.source_id
return ['update', concept_id, langcode, definition, source_id, orig_concept_id, orig_langcode]
else:
return ['add', concept_id, langcode, definition, source_id, '', '']
#definitions api
security.declareProtected(view_management_screens, 'manage_add_definition')
def manage_add_definition(self, concept_id='', langcode='', definition='', source_id='', REQUEST=None):
""" manage definitions """
err = 0
if self.checkDefinition(concept_id):
self.__add_definition(concept_id, langcode, definition, source_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionDefinition(definition)
self.setSessionSourceId(source_id)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('definitions_html')
security.declareProtected(view_management_screens, 'manage_update_definition')
def manage_update_definition(self, concept_id='', old_concept_id='', langcode='', old_langcode='',
definition='', source_id='', REQUEST=None):
""" update definition """
err = 0
if self.checkDefinition(concept_id):
self.__update_definition(concept_id, old_concept_id, langcode, old_langcode, definition, source_id)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionDefinition(definition)
self.setSessionSourceId(source_id)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
REQUEST.RESPONSE.redirect('definitions_html?concept_id=%s&langcode=%s' % (old_concept_id, old_langcode))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('definitions_html')
security.declareProtected(view_management_screens, 'manage_delete_definitions')
def manage_delete_definitions(self, ids=[], delete_all='', REQUEST=None):
""" delete definitions """
if delete_all: ids = self.getIdsList(ids, 1)
else: ids = self.getIdsList(ids)
self.__delete_definition(ids)
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.')
REQUEST.RESPONSE.redirect('definitions_html')
security.declareProtected(view_management_screens, 'getDefinitionItemData')
def getDefinitionItemData(self):
""" return a definition based on its ID """
if self.isSessionConceptId():
concept_id = self.getSessionConceptId()
langcode = self.getSessionLangcode()
definition = self.getSessionDefinition()
source_id = self.getSessionSourceId()
orig_concept_id = self.REQUEST.get('concept_id', None)
orig_langcode = self.REQUEST.get('langcode', None)
else:
concept_id = self.REQUEST.get('concept_id', self.getSessionConceptId())
langcode = self.REQUEST.get('langcode', self.getSessionLangcode())
definition = self.getSessionDefinition()
source_id = self.getSessionSourceId()
orig_concept_id = concept_id
orig_langcode = langcode
self.delSessionConceptId()
self.delSessionLangcode()
self.delSessionDefinition()
self.delSessionSourceId()
return self.get_definition_item_data(concept_id, langcode, orig_concept_id, orig_langcode, definition, source_id)
return self.get_definition_item_data(self.REQUEST.get('concept_id', None), self.REQUEST.get('langcode', None))
#statistics
def getAllDef(self):
query = [('meta_type',DEFINITION_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getDefNumber(self):
return len(self.getAllDef())
def getDefTransNumber(self):
results = {}
for def_ob in self.getAllDef():
try: tr_count = results[def_ob.langcode][0]
except: tr_count = 0
tr_count += 1
try: src_count = results[def_ob.langcode][1]
except: src_count = 0
if def_ob.source_id: src_count += 1
results[def_ob.langcode] = (tr_count, src_count)
return results
def getDefWithSource(self):
count = 0
for def_ob in self.getAllDef():
if len(def_ob.source_id): count += 1
return count
def getEmptyDefs(self):
empty_count = 0
for def_ob in self.getAllDef():
if not def_ob.definition:
empty_count += 1
return empty_count
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile("%s/zpt/Definitions/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'definitions_html')
definitions_html = PageTemplateFile("%s/zpt/Definitions/definitions" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile("%s/zpt/Definitions/statistics" % NAAYATHESAURUS_PATH, globals())
class AltTerms(SimpleItem, session_manager):
""" AltTerms """
meta_type = ALTTERMS_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/alt_terms.gif'
manage_options = (
{'label':'Properties', 'action':'properties_html'},
{'label':'Management', 'action':'altterms_html'},
{'label':'Statistics', 'action':'statistics_html'},
{'label':'Undo', 'action':'manage_UndoForm'},)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.altterms = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for AltTerms """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#alt_terms management
def __add_altterm(self, concept_id, langcode, alt_name):
#create a new item
item = AltTermItem(concept_id, langcode, alt_name)
self.altterms[(concept_id, langcode)] = item
self.catalog.CatalogObject(item)
def __update_altterm(self, concept_id, old_concept_id, langcode, old_langcode, alt_name):
#modify an item
item = self.altterms.get((old_concept_id, old_langcode))
if item is not None:
self.__delete_altterm((old_concept_id, old_langcode))
self.__add_altterm(concept_id, langcode, alt_name)
def __delete_altterm(self, ids):
#delete 1 or more items
if type(ids) != type((1,1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_altterms()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#altterm constraints
security.declareProtected(view_management_screens, 'checkAltTerm')
def checkAltTerm(self, concept_id):
""" """
if self.getConceptsFolder().get_concept_by_id(concept_id):
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.altterms.keys()
return th_utils().getIdsList(ids)
#terms getters
def get_altterms(self):
#get all alt_terms
return self.altterms
def get_altterms_sorted(self):
#get all alt_terms sorted
return th_utils().utSortObjsListByAttr(self.altterms.values(), 'concept_id', 0)
def get_altterm_by_id(self, id):
#get an item
try: return self.altterms[id]
except: return None
def get_altterm_item_data(self,concept_id, langcode, orig_concept_id, orig_langcode, alt_name):
#get an item data
item = self.get_altterm_by_id((orig_concept_id, orig_langcode))
if item is not None:
if alt_name is None:
alt_name = item.alt_name
return ['update', concept_id, langcode, alt_name, orig_concept_id, orig_langcode]
else:
return ['add', concept_id, langcode, alt_name, '', '']
#alt_terms api
security.declareProtected(view_management_screens, 'manage_add_altterm')
def manage_add_altterm(self, concept_id='', langcode='', alt_name='', REQUEST=None):
""" manage alt_terms """
err = 0
if self.checkAltTerm(concept_id):
self.__add_altterm(concept_id, langcode, alt_name)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionAltName(alt_name)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('altterms_html')
security.declareProtected(view_management_screens, 'manage_update_altterm')
def manage_update_altterm(self, concept_id='', old_concept_id='', langcode='', old_langcode='', alt_name='', REQUEST=None):
""" update alt_term """
err = 0
if self.checkAltTerm(concept_id):
self.__update_altterm(concept_id, old_concept_id, langcode, old_langcode, alt_name)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionLangcode(langcode)
self.setSessionAltName(alt_name)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
REQUEST.RESPONSE.redirect('altterms_html?concept_id=%s&langcode=%s' % (old_concept_id, old_langcode))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('altterms_html')
security.declareProtected(view_management_screens, 'manage_delete_altterms')
def manage_delete_altterms(self, ids=[], delete_all='', REQUEST=None):
""" delete alt_terms """
if delete_all: ids = self.getIdsList(ids, 1)
else: ids = self.getIdsList(ids)
self.__delete_altterm(ids)
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.')
REQUEST.RESPONSE.redirect('altterms_html')
security.declareProtected(view_management_screens, 'getAltTermItemData')
def getAltTermItemData(self):
""" return a term based on its ID """
if self.isSessionConceptId():
concept_id = self.getSessionConceptId()
langcode = self.getSessionLangcode()
alt_name = self.getSessionAltName()
orig_concept_id = self.REQUEST.get('concept_id', None)
orig_langcode = self.REQUEST.get('langcode', None)
else:
concept_id = self.REQUEST.get('concept_id', self.getSessionConceptId())
langcode = self.REQUEST.get('langcode', self.getSessionLangcode())
alt_name = self.getSessionAltName()
orig_concept_id = concept_id
orig_langcode = langcode
self.delSessionConceptId()
self.delSessionLangcode()
self.delSessionAltName()
return self.get_altterm_item_data(concept_id, langcode, orig_concept_id, orig_langcode, alt_name)
#statistics
def getAllAltTerms(self):
query = [('meta_type',ALTTERM_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getAltTermsNumber(self):
return len(self.getAllAltTerms())
def getAltTermsTransNumber(self):
results = {}
for altt_ob in self.getAllAltTerms():
try: tr_count = results[altt_ob.langcode]
except: tr_count = 0
results[altt_ob.langcode] = tr_count + 1
return results
def getEmptyTrans(self):
empty_count = 0
for altterm_ob in self.getAllAltTerms():
if not altterm_ob.alt_name:
empty_count += 1
return empty_count
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile("%s/zpt/AltTerms/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'altterms_html')
altterms_html = PageTemplateFile("%s/zpt/AltTerms/altterms" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile("%s/zpt/AltTerms/statistics" % NAAYATHESAURUS_PATH, globals())
class ConceptRelations(SimpleItem, session_manager):
""" ConceptRelations """
meta_type = CONCEPT_RELATIONS_METATYPE
product_name = NAAYATHESAURUS_PRODUCT_NAME
icon = 'misc_/NaayaThesaurus/concept_relations.gif'
manage_options = (
{'label':'Properties', 'action':'properties_html'},
{'label':'Management', 'action':'concept_relations_html'},
{'label':'Import', 'action':'import_html'},
{'label':'Statistics', 'action':'statistics_html'},
{'label':'Undo', 'action':'manage_UndoForm'},)
security = ClassSecurityInfo()
def __init__(self, id, title):
""" constructor """
self.id = id
self.title = title
self.concept_relations = PersistentMapping()
#basic properties
security.declareProtected(view_management_screens, 'manageBasicProperties')
def manageBasicProperties(self, title='', REQUEST=None):
""" manage basic properties for ConceptRelations """
self.title = title
self._p_changed = 1
if REQUEST:
self.setSessionInfoTrans('Saved changes.')
return REQUEST.RESPONSE.redirect('properties_html')
#concept relations management
def __add_relation(self, concept_id, relation_id, relation_type):
#create a new item
item = ConceptRelationsItem(concept_id, relation_id, relation_type)
self.concept_relations[(concept_id, relation_id, relation_type)] = item
self.catalog.CatalogObject(item)
def __update_relation(self, concept_id, old_concept_id, relation_id,
old_relation_id, relation_type, old_relation_type):
#modify an item
l_old_id = (old_concept_id, old_relation_id, old_relation_type)
item = self.concept_relations.get(l_old_id)
if item is not None:
self.__delete_relation(l_old_id)
self.__add_relation(concept_id, relation_id, relation_type)
def __delete_relation(self, ids):
#delete 1 or more items
if type(ids) != type((1,1)):
ids = th_utils().utConvertToList(ids)
else:
ids = [ids]
collection = self.get_relations()
for id in ids:
self.catalog.UncatalogObject(collection[id])
del collection[id]
#concept relations constraints
security.declareProtected(view_management_screens, 'checkCpRel')
def checkCpRel(self, concept_id):
""" """
if self.getConceptsFolder().get_concept_by_id(concept_id):
return 1
return 0
security.declareProtected(view_management_screens, 'getIdsList')
def getIdsList(self, ids, all=0):
""" """
if all: return self.concept_relations.keys()
return th_utils().getIdsList(ids)
#relations getters
def get_relations(self):
#get all relations
return self.concept_relations
def get_relations_sorted(self):
#get all relations sorted
return th_utils().utSortObjsListByAttr(self.concept_relations.values(), 'concept_id', 0)
def get_relation_by_id(self, id):
#get an item
try: return self.concept_relations[id]
except: return None
def get_relations_item_data(self, concept_id, relation_id, relation_type,
orig_concept_id, orig_relation_id, orig_relation_type):
#get an item data
item = self.get_relation_by_id((orig_concept_id, orig_relation_id, orig_relation_type))
if item is not None:
return ['update', concept_id, relation_id, relation_type,
orig_concept_id, orig_relation_id, orig_relation_type]
else:
return ['add', concept_id, relation_id, relation_type, '', '', '']
#concept relations api
security.declareProtected(view_management_screens, 'manage_add_relation')
def manage_add_relation(self, concept_id='', relation_id='', relation_type='', REQUEST=None):
""" manage relations """
err = 0
if self.checkCpRel(concept_id) and self.checkCpRel(relation_id):
self.__add_relation(concept_id, relation_id, relation_type)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionRelationId(relation_id)
self.setSessionRelationType(relation_type)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
else:
self.setSessionInfoTrans('Record added.')
REQUEST.RESPONSE.redirect('concept_relations_html')
security.declareProtected(view_management_screens, 'manage_update_relation')
def manage_update_relation(self, concept_id='', old_concept_id='', relation_id='',
old_relation_id='', relation_type='', old_relation_type='', REQUEST=None):
""" update relation """
err = 0
if self.checkCpRel(concept_id) and self.checkCpRel(relation_id):
self.__update_relation(concept_id, old_concept_id, relation_id,
old_relation_id, relation_type, old_relation_type)
else:
err = 1
if REQUEST:
if err:
self.setSessionConceptId(concept_id)
self.setSessionRelationId(relation_id)
self.setSessionRelationType(relation_type)
self.setSessionErrorsTrans('${concept_id} is not a valid concept ID.', concept_id=concept_id)
REQUEST.RESPONSE.redirect('concept_relations_html?concept_id=%s&relation_id=%s&relation_type=%s'
% (old_concept_id, old_relation_id, old_relation_type))
else:
self.setSessionInfoTrans('Record updated.')
REQUEST.RESPONSE.redirect('concept_relations_html')
security.declareProtected(view_management_screens, 'manage_delete_relations')
def manage_delete_relations(self, ids=[], delete_all='', REQUEST=None):
""" delete relations """
if delete_all: ids = self.getIdsList(ids, 1)
else: ids = self.getIdsList(ids)
self.__delete_relation(ids)
if REQUEST:
self.setSessionInfoTrans('Selected records deleted.')
REQUEST.RESPONSE.redirect('concept_relations_html')
security.declareProtected(view_management_screens, 'getRelationItemData')
def getRelationItemData(self):
""" return a relation based on its ID """
if self.isSessionConceptId():
concept_id = self.getSessionConceptId()
relation_id = self.getSessionRelationId()
relation_type = self.getSessionRelationType()
orig_concept_id = self.REQUEST.get('concept_id', None)
orig_relation_id = self.REQUEST.get('relation_id', None)
orig_relation_type = self.REQUEST.get('relation_type', None)
else:
concept_id = self.REQUEST.get('concept_id', self.getSessionConceptId())
relation_id = self.REQUEST.get('relation_id', self.getSessionRelationId())
relation_type = self.REQUEST.get('relation_type', self.getSessionRelationType())
orig_concept_id = concept_id
orig_relation_id = relation_id
orig_relation_type = relation_type
self.delSessionConceptId()
self.delSessionRelationId()
self.delSessionRelationType()
return self.get_relations_item_data(concept_id, relation_id, relation_type,
orig_concept_id, orig_relation_id, orig_relation_type)
#import related
def skos_import(self, file, REQUEST=None):
""" """
parser = relation_parser()
#parse the SKOS information
chandler = parser.parseHeader(file)
if chandler is None:
if REQUEST:
self.setSessionErrorsTrans('Parsing error. The file could not be parsed.')
return REQUEST.RESPONSE.redirect('import_html')
#info
count_rel = 0
err_list = []
#set data
for data in chandler.getBody():
concept_id = data['concept_id'].encode('utf-8').split('/')[-1]
relation_id = data['relation_id'].encode('utf-8').split('/')[-1]
relation_type = data['relation_type']
if concept_id:
if self.checkCpRel(concept_id) and self.checkCpRel(relation_id):
self.__add_relation(concept_id, relation_id, relation_type)
count_rel += 1
else:
if not relation_id:
err_list.append(('(${content_id}, None) - relation_id not specified', {'concept_id': concept_id }, ))
else:
err_list.append(('(${concept_id}, ${relation_id}) - at least one of the concept_id or relation_id does not exist',
{'concept_id': concept_id, 'relation_id': relation_id }))
else:
err_list.append('None - concept_id not specified')
if REQUEST:
self.setSessionInfoTrans(['File imported successfully.',
('Translations added: ${count_rel}', {'count_rel': count_rel}, )])
if err_list:
self.setSessionErrorsTrans(['Relations not imported (by its (concept_id, relation_id)):', err_list, ])
return REQUEST.RESPONSE.redirect('import_html')
#relation type related
def getRelTypes(self):
""" """
return RELATION_TYPES
def getRelTypesIDs(self):
""" """
return self.getRelTypes().keys()
def getRelTypeByID(self, id):
""" """
return self.getRelTypes()[id]
#statistics
def getAllConRel(self):
query = [('meta_type',CONCEPT_RELATION_ITEM_METATYPE)]
return self.catalog.searchCatalog(query)
def getConRelNumber(self):
return len(self.getAllConRel())
def getRelationsNumber(self):
results = {}
for conrel_ob in self.getAllConRel():
try: br_count = results[1]
except: br_count = 0
try: nr_count = results[2]
except: nr_count = 0
try: re_count = results[3]
except: re_count = 0
if conrel_ob.relation_type == '1':
results[1] = br_count + 1
elif conrel_ob.relation_type == '2':
results[2] = nr_count + 1
elif conrel_ob.relation_type == '3':
results[3] = re_count + 1
return results
#management tabs
security.declareProtected(view_management_screens, 'properties_html')
properties_html = PageTemplateFile("%s/zpt/ConceptRelations/properties" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'concept_relations_html')
concept_relations_html = PageTemplateFile("%s/zpt/ConceptRelations/concept_relations" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'statistics_html')
statistics_html = PageTemplateFile("%s/zpt/ConceptRelations/statistics" % NAAYATHESAURUS_PATH, globals())
security.declareProtected(view_management_screens, 'import_html')
import_html = PageTemplateFile("%s/zpt/ConceptRelations/import" % NAAYATHESAURUS_PATH, globals())
