def __call__(self):
protect.CheckAuthenticator(self.request)
# Getting values from post
section_name = self.request.get('section_name', None)
if section_name is None:
return None
role_id = self.request.get('role_id', None)
if role_id is None:
return None
check_state = self.request.get('check_state', None)
if check_state is None:
return None
elif check_state == 'false':
check_state = 'no'
else:
check_state = 'yes'
# Update registry
registry_info = get_dashboard_registry_record()
pairs = get_dashboard_panels_visibility_by_section(section_name)
role_permissions = list()
for pair in pairs:
visibility = pair[1]
if pair[0] == role_id:
visibility = check_state
value = '{0},{1}'.format(pair[0], visibility)
role_permissions.append(value)
role_permissions = ','.join(role_permissions)
# Set permissions string into dict
registry_info[section_name] = get_unicode(role_permissions)
set_dashboard_registry_record(registry_info)
return True
def __call__(self):
"""Endpoint for form actions etc.
"""
protect.CheckAuthenticator(self.request.form)
url = self.context.absolute_url()
# only proceed if the form was POSTed
if not self.request.form.get("submitted", False):
return self.request.response.redirect(url)
# only handle one additional path segment to route to a form action
if len(self.traverse_subpath) != 1:
return self.request.response.redirect(url)
# the first path segment is used to determine the endpoint
func_name = self.traverse_subpath[0]
action_name = "action_{}".format(func_name)
action = getattr(self, action_name, None)
if action is None:
logger.warn(
"AttachmentsView.__call__: Unknown action name '{}'".format(
func_name))
return self.request.response.redirect(url)
# call the endpoint
return action()
def __call__(self):
protect.CheckAuthenticator(self.request.form)
self.portal = api.get_portal()
self.request.set('disable_plone.rightcolumn', 1)
self.request.set('disable_border', 1)
# Handle form submit
form = self.request.form
submitted = form.get("submitted", False)
# nothing to do here
if not submitted:
return self.template()
# Handle "Seed" action
if form.get("seed", False):
seeds = form.get("seeds", {})
for key, value in seeds.items():
value = api.to_int(value, None)
message = ""
if value is None:
message = _(
"Could not convert '{}' to an integer".format(value))
elif value == 0:
del self.storage[key]
message = _("Removed key {} from storage".format(key))
else:
self.set_seed(key, value)
message = _("Seeding key {} to {}".format(key, value))
self.add_status_message(message, "info")
return self.template()
def handle_form_submit(self):
"""Handle form submission
"""
protect.CheckAuthenticator(self.request)
logger.info("Handle ResultsInterpration Submit")
# Save the results interpretation
res = self.request.form.get("ResultsInterpretationDepts", [])
self.context.setResultsInterpretationDepts(res)
self.add_status_message(_("Changes Saved"), level="info")
def __call__(self):
protect.CheckAuthenticator(self.request.form)
if len(self.traverse_subpath) != 1:
return self.error("Not found", status=404)
func_name = "ajax_{}".format(self.traverse_subpath[0])
func = getattr(self, func_name, None)
if func is None:
return self.error("Invalid function", status=400)
return func()
def __call__(self):
protect.CheckAuthenticator(self.request)
# Do the search
brains = self.search()
# Generate the data rows to display
data_rows = self.to_data_rows(brains)
# Return the payload
return self.to_json_payload(data_rows)
def __call__(self):
protect.CheckAuthenticator(self.request.form)
self.portal = api.get_portal()
self.request.set('disable_plone.rightcolumn', 1)
self.request.set('disable_border', 1)
# Handle form submit
form = self.request.form
if not form.get("dataform", False):
return self.template()
domain_name = form.get("domain_name", None)
# Handle "Clear this Storage" action
if form.get("clear_storage", False):
del self.storage[domain_name]
delete_soup(self.portal, domain_name)
message = _("Cleared Storage {}".format(domain_name))
self.add_status_message(message, "info")
return self.template()
# Get the necessary data for the domain
storage = self.get_storage(domain_name)
credentials = storage["credentials"]
config = storage["configuration"]
# Handle "Import" action
if form.get("import", False):
step = ImportStep(credentials, config)
# Handle "Update" action
else:
fetch_time = form.get("mod_date_limit", None) or \
storage.get("last_fetch_time", None)
if not fetch_time:
message = 'Cannot get last fetched time, please re-run ' \
'the Fetch step.'
self.add_status_message(message, "error")
return self.template()
if isinstance(fetch_time, str):
try:
fetch_time = DateTime(fetch_time)
except:
message = 'Please enter a valid Date & Time'
self.add_status_message(message, "error")
return self.template()
step = UpdateStep(credentials, config, fetch_time)
step.run()
return self.template()
def handle_form_submit(self):
"""Handle form submission
"""
protect.CheckAuthenticator(self.request)
logger.info("Handle ResultsInterpration Submit")
# Save the results interpretation
res = self.request.form.get("ResultsInterpretationDepts", [])
self.context.setResultsInterpretationDepts(res)
self.add_status_message(_("Changes Saved"), level="info")
# reindex the object after save to update all catalog metadata
self.context.reindexObject()
# notify object edited event
event.notify(ObjectEditedEvent(self.context))
def __call__(self):
protect.CheckAuthenticator(self.request)
searchTerm = self.request.get("searchTerm", "").lower()
page = self.request.get("page", 1)
nr_rows = self.request.get("rows", 20)
sort_order = self.request.get("sord") or "ascending"
sort_index = self.request.get("sidx") or "sortable_title"
if sort_order == "desc":
sort_order = "descending"
# Use the catalog to speed things up and also limit the results
catalog = api.get_tool("portal_catalog")
catalog_query = {
"portal_type": "Client",
"review_state": "active",
"sort_on": sort_index,
"sort_order": sort_order,
"sort_limit": 500
}
# Inject the searchTerm to narrow the results further
if searchTerm:
catalog_query["SearchableText"] = searchTerm
logger.debug("ajaxGetClients::catalog_query=%s" % catalog_query)
brains = catalog(catalog_query)
rows = []
for brain in brains:
client = brain.getObject()
# skip clients where the search term does not match
if searchTerm and not client_match(client, searchTerm):
continue
rows.append({
"ClientID": client.getClientID(),
"Title": client.Title(),
"ClientUID": client.UID(),
})
pages = len(rows) / int(nr_rows)
pages += divmod(len(rows), int(nr_rows))[1] and 1 or 0
ret = {
"page": page,
"total": pages,
"records": len(rows),
"rows":
rows[(int(page) - 1) * int(nr_rows):int(page) * int(nr_rows)]
}
return json.dumps(ret)
def __call__(self):
protect.CheckAuthenticator(self.request.form)
logger.info("**** AUTO SYNC STARTED ****")
self.portal = api.get_portal()
storage = u.get_annotation(self.portal)[SYNC_STORAGE]
for domain_name, values in storage.iteritems():
# Check if Auto-Sync is enabled for this Remote
if not values["configuration"]["auto_sync"]:
continue
logger.info("Updating data with: '{}' ".format(domain_name))
self.request.form["dataform"] = 1
self.request.form["update"] = 1
self.request.form["domain_name"] = domain_name
response = Sync(self.context, self.request)
response()
logger.info("**** AUTO SYNC FINISHED ****")
return "Done..."
def __call__(self):
protect.CheckAuthenticator(self.request.form)
self.portal = api.get_portal()
self.request.set('disable_plone.rightcolumn', 1)
self.request.set('disable_border', 1)
# Handle form submit
form = self.request.form
fetchform = form.get("fetchform", False)
dataform = form.get("dataform", False)
if not any([fetchform, dataform]):
return self.template()
# remember the form field values
url = form.get("url", "")
if not url.startswith("http"):
url = "http://{}".format(url)
self.url = url
self.username = form.get("ac_name", None)
self.password = form.get("ac_password", None)
# Handle "Import" action
if form.get("import", False):
domain = form.get("domain", None)
self.import_registry_records(domain)
self.import_users(domain)
self.import_data(domain)
logger.info("*** END OF DATA IMPORT {} ***".format(domain))
return self.template()
# Handle "Clear this Storage" action
if form.get("clear_storage", False):
domain = form.get("domain", None)
del self.storage[domain]
message = _("Cleared Storage {}".format(domain))
self.add_status_message(message, "info")
return self.template()
# Handle "Clear all Storages" action
if form.get("clear", False):
self.flush_storage()
message = _("Cleared Data Storage")
self.add_status_message(message, "info")
return self.template()
# Handle "Fetch" action
if form.get("fetch", False):
# check if all mandatory fields have values
if not all([self.url, self.username, self.password]):
message = _("Please fill in all required fields")
self.add_status_message(message, "error")
return self.template()
# initialize the session
self.session = self.get_session(self.username, self.password)
# remember the credentials in the storage
storage = self.get_storage(self.url)
storage["credentials"]["username"] = self.username
storage["credentials"]["password"] = self.password
# try to get the version of the remote JSON API
version = self.get_version()
if not version or not version.get('version'):
message = _(
"Please install senaite.jsonapi on the source system")
self.add_status_message(message, "error")
return self.template()
# try to get the current logged in user
user = self.get_authenticated_user()
if not user or user.get("authenticated") is False:
message = _("Wrong username/password")
self.add_status_message(message, "error")
return self.template()
domain = self.url
# Fetch all users from the source
self.fetch_users(domain)
# Start the fetch process beginning from the portal object
self.fetch_data(domain, uid="0")
# Fetch registry records that contain the word bika or senaite
self.fetch_registry_records(domain, keys=["bika", "senaite"])
logger.info("*** FETCHING DATA FINISHED {} ***".format(domain))
# always render the template
return self.template()
def __call__(self):
protect.CheckAuthenticator(self.request.form)
self.portal = api.get_portal()
self.request.set('disable_plone.rightcolumn', 1)
self.request.set('disable_border', 1)
# Handle form submit
form = self.request.form
fetchform = form.get("fetchform", False)
if not fetchform:
return self.template()
self.url = form.get("url", "")
if not self.url.startswith("http"):
self.url = "https://{}".format(self.url)
self.domain_name = form.get("domain_name", None)
self.username = form.get("ac_name", None)
self.password = form.get("ac_password", None)
# check if all mandatory fields have values
if not all([self.domain_name, self.url, self.username, self.password]):
message = _("Please fill in all required fields")
self.add_status_message(message, "error")
return self.template()
self.auto_sync = (form.get("auto_sync") == 'on')
self.import_settings = (form.get("import_settings") == 'on')
self.import_users = (form.get("import_users") == 'on')
self.import_registry = (form.get("import_registry") == 'on')
self.remote_prefix = form.get("remote_prefix", None)
self.local_prefix = form.get("local_prefix", None)
self.full_sync_types = utils.filter_content_types(
form.get("full_sync_types"))
self.unwanted_content_types = utils.filter_content_types(
form.get("unwanted_content_types"))
self.read_only_types = utils.filter_content_types(
form.get("read_only_types"))
self.update_only_types = utils.filter_content_types(
form.get("update_only_types"))
self.prefixable_types = utils.filter_content_types(
form.get("prefixable_types"))
# Prefix Validation
if not self.validate_prefix():
return self.template()
credentials = dict(
url=self.url,
domain_name=self.domain_name,
ac_name=self.username,
ac_password=self.password)
config = dict(
auto_sync=self.auto_sync,
import_settings=self.import_settings,
import_users=self.import_users,
import_registry=self.import_registry,
remote_prefix=self.remote_prefix,
local_prefix=self.local_prefix,
full_sync_types=self.full_sync_types,
unwanted_content_types=self.unwanted_content_types,
read_only_types=self.read_only_types,
update_only_types=self.update_only_types,
prefixable_types=self.prefixable_types,
)
fs = FetchStep(credentials, config)
verified, message = fs.verify()
if verified:
fs.run()
self.add_status_message(message, "info")
else:
self.add_status_message(message, "error")
# render the template
return self.template()
