def index_site(request, autocommit=True):
"""Index all site contents in internal catalog"""
application = site_factory(request)
if application is not None:
try:
set_local_registry(application.getSiteManager())
catalog = get_utility(ICatalog)
catalog.reset()
transaction.savepoint()
intids = get_utility(IIntIds)
for index, document in enumerate(find_objects_providing(application, Interface)):
if INoAutoIndex.providedBy(document):
continue
if IBroken.providedBy(document):
print("Skipping broken object: {0!r}".format(document))
else:
print("Indexing: {0!r}".format(document))
catalog.reindex_doc(intids.register(document), document)
if not index % 100:
transaction.savepoint()
finally:
set_local_registry(None)
if autocommit:
transaction.commit()
return application
def get_oid(self):
"""Get new document OID"""
container = get_utility(IDocumentContainer)
intids = get_utility(IIntIds)
oid = '{}{}'.format(container.oid_prefix or '',
hex(intids.register(self))[2:])
if container.get_document(oid) is not None:
raise DocumentContainerError("Specified OID already exists!")
self.oid = oid
def get_connection_from_settings(settings=None):
"""Load connection matching registry settings"""
if settings is None:
settings = get_utility(ISettings)
for name, uri in get_uris(settings):
zdb = db_from_uri(uri, name, {})
return zdb.open()
def evolve(site):
"""Evolve 1: remove all images thumbnails to free blobs"""
registry = get_local_registry()
try:
medias = set()
set_local_registry(site.getSiteManager())
LOGGER.warning(
"Removing all thumbnails from database to free unused blobs...")
intids = get_utility(IIntIds)
for ref in list(intids.refs.keys()):
obj = intids.queryObject(ref)
if IMediaFile.providedBy(obj):
LOGGER.debug(
">>> removing thumbnails for image {!r}".format(obj))
thumbnails = IThumbnails(obj, None)
if thumbnails is not None:
medias.add(obj)
thumbnails.clear_thumbnails()
LOGGER.warning(
"Thumbnails cleanup is finished. Launch *zeopack* (for ZEO storage) "
"or *zodbpack* (for Relstorage) command to remove all unused blobs."
)
LOGGER.warning("{} images updated".format(len(medias)))
finally:
set_local_registry(registry)
def get_document(oid, version=None, status=None):
"""Get existing document from it's OID"""
if not oid:
return None
catalog = get_utility(ICatalog)
params = Eq(catalog['zfile_oid'], oid)
# check for version or state
index = None
if version: # check for version number or status
try:
index = int(version) # version number
status = None
except ValueError: # status string
index = None
status = version
if index:
params = and_(params, Eq(catalog['workflow_version'], index))
elif status:
params = and_(params, Eq(catalog['workflow_state'], status))
for result in ResultSet(
CatalogQuery(catalog).query(params,
sort_index='workflow_version',
reverse=True)):
if version or status:
return result
return IWorkflowVersions(result).get_last_versions()[0]
return None
def traverse(self, name, furtherpath=None): # pylint: disable=unused-argument
"""Profile traverser"""
if not name:
return IPublicProfile(self.request.principal)
intids = get_utility(IIntIds)
profile = intids.queryObject(int(name))
return IPublicProfile(profile, None)
def run(self, report, **kwargs): # pylint: disable=unused-argument
"""Run SQL query task"""
try:
session = get_user_session(self.session_name, join=False, twophase=False,
use_zope_extension=False)
try:
report.write('SQL query output\n'
'================\n')
report.write('SQL query: \n {}\n\n'.format(
self.query.replace('\r', '').replace('\n', '\n ')))
results = session.execute(self.query)
session.commit()
converter = get_utility(IAlchemyConverter, name=self.output_format)
result = converter.convert(results)
report.write('SQL output ({} records):\n\n'.format(results.rowcount))
report.write(result)
return TASK_STATUS_OK, result
except ResourceClosedError:
report.write('SQL query returned no result.\n')
return TASK_STATUS_EMPTY, None
except SQLAlchemyError:
session.rollback()
etype, value, tb = sys.exc_info() # pylint: disable=invalid-name
report.write('\n\n'
'An SQL error occurred\n'
'=====================\n')
report.write(''.join(traceback.format_exception(etype, value, tb)))
return TASK_STATUS_ERROR, None
def find_documents(request):
"""Find documents matching specified properties"""
properties = request.params.copy(
) if TEST_MODE else request.validated.copy()
fields = properties.pop('fields', None)
container = get_utility(IDocumentContainer)
return list(
map(lambda x: x.to_json(fields), container.find_documents(properties)))
def public_profile_callback(profile):
"""Public profile creation callback"""
request = get_current_request()
if request is not None:
root = request.root
intids = get_utility(IIntIds)
locate(profile, root) # avoid NotYet exception
locate(profile, root, '++profile++{0}'.format(intids.register(profile)))
def remove_blob_reference(self):
"""Remove reference to internal blob
Blob is deleted if there is no more reference to it.
"""
if self._blob is not None:
references = get_utility(IBlobReferenceManager)
references.drop_reference(self._blob, self)
self._blob = None
def publication(self):
"""Publication label used to display workflow publication state"""
request = check_request()
translate = request.localizer.translate
sm = get_utility(ISecurityManager) # pylint: disable=invalid-name
return translate(_('{date} by {principal}')).format(
date=format_datetime(tztime(
IWorkflowPublicationInfo(self).publication_date),
request=request),
principal=translate(sm.get_principal(self.publisher).title))
def mutate(self, info, **properties): # pylint: disable=no-self-use
"""Create new document"""
request = info.context
container = get_utility(IDocumentContainer)
if not request.has_permission(CREATE_DOCUMENT_PERMISSION,
context=container):
raise HTTPForbidden()
data = base64.b64decode(properties.pop('data', None))
document = container.add_document(data, properties, request=request)
return CreateDocument(document=document.to_json())
def evolve(site):
"""Evolve 2: create reference for all files blobs"""
registry = get_local_registry()
try:
files = set()
set_local_registry(site.getSiteManager())
LOGGER.warning("Creating references to all blobs...")
intids = get_utility(IIntIds)
references = get_utility(IBlobReferenceManager)
for ref in list(intids.refs.keys()):
obj = intids.queryObject(ref)
if IFile.providedBy(obj):
blob = getattr(obj, '_blob', None)
if blob is not None:
references.add_reference(blob, obj)
LOGGER.debug(">>> updated blob reference for file {!r}".format(obj))
LOGGER.warning("{} files updated".format(len(files)))
finally:
set_local_registry(registry)
def password(self, value):
"""Encode password before storing new value"""
if value:
if value == '*****':
return
self._password_salt = urandom(4)
manager = get_utility(IPasswordManager, name='SSHA')
self._password = manager.encodePassword(value,
salt=self._password_salt)
else:
self._password = None
def resolve_data(self, info, oid, version=None, status=None): # pylint: disable=no-self-use
"""Resolve document data"""
container = get_utility(IDocumentContainer)
document = container.get_document(oid, version, status)
if document is None:
raise HTTPNotFound()
request = info.context
if not request.has_permission(READ_DOCUMENT_PERMISSION,
context=document):
raise HTTPForbidden()
return base64.b64encode(document.data.data).decode()
def resolve_document(self, info, oid, version=None, status=None): # pylint: disable=no-self-use
"""Resolve document properties"""
container = get_utility(IDocumentContainer)
document = container.get_document(oid, version, status)
if document is None:
raise HTTPNotFound()
request = info.context
if not request.has_permission(READ_DOCUMENT_PERMISSION,
context=document):
raise HTTPForbidden()
return document.to_json(request=request)
def set_file_properties(request, oid, properties, version=None):
"""Set document properties"""
container = get_utility(IDocumentContainer)
document = container.update_document(oid,
version,
properties=properties,
request=request)
if document is None:
return None
state = IWorkflowState(document)
return {'version': state.version_id}
def synchronize(request, imported=None, deleted=None):
"""Synchronize documents to remote container"""
container = get_utility(IDocumentContainer)
synchronizer = IDocumentSynchronizer(container)
if not synchronizer.target:
raise HTTPServiceUnavailable()
result = {}
for oid in (imported or ()):
result[oid] = synchronizer.synchronize(oid, IMPORT_MODE, request) # pylint: disable=assignment-from-no-return
for oid in (deleted or ()):
result[oid] = synchronizer.synchronize(oid, DELETE_MODE, request) # pylint: disable=assignment-from-no-return
return result
def import_file(request, oid, data, properties):
"""Import document from outer ZFiles database through RPC"""
container = get_utility(IDocumentContainer)
if not request.has_permission(CREATE_DOCUMENT_WITH_OWNER_PERMISSION,
context=container):
raise HTTPForbidden()
if isinstance(data, Binary):
data = data.data
else:
data = base64.b64decode(data)
document = container.import_document(oid, data, properties, request)
return document.oid
def upload_file(request, data, properties):
"""Create new document through RPC"""
container = get_utility(IDocumentContainer)
if not request.has_permission(CREATE_DOCUMENT_PERMISSION,
context=container):
raise HTTPForbidden()
if isinstance(data, Binary):
data = data.data
else:
data = base64.b64decode(data)
document = container.add_document(data, properties, request)
return document.oid
def authenticate(self, credentials, request): # pylint: disable=unused-argument
"""Try to authenticate principal using given credentials"""
if not (self.enabled and self.password):
return None
attrs = credentials.attributes
login = attrs.get('login')
password = attrs.get('password')
manager = get_utility(IPasswordManager, name='SSHA')
if login == self.login and manager.checkPassword(
self.password, password):
return "{0}:{1}".format(self.prefix, login)
return None
def set_file_data(request, oid, data, properties=None, version=None):
"""Set document data"""
container = get_utility(IDocumentContainer)
if isinstance(data, Binary):
data = data.data
else:
data = base64.b64decode(data)
document = container.update_document(oid, version, data, properties,
request)
if document is None:
return None
state = IWorkflowState(document)
return {'version': state.version_id}
def password(self, value):
"""Encode and set user password"""
if value:
if value == '*****':
return
self._password_salt = urandom(SALT_SIZE.get(self.password_manager, 4))
manager = get_utility(IPasswordManager, name=self.password_manager)
if self.password_manager == 'Plain Text':
self._password = manager.encodePassword(value)
else:
self._password = manager.encodePassword(value, salt=self._password_salt)
else:
self._password = None
def get_document(request,
oid,
version=None,
status=None,
permission=READ_DOCUMENT_PERMISSION):
"""Get document matching given OID and version"""
container = get_utility(IDocumentContainer)
document = container.get_document(oid, version, status)
if document is None:
raise HTTPNotFound()
if permission and not request.has_permission(permission, context=document):
raise HTTPForbidden()
return document
def schedule_mode(self, value):
"""Scheduler mode setter"""
if self._schedule_mode is not None:
mode = query_utility(ITaskSchedulingMode, name=self._schedule_mode)
if (mode is not None) and mode.marker_interface.providedBy(self):
noLongerProvides(self, mode.marker_interface)
self._schedule_mode = value
if value:
mode = get_utility(ITaskSchedulingMode, name=value)
alsoProvides(self, mode.marker_interface)
mode.schema(self).active = False
if self.__parent__ is not None:
self.reset()
def patch_document(request):
"""Update existing document properties, excluding file data"""
oid, version = get_ids(request)
container = get_utility(IDocumentContainer)
properties = request.params.copy(
) if TEST_MODE else request.validated.copy()
document = container.update_document(oid,
version,
properties=properties,
request=request)
if document is None:
return {'oid': oid, 'status': 'deleted'}
return document.to_json()
def get_document(request):
"""Retrieve existing document information"""
container = get_utility(IDocumentContainer)
document = container.get_document(*get_ids(request))
if document is None:
raise HTTPNotFound()
if not request.has_permission(READ_DOCUMENT_PERMISSION, context=document):
raise HTTPForbidden()
fields = request.params.get(
'fields') if TEST_MODE else request.validated.get('fields')
if isinstance(fields, str):
fields = set(fields.split(';'))
return document.to_json(fields)
def _get_viewlets(self):
viewlets = []
content = get_parent(self.context, IWorkflowManagedContent)
wf = get_utility(IWorkflow, name=content.workflow_name) # pylint: disable=invalid-name
if wf is None:
return viewlets
info = IWorkflowInfo(self.context)
for transition_id in info.get_manual_transition_ids():
transition = wf.get_transition_by_id(transition_id)
menu = TransitionMenuItem(self.context, self.request, self.view,
self, transition)
viewlets.append((transition_id, menu))
return sorted(viewlets, key=lambda x: x[1].weight)
def get_target(self):
"""Chat message targets getter"""
principals = {ADMIN_USER_ID}
root = self.context.request.root
protection = IProtectedObject(root, None)
if protection is not None:
principals |= protection.get_principals(SYSTEM_ADMIN_ROLE)
scheduler = get_utility(IScheduler)
protection = IProtectedObject(scheduler, None)
if protection is not None:
principals |= protection.get_principals(SCHEDULER_MANAGER_ROLE)
principals |= protection.get_principals(TASKS_MANAGER_ROLE)
return {
'principals': tuple(principals)
}
def put_document(request):
"""Update existing document content"""
oid, version = get_ids(request)
container = get_utility(IDocumentContainer)
properties = request.params.copy(
) if TEST_MODE else request.validated.copy()
if request.headers.get('Content-Type').startswith('multipart/form-data'):
properties['data'] = request.params.get('data')
else:
properties['data'] = base64.b64decode(request.json.get('data'))
data = properties.pop('data')
document = container.update_document(oid, version, data, properties,
request)
if document is None:
return {'oid': oid, 'status': 'deleted'}
return document.to_json()
