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()