def build_template(request, template_id): """View that allows to build the Template. Args: request: template_id: Returns: """ if template_id == "new": base_template_path = finders.find( join("core_composer_app", "user", "xsd", "new_base_template.xsd") ) xsd_string = read_file_content(base_template_path) else: template = template_api.get(template_id, request=request) xsd_string = template.content request.session["newXmlTemplateCompose"] = xsd_string request.session["includedTypesCompose"] = [] # store the current includes/imports xsd_tree = XSDTree.build_tree(xsd_string) includes = xsd_tree.findall("{}include".format(LXML_SCHEMA_NAMESPACE)) for el_include in includes: if "schemaLocation" in el_include.attrib: request.session["includedTypesCompose"].append( el_include.attrib["schemaLocation"] ) imports = xsd_tree.findall("{}import".format(LXML_SCHEMA_NAMESPACE)) for el_import in imports: if "schemaLocation" in el_import.attrib: request.session["includedTypesCompose"].append( el_import.attrib["schemaLocation"] ) # remove annotations from the tree remove_annotations(xsd_tree) xsd_string = XSDTree.tostring(xsd_tree) # loads XSLT xslt_path = finders.find(join("core_composer_app", "user", "xsl", "xsd2html.xsl")) # reads XSLT xslt_string = read_file_content(xslt_path) # transform XML to HTML xsd_to_html_string = xsl_transform(xsd_string, xslt_string) # 1) Get user defined types user_types = type_version_manager_api.get_version_managers_by_user(request=request) # 2) Get buckets buckets = bucket_api.get_all() # 3) no_buckets_types: list of types that are not assigned to a specific bucket no_buckets_types = type_version_manager_api.get_no_buckets_types(request=request) # 4) Build list of built-in types built_in_types = [] for built_in_type in get_xsd_types(): built_in_types.append({"current": "built_in_type", "title": built_in_type}) assets = { "js": [ {"path": "core_composer_app/user/js/build_template.js", "is_raw": False}, {"path": "core_composer_app/user/js/build_template.raw.js", "is_raw": True}, {"path": "core_composer_app/user/js/xpath.js", "is_raw": False}, {"path": "core_composer_app/user/js/menus.js", "is_raw": False}, {"path": "core_composer_app/user/js/xsd_tree.js", "is_raw": False}, ], "css": [ "core_main_app/common/css/XMLTree.css", "core_composer_app/common/css/bucket.css", "core_composer_app/user/css/menu.css", "core_composer_app/user/css/style.css", "core_composer_app/user/css/xsd_tree.css", ], } context = { "buckets": buckets, "built_in_types": built_in_types, "no_buckets_types": no_buckets_types, "user_types": user_types, "xsd_form": xsd_to_html_string, "template_id": template_id, } modals = [ "core_composer_app/user/builder/menus/sequence.html", "core_composer_app/user/builder/menus/element.html", "core_composer_app/user/builder/menus/element_root.html", "core_composer_app/user/builder/modals/root_type_name.html", "core_composer_app/user/builder/modals/element_name.html", "core_composer_app/user/builder/modals/insert_element.html", "core_composer_app/user/builder/modals/delete_element.html", "core_composer_app/user/builder/modals/change_type.html", "core_composer_app/user/builder/modals/save_template.html", "core_composer_app/user/builder/modals/save_type.html", "core_composer_app/user/builder/modals/save_success.html", "core_composer_app/user/builder/modals/occurrences.html", "core_composer_app/user/builder/modals/errors.html", ] return render( request, "core_composer_app/user/build_template.html", assets=assets, context=context, modals=modals, )
def core_explore_tree_index(request): """ Page that allows to see the exploration tree. Args: request: Returns: """ context = {} error = None try: # get the active ontology active_ontology = query_ontology_api.get_active() # get the navigation from the cache nav_key = active_ontology.id if nav_key in navigation_cache: navigation = navigation_cache.get(nav_key) else: # create the navigation navigation = create_navigation_tree_from_owl_file(active_ontology.content) navigation_cache.set(nav_key, navigation) # get the tree from the cache tree_key = navigation.id if tree_key in html_tree_cache: html_tree = html_tree_cache.get(tree_key) else: # create the html tree html_tree = render_navigation_tree(navigation, active_ontology.template.id) html_tree_cache.set(tree_key, html_tree) context = { 'navigation_tree': html_tree, 'navigation_id': navigation.id } except exceptions.DoesNotExist: error = {"error": "An Ontology should be active to explore. Please contact an admin."} except Exception: error = {"error": "An error occurred during the generation of the navigation tree."} if error: context.update(error) assets = { "js": [ { "path": 'core_explore_tree_app/user/js/load_view.js', "is_raw": False }, { "path": 'core_explore_tree_app/user/js/tree.js', "is_raw": True }, { "path": 'core_explore_tree_app/user/js/resize_tree_panel.js', "is_raw": True }, { "path": 'core_explore_tree_app/user/js/mock.js', "is_raw": True }, ], "css": ['core_explore_tree_app/user/css/tree.css', 'core_explore_tree_app/user/css/loading_background.css'] } modals = ['core_explore_tree_app/user/navigation/download_options.html'] return render(request, 'core_explore_tree_app/user/navigation/explore_tree_wrapper.html', assets=assets, modals=modals, context=context)
def get(self, request, template_id, query_id=None): """Page that allows to build and submit queries Args: request: template_id: query_id: Returns: """ try: template = template_api.get(template_id) if template is None: return render(request, 'core_explore_example_app/user/errors.html', assets={}, context={ 'errors': "The selected {0} does not exist".format( self.object_name) }) # Init variables saved_query_form = "" try: explore_data_structure = explore_data_structure_api.get_by_user_id_and_template_id( str(request.user.id), template_id) # If custom fields form present, set it custom_form = explore_data_structure.selected_fields_html_tree except exceptions.DoesNotExist: custom_form = None # If new form if query_id is None: # empty session variables request.session['mapCriteriaExplore'] = dict() request.session['savedQueryFormExplore'] = "" # create new query object query = self._create_new_query(request, template) else: # if not a new form and a query form is present in session if 'savedQueryFormExplore' in request.session: saved_query_form = request.session['savedQueryFormExplore'] query = query_api.get_by_id(query_id) # Get saved queries of a user if '_auth_user_id' in request.session: user_id = request.session['_auth_user_id'] user_queries = saved_query_api.get_all_by_user_and_template( user_id=user_id, template_id=template_id) else: user_queries = [] assets = {"js": self._get_js(), "css": self._get_css()} context = { 'queries': user_queries, 'template_id': template_id, 'description': self.get_description(), 'title': self.get_title(), 'custom_form': custom_form, 'query_form': saved_query_form, 'query_id': str(query.id), "build_query_url": self.build_query_url, "results_url": self.results_url, "get_query_url": self.get_query_url, "save_query_url": self.save_query_url, "select_fields_url": self.select_fields_url, "data_sources_selector_template": self.data_sources_selector_template, "query_builder_interface": self.query_builder_interface } modals = [ "core_explore_example_app/user/modals/custom_tree.html", "core_explore_example_app/user/modals/sub_elements_query_builder.html", "core_main_app/common/modals/error_page_modal.html", "core_explore_example_app/user/modals/delete_all_queries.html", "core_explore_example_app/user/modals/delete_query.html" ] return render(request, 'core_explore_example_app/user/build_query.html', assets=assets, context=context, modals=modals) except Exception, e: return render(request, 'core_explore_example_app/user/errors.html', assets={}, context={'errors': e.message})
def get(self, request, template_id, query_id): """Query results view Args: request: template_id: query_id: Returns: """ context = { 'template_id': template_id, 'query_id': query_id, 'exporter_app': False, 'back_to_query_redirect': self.back_to_query_redirect, 'get_shareable_link_url': reverse("core_explore_example_get_persistent_query_url") } assets = { "js": [ { "path": 'core_explore_common_app/user/js/results.js', "is_raw": False }, { "path": 'core_explore_common_app/user/js/results.raw.js', "is_raw": True }, { "path": 'core_main_app/common/js/XMLTree.js', "is_raw": False }, { "path": 'core_main_app/common/js/modals/error_page_modal.js', "is_raw": True }, { "path": 'core_explore_common_app/user/js/button_persistent_query.js', "is_raw": False }, ], "css": [ "core_explore_common_app/user/css/query_result.css", "core_main_app/common/css/XMLTree.css", "core_explore_common_app/user/css/results.css" ], } modals = [ "core_main_app/common/modals/error_page_modal.html", "core_explore_common_app/user/persistent_query/modals/persistent_query_modal.html" ] if 'core_exporters_app' in INSTALLED_APPS: # add all assets needed assets['js'].extend([{ "path": 'core_exporters_app/user/js/exporters/list/modals/list_exporters_selector.js', "is_raw": False }]) # add the modal modals.extend([ "core_exporters_app/user/exporters/list/modals/list_exporters_selector.html" ]) # the modal need all selected template query = query_api.get_by_id(query_id) context['exporter_app'] = True context['templates_list'] = json.dumps( [str(template.id) for template in query.templates]) return render(request, 'core_explore_example_app/user/results.html', assets=assets, modals=modals, context=context)
def get(self, request, curate_data_structure_id, reload_unsaved_changes=False): """Load view to enter data. Args: request: curate_data_structure_id: reload_unsaved_changes: Returns: """ curate_data_structure = None try: # Retrieve CurateDataStructure and lock the object for the current # user. curate_data_structure = _get_curate_data_structure_by_id( curate_data_structure_id, request) # Lock from database if curate_data_structure.data is not None: lock_api.set_lock_object(curate_data_structure.data, request.user) # Check if we need to change the user. Code executed only if the # data is unlocked. set_lock_object() raises LockError. if str(request.user.id) != curate_data_structure.user: curate_data_structure.user = str(request.user.id) curate_data_structure = curate_data_structure_api.upsert( curate_data_structure, request.user) return render( request, "core_curate_app/user/data-entry/enter_data.html", assets=self.assets, context=self.build_context(request, curate_data_structure, reload_unsaved_changes), modals=self.modals, ) except (LockError, AccessControlError, ModelError, DoesNotExist) as ex: return render( request, "core_curate_app/user/errors.html", assets={}, context={"errors": str(ex)}, ) except Exception as e: try: # Unlock from database if (curate_data_structure is not None and curate_data_structure.data is not None): lock_api.remove_lock_on_object(curate_data_structure.data, request.user) except Exception as lock_exc: # CurateDataStructure not found, continue search logger.warning( "'EnterDataView.get' threw an exception: {0}".format( str(lock_exc))) return render( request, "core_curate_app/user/errors.html", assets={}, context={"errors": str(e)}, )
def get(self, request, template_id, *args, **kwargs): """Loads view to customize exploration tree Args: request: template_id: Returns: """ try: # Set the assets assets = { "js": [ { "path": 'core_main_app/common/js/XMLTree.js', "is_raw": False }, { "path": "core_parser_app/js/autosave.js", "is_raw": False }, { "path": "core_parser_app/js/autosave_checkbox.js", "is_raw": False }, { "path": "core_parser_app/js/autosave.raw.js", "is_raw": True }, { "path": "core_parser_app/js/buttons.js", "is_raw": False }, { "path": "core_explore_example_app/user/js/buttons.raw.js", "is_raw": True }, { "path": "core_parser_app/js/modules.js", "is_raw": False }, { "path": "core_parser_app/js/choice.js", "is_raw": False }, { "path": "core_explore_example_app/user/js/choice.raw.js", "is_raw": True }, { "path": "core_explore_example_app/user/js/select_fields.js", "is_raw": False }, { "path": "core_explore_example_app/user/js/select_fields.raw.js", "is_raw": True }, ], "css": [ 'core_explore_example_app/user/css/xsd_form.css', 'core_explore_example_app/user/css/style.css' ] } template = template_api.get(template_id) # get data structure data_structure = explore_data_structure_api.create_and_get_explore_data_structure( template, request.user.id) root_element = data_structure.data_structure_element_root # renders the form xsd_form = render_form(request, root_element) # Set the context context = { "template_id": template_id, "build_query_url": self.build_query_url, "load_form_url": self.load_form_url, "generate_element_url": self.generate_element_url, "remove_element_url": self.remove_element_url, "generate_choice_url": self.generate_choice_url, "data_structure_id": str(data_structure.id), "xsd_form": xsd_form } return render(request, 'core_explore_example_app/user/select_fields.html', assets=assets, context=context) except Exception, e: return render(request, 'core_explore_example_app/user/errors.html', assets={}, context={'errors': e.message})
def choose_query(request): """ Select a query from the one into the database to be able to use it. Used by the user. If there is no query into the database, an error message is shown to the user. If no query has been selected, an error message is shown to the user. Send to the query_step if a query has been selected. If history queries are available, they are show with the following option: _History deletion _History recovery Args: request: Returns: """ formset = None formset_history = None history_queries = None # Come back from the form with the query selected if request.method == 'POST': # Get the forms variable query_id = request.POST.get('query', None) to_recover = request.POST.get('to_recover', None) number_forms = request.POST.get('form-TOTAL_FORMS', None) # if a variable is none, come back with an error message if query_id is None and to_recover is None and number_forms is None: messages.add_message(request, messages.INFO, "You have to select a query.") else: if query_id is not None: return redirect( reverse("core_custom_queries_app_steps", kwargs={'query_id': query_id})) # History selected elif to_recover is not None and to_recover != '': return redirect( reverse("core_custom_queries_app_recover_steps", kwargs={'history_id': to_recover})) # Delete history query else: number_forms = int(number_forms) formset_history = formset_factory(FormHistory, extra=number_forms, can_delete=True) formset = formset_history(request.POST, request.FILES) if formset.is_valid(): if len(formset.deleted_forms) == 0: messages.add_message(request, messages.ERROR, "Please select a query first.") for form in formset.deleted_forms: data = form.cleaned_data if 'DELETE' in data: id_history = ObjectId(data['id_history']) history = history_query_api.get_by_id(id_history) temp_query_id = history.query_id query = temp_user_query_api.get_by_id( temp_query_id) query.delete_database() messages.add_message(request, messages.SUCCESS, "Queries successfully deleted.") # Create the query form from the ones into the database id_list = list() # Get the available templates available_template_version_managers = template_version_manager_api.get_active_global_version_manager( ) for available_template_version_manager in available_template_version_managers: for available_template_id in available_template_version_manager.versions: id_list.append(str(available_template_id)) # Get the queries available for the current user if request.user.is_staff: # FIXME: call specialized api queries = dyn_query_api.get_all().filter( schema__in=id_list).values_list('pk', 'name') else: # FIXME: call specialized api queries = dyn_query_api.get_all().filter(schema__in=id_list).filter( group='user').values_list('pk', 'name') number_queries = len(queries) form = None if number_queries != 0: form = FormChooseQuery(query=queries) else: # If no query available, set an error message message = "No query available." messages.add_message(request, messages.ERROR, message) try: # If histories exist load them history_queries = history_query_api.get_all_by_user_id( str(request.user.id)) number_history = len(history_queries) except Exception: number_history = 0 if number_history > 0: # Create the formset with the histories values formset_history = formset_factory(FormHistory, extra=number_history, can_delete=True) data = dict() data['form-TOTAL_FORMS'] = number_history data['form-INITIAL_FORMS'] = number_history data['form-MAX_NUM_FORMS'] = number_history position = 0 for history_query in history_queries: try: query_id = str(history_query.query_id) data['form-' + str(position) + '-id_history'] = str( history_query.id) query = temp_user_query_api.get_by_id(query_id) data['form-' + str(position) + '-query_name'] = query.query.name data['form-' + str(position) + '-query_last_modified'] = query.last_modified h_message = history_query.message if h_message == "Pending.": redis_server = Redis.from_url(REDIS_URL) try: if redis_server.exists("current_id"): current_id = redis_server.get( "current_id").decode() if current_id == query_id: h_message = "Pending: The file creation will begin shortly." if redis_server.exists("list_ids"): list_id = redis_server.lrange('list_ids', 0, -1) try: position_id = list_id.index(query_id) + 1 h_message = "Pending - Waiting list: " + str( position_id) + "/" + str(len(list_id)) except ValueError as e: logger.warning( "choose_query threw an exception: {0}". format(str(e))) except ConnectionError as e: log_file = LogFile( application="Custom Queries", message="Redis not reachable, is it running?", additionalInformation={'message': str(e)}, timestamp=datetime.now()) log_file_api.upsert(log_file) data['form-' + str(position) + '-query_message'] = h_message data['form-' + str(position) + '-status'] = history_query.status data['form-' + str(position) + '-DELETE'] = '' position += 1 except DoesNotExist as e: logger.warning("choose_query threw an exception: {0}".format( str(e))) formset = formset_history(data) context = { 'number_queries': number_queries, 'number_history': number_history, 'form': form, 'formset': formset, 'formset_history': formset_history } assets = { "js": [ { "path": 'core_custom_queries_app/user/js/custom_queries.js', "is_raw": False }, ], } return render(request, 'core_custom_queries_app/user/select_query.html', assets=assets, context=context)
def default_custom_login(request): """ Default custom login page. Parameters: request: Returns: """ def _login_redirect(to_page): if to_page is not None and to_page != "": return redirect(to_page) return redirect(reverse("core_main_app_homepage")) if request.method == "POST": username = request.POST["username"] password = request.POST["password"] next_page = request.POST["next_page"] try: user = authenticate(username=username, password=password) if not user.is_active: return render(request, "core_main_app/user/login.html", context={ 'login_form': LoginForm(initial={'next_page': next_page}), 'login_locked': True, 'with_website_features': "core_website_app" in INSTALLED_APPS }) login(request, user) return _login_redirect(next_page) except Exception as e: return render(request, "core_main_app/user/login.html", context={ 'login_form': LoginForm(initial={'next_page': next_page}), 'login_error': True, 'with_website_features': "core_website_app" in INSTALLED_APPS }) elif request.method == "GET": if request.user.is_authenticated(): return redirect(reverse("core_main_app_homepage")) next_page = None if "next" in request.GET: next_page = request.GET["next"] # build the context context = { 'login_form': LoginForm(initial={"next_page": next_page}), 'with_website_features': "core_website_app" in INSTALLED_APPS } assets = {"css": ["core_main_app/user/css/login/login.css"]} # get the web page login if exist web_page_login = web_page_login_api.get() if web_page_login: # update the context context["login_message"] = web_page_login.content # if exist we build assets and modals collection assets.update({ "js": [{ "path": 'core_main_app/user/js/web_page_login/web_page_login.js', "is_raw": False }] }) modals = [ "core_main_app/user/web_page_login/modals/web_page_login_modal.html" ] # render the page with context, assets and modals return render(request, "core_main_app/user/login.html", context=context, assets=assets, modals=modals) # render the page with context, assets return render(request, "core_main_app/user/login.html", context=context, assets=assets) else: return HttpResponse(status=HTTP_405_METHOD_NOT_ALLOWED)
def get(self, request, template_id, query_id=None): """Page that allows to build and submit queries Args: request: template_id: query_id: Returns: """ try: template = template_api.get(template_id, request=request) if template is None: return render( request, "core_explore_example_app/user/errors.html", assets={}, context={ "errors": "The selected {0} does not exist".format( self.object_name) }, ) # Init variables saved_query_form = "" try: explore_data_structure = ( explore_data_structure_api.get_by_user_id_and_template_id( str(request.user.id), template_id)) # If custom fields form present, set it custom_form = explore_data_structure.selected_fields_html_tree except exceptions.DoesNotExist: custom_form = None # If new form if query_id is None: # empty session variables request.session["mapCriteriaExplore"] = dict() request.session["savedQueryFormExplore"] = "" # create new query object query = self._create_new_query(request, template) else: # if not a new form and a query form is present in session if "savedQueryFormExplore" in request.session: saved_query_form = request.session["savedQueryFormExplore"] query = query_api.get_by_id(query_id, request.user) # Get saved queries of a user if "_auth_user_id" in request.session: user_id = request.session["_auth_user_id"] user_queries = saved_query_api.get_all_by_user_and_template( user_id=user_id, template_id=template_id) else: user_queries = [] assets = {"js": self._get_js(), "css": self._get_css()} context = { "queries": user_queries, "template_id": template_id, "description": self.get_description(), "title": self.get_title(), "data_sorting_fields": build_sorting_context_array(query), "default_data_sorting_fields": ",".join(DATA_SORTING_FIELDS), "custom_form": custom_form, "query_form": saved_query_form, "query_id": str(query.id), "build_query_url": self.build_query_url, "results_url": self.results_url, "get_query_url": self.get_query_url, "save_query_url": self.save_query_url, "select_fields_url": self.select_fields_url, "data_sources_selector_template": self.data_sources_selector_template, "query_builder_interface": self.query_builder_interface, } modals = [ "core_explore_example_app/user/modals/custom_tree.html", "core_explore_example_app/user/modals/sub_elements_query_builder.html", "core_main_app/common/modals/error_page_modal.html", "core_explore_example_app/user/modals/delete_all_queries.html", "core_explore_example_app/user/modals/delete_query.html", ] return render( request, "core_explore_example_app/user/build_query.html", assets=assets, context=context, modals=modals, ) except Exception as e: return render( request, "core_explore_example_app/user/errors.html", assets={}, context={"errors": str(e)}, )
class EnterDataView(View): def __init__(self): super(EnterDataView, self).__init__() self.assets = { "js": [ { "path": "core_curate_app/user/js/enter_data.js", "is_raw": False }, { "path": "core_curate_app/user/js/enter_data.raw.js", "is_raw": True }, { "path": "core_parser_app/js/modules.js", "is_raw": False }, { "path": "core_parser_app/js/modules.raw.js", "is_raw": True }, { "path": 'core_main_app/common/js/XMLTree.js', "is_raw": False }, { "path": "core_parser_app/js/autosave.js", "is_raw": False }, { "path": "core_parser_app/js/autosave.raw.js", "is_raw": True }, { "path": "core_parser_app/js/buttons.js", "is_raw": False }, { "path": "core_curate_app/user/js/buttons.raw.js", "is_raw": True }, { "path": "core_parser_app/js/choice.js", "is_raw": False }, { "path": "core_curate_app/user/js/choice.raw.js", "is_raw": True }, ], "css": [ 'core_curate_app/user/css/xsd_form.css', 'core_parser_app/css/use.css' ] } self.modals = [ 'core_curate_app/user/data-entry/modals/cancel-changes.html', 'core_curate_app/user/data-entry/modals/cancel-form.html', 'core_curate_app/user/data-entry/modals/clear-fields.html', 'core_curate_app/user/data-entry/modals/download-options.html', 'core_curate_app/user/data-entry/modals/save-form.html', 'core_curate_app/user/data-entry/modals/use-validation.html', 'core_curate_app/user/data-entry/modals/xml-error.html', 'core_curate_app/user/data-entry/modals/xml-valid.html', ] def build_context(self, request, curate_data_structure, reload_unsaved_changes): """ Build the context of the view Args: request: curate_data_structure: reload_unsaved_changes: Returns: """ # get xsd string from the template xsd_string = curate_data_structure.template.content if reload_unsaved_changes: # get root element from the data structure root_element = curate_data_structure.data_structure_element_root else: # if form string provided, use it to generate the form xml_string = curate_data_structure.form_string # get the root element root_element = generate_form(xsd_string, xml_string) # save the root element in the data structure curate_data_structure_api.update_data_structure_root( curate_data_structure, root_element) # renders the form xsd_form = render_form(request, root_element) return { "edit": True if curate_data_structure.data is not None else False, "xsd_form": xsd_form, "data_structure": curate_data_structure, } @method_decorator( decorators.permission_required( content_type=rights.curate_content_type, permission=rights.curate_access, login_url=reverse_lazy("core_main_app_login"))) def get(self, request, curate_data_structure_id, reload_unsaved_changes=False): """Load view to enter data. Args: request: curate_data_structure_id: reload_unsaved_changes: Returns: """ try: # get data structure curate_data_structure = _get_curate_data_structure_by_id( curate_data_structure_id, request) # lock from database if curate_data_structure.data is not None: lock_api.set_lock_object(curate_data_structure.data, request.user) # Check if we need to change the user. # Code executed only if the data is unlocked. set_lock_object() raises LockError. if str(request.user.id) != curate_data_structure.user: curate_data_structure.user = str(request.user.id) curate_data_structure = curate_data_structure_api.upsert( curate_data_structure) # Set the context context = self.build_context(request, curate_data_structure, reload_unsaved_changes) return render(request, 'core_curate_app/user/data-entry/enter_data.html', assets=self.assets, context=context, modals=self.modals) except LockError, ler: return render(request, 'core_curate_app/user/errors.html', assets={}, context={'errors': ler.message}) except Exception, e: try: # unlock from database if curate_data_structure is not None and curate_data_structure.data is not None: lock_api.remove_lock_on_object(curate_data_structure.data, request.user) except: pass return render(request, 'core_curate_app/user/errors.html', assets={}, context={'errors': e.message})
def common_render(self, request, template_name, modals=None, assets=None, context=None): return admin_render(request, template_name, modals, assets, context) if self.administration \ else render(request, template_name, modals, assets, context)
'form': form, 'formset': formset, 'formset_history': formset_history } assets = { "js": [ { "path": 'core_custom_queries_app/user/js/custom_queries.js', "is_raw": False }, ], } return render(request, 'core_custom_queries_app/user/select_query.html', assets=assets, context=context) @decorators.permission_required( content_type=rights.custom_queries_content_type, permission=rights.custom_queries_access, login_url=reverse_lazy("core_main_app_login")) def query_steps(request, query_id): """ Manage each step of the query. Create the query step in function of the step type. Validate the user choices and store each step to the query history. The last step validation store the query to the database to explore the files and get the data. Args:
def sandbox_view(request, pk): """Loads view to customize sandbox tree Args: request: pk: template id Returns: """ try: # Set the assets assets = { "js": [ { "path": 'core_main_app/common/js/XMLTree.js', "is_raw": False }, { "path": "core_parser_app/js/autosave.js", "is_raw": False }, { "path": "core_parser_app/js/autosave_checkbox.js", "is_raw": False }, { "path": "core_parser_app/js/autosave.raw.js", "is_raw": True }, { "path": "core_parser_app/js/buttons.js", "is_raw": False }, { "path": "core_schema_viewer_app/user/js/buttons.raw.js", "is_raw": True }, { "path": "core_parser_app/js/choice.js", "is_raw": False }, { "path": "core_schema_viewer_app/user/js/choice.raw.js", "is_raw": True }, { "path": "core_parser_app/js/modules.js", "is_raw": False }, { "path": 'core_schema_viewer_app/user/js/sandbox.js', "is_raw": False }, ], "css": [ 'core_main_app/common/css/XMLTree.css', 'core_schema_viewer_app/user/css/xsd_form.css', 'core_parser_app/css/use.css' ] } template = template_api.get(pk) # create the data structure sandbox_data_structure = sandbox_data_structure_api.create_and_save( template, request.user.id) # renders the form xsd_form = render_form( request, sandbox_data_structure.data_structure_element_root) # Set the context context = { "data_structure_id": str(sandbox_data_structure.id), "xsd_form": xsd_form } return render(request, 'core_schema_viewer_app/user/sandbox.html', assets=assets, context=context) except Exception as e: return render( request, 'core_main_app/common/commons/error.html', assets={}, context={'errors': 'An error occurred while rendering the tree.'})
def edit_rights(request, workspace_id): """ Load page to edit the rights. Args: request workspace_id Returns: """ try: workspace = workspace_api.get_by_id(workspace_id) except DoesNotExist as e: return HttpResponseBadRequest("The workspace does not exist.") except: return HttpResponseBadRequest("Something wrong happened.") if workspace.owner != str(request.user.id): return HttpResponseForbidden( "Only the workspace owner can edit the rights.") try: # Users users_read_workspace = workspace_api.get_list_user_can_read_workspace( workspace, request.user) users_write_workspace = workspace_api.get_list_user_can_write_workspace( workspace, request.user) users_access_workspace = list( set(users_read_workspace + users_write_workspace)) detailed_users = [] for user in users_access_workspace: detailed_users.append({ 'object_id': user.id, 'object_name': user.username, 'can_read': user in users_read_workspace, 'can_write': user in users_write_workspace, }) except: detailed_users = [] try: # Groups groups_read_workspace = workspace_api.get_list_group_can_read_workspace( workspace, request.user) groups_write_workspace = workspace_api.get_list_group_can_write_workspace( workspace, request.user) groups_access_workspace = list( set(groups_read_workspace + groups_write_workspace)) group_utils.remove_list_object_from_list( groups_access_workspace, [group_api.get_anonymous_group(), group_api.get_default_group()]) detailed_groups = [] for group in groups_access_workspace: detailed_groups.append({ 'object_id': group.id, 'object_name': group.name, 'can_read': group in groups_read_workspace, 'can_write': group in groups_write_workspace, }) except: detailed_groups = [] context = { 'workspace': workspace, 'user_data': detailed_users, 'group_data': detailed_groups, 'template': workspace_constants.EDIT_RIGHTS_TEMPLATE_TABLE, 'action_read': workspace_constants.ACTION_READ, 'action_write': workspace_constants.ACTION_WRITE, 'user': workspace_constants.USER, 'group': workspace_constants.GROUP, } assets = { "css": [ 'core_main_app/libs/datatables/1.10.13/css/jquery.dataTables.css', "core_main_app/libs/fSelect/css/fSelect.css" ], "js": [{ "path": 'core_main_app/libs/datatables/1.10.13/js/jquery.dataTables.js', "is_raw": True }, { "path": "core_main_app/libs/fSelect/js/fSelect.js", "is_raw": False }, { "path": 'core_main_app/common/js/backtoprevious.js', "is_raw": True }] } assets['js'].extend(copy.deepcopy(workspace_constants.JS_TABLES)) assets['js'].extend(copy.deepcopy(workspace_constants.JS_ADD_USER)) assets['css'].extend(copy.deepcopy(workspace_constants.CSS_SWITCH)) assets['js'].extend(copy.deepcopy(workspace_constants.JS_SWITCH_RIGHT)) assets['js'].extend(copy.deepcopy(workspace_constants.JS_REMOVE_RIGHT)) assets['js'].extend(copy.deepcopy(workspace_constants.JS_ADD_GROUP)) assets['js'].extend(copy.deepcopy(workspace_constants.JS_INIT)) modals = [ workspace_constants.MODAL_ADD_USER, workspace_constants.MODAL_SWITCH_RIGHT, workspace_constants.MODAL_REMOVE_RIGHTS, workspace_constants.MODAL_ADD_GROUP ] return render(request, workspace_constants.EDIT_RIGHTS_TEMPLATE, context=context, assets=assets, modals=modals)
def recover_query_steps(request, history_id): """ """ user_step = None previous_step = False next_step = False history_step = False # Validate the user step if request.method == 'POST': # Get the form's value user_query_id = request.POST.get('user_query', None) step_back = request.POST.get('step_back', None) try: # Load the query user_query = temp_user_query_api.get_by_id(user_query_id) except DoesNotExist: # The query doesn't exist anymore. messages.add_message( request, messages.ERROR, "A problem occurred during your information's transportation." " Please do it again.") return redirect(reverse("core_custom_queries_app_index")) # Get the current step information user_step = user_query.get_current_step() form_type = user_step.form_type # If the user want to go back to the previous step if step_back == 'True': previous_step = True else: error = False # The step is a a single choice step if form_type == 'radio': choices = request.POST.get('choices', None) if choices: user_step.choices.append(choices) else: messages.add_message(request, messages.WARNING, 'You have to choose one.') error = True # The step is a a multiple choices step elif form_type == 'check': list_choices = request.POST.getlist('choices') # Get the step restrictions and validate the choices against the restrictions min_range = user_step.step.data_min_range if min_range != '' and min_range: min_range = int(min_range) max_range = user_step.step.data_max_range # data_infinity = user_step.step.data_infinity if max_range != '' and max_range: max_range = int(max_range) if max_range < len(list_choices) or len( list_choices) < min_range: error = True messages.add_message( request, messages.WARNING, 'You have to choose between ' + str(min_range) + ' and ' + str(max_range) + ' choice.') else: if len(list_choices) < min_range: error = True messages.add_message( request, messages.WARNING, 'You have to choose at least one.') if not error: user_step.choices = list_choices # The step is a a date step else: time_from = request.POST['timeFrom'] time_to = request.POST['timeTo'] if time_from == "" or time_to == "": error = True messages.add_message(request, messages.WARNING, 'You have to fill both date.') else: try: time_from = datetime.strptime(time_from, "%Y-%m-%d %H:%M") time_to = datetime.strptime(time_to, "%Y-%m-%d %H:%M") if time_from > time_to: error = True messages.add_message( request, messages.WARNING, 'Date From has to be before date To') date_range = user_step.step.date_range if date_range and date_range != '': date_range = int(date_range) if (time_to - time_from).days > date_range: error = True messages.add_message( request, messages.WARNING, 'The maximum time range you can query in is ' + str(date_range) + ' day(s).') except Exception as e: error = True messages.add_message(request, messages.ERROR, e) if not error: user_step.choices = (request.POST['timeFrom'], request.POST['timeTo']) if not error: user_step.update_choices_to_db() next_step = True # Select and load the current step else: # Load history queries try: history_query = history_query_api.get_by_id(history_id) user_query = temp_user_query_api.get_by_id(history_query.query_id) except DoesNotExist: messages.add_message(request, messages.ERROR, "A problem occurred during the redirection.") return redirect(reverse("core_custom_queries_app_index")) history_step = True try: # Load the current step if previous_step is True: # Load the previous step user_step = user_query.get_previous_query_able_step() user_query.update_current_position_into_the_db() user_step.transform_choices_files_list_to_dict() history_id = user_query.save_to_history(user_id=request.user.id, history_id=history_id) elif next_step is True: # Load the next step user_step = user_query.get_and_load_choices_next_step() user_query.update_current_position_into_the_db() history_id = user_query.save_to_history(user_id=request.user.id, history_id=history_id) elif history_step is True: if user_query.history.message == "Error during output file creation.": # An error occurred messages.add_message( request, messages.ERROR, "An internal problem occurred during the output file creation. " "The administrator has been noticed.") return redirect(reverse("core_custom_queries_app_index")) else: # Load the history query user_step = user_query.handle_history() user_step.transform_choices_files_list_to_dict() except Exception as e: # Create the log file from the error log_file = LogFile( application="Custom Queries", message=str(e), additionalInformation={ 'query_name': user_query.query.name, 'step_name': user_query.list_steps[user_query.current_position].step.name, 'user_choices': user_query.get_previous_choices() }, timestamp=datetime.now()) log_file_api.upsert(log_file) try: user_query.update_message("Error during query step.") except ValidationError as e: logger.warning( "recover_query_steps threw an exception: {0}".format(str(e))) messages.add_message( request, messages.ERROR, "An internal problem occurred, the administrator has been notified." ) return redirect(reverse("core_custom_queries_app_index")) if user_step is None: # Go to result page user_query.add_query_to_waiting_line() user_query.update_message("Pending.") user_query.update_status(1) messages.add_message(request, messages.SUCCESS, "The output file will be created soon.") return redirect(reverse("core_custom_queries_app_index")) else: context = _create_step_context(user_query, user_step, history_id) assets = { "js": [ { "path": 'core_custom_queries_app/user/js/custom_queries.js', "is_raw": False }, { "path": 'core_custom_queries_app/user/js/custom_queries_step.js', "is_raw": False }, { "path": "core_custom_queries_app/libs/bootstrap-datetimepicker/js/bootstrap-datetimepicker.js", "is_raw": False }, ], 'css': [ 'core_custom_queries_app/libs/bootstrap-datetimepicker/css/bootstrap-datetimepicker.min.css' ] } # for the rendering return render(request, 'core_custom_queries_app/user/query_step.html', assets=assets, context=context)
def custom_password_reset_confirm( request, uidb64=None, token=None, template_name='core_main_app/user/registration/password_reset_confirm.html', token_generator=default_token_generator, set_password_form=SetPasswordForm, post_reset_redirect=None, extra_context=None): """ View that checks the hash in a password reset link and presents a form for entering a new password. Parameters: :param request: :param uidb64: :param token: :param template_name: :param token_generator: :param set_password_form: :param post_reset_redirect: :param extra_context: Returns: :return request """ UserModel = get_user_model() assert uidb64 is not None and token is not None # checked by URLconf if post_reset_redirect is None: post_reset_redirect = reverse('password_reset_complete') else: post_reset_redirect = resolve_url(post_reset_redirect) try: # urlsafe_base64_decode() decodes to bytestring on Python 3 uid = force_text(urlsafe_base64_decode(uidb64)) user = UserModel._default_manager.get(pk=uid) except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist): user = None if user is not None and token_generator.check_token(user, token): validlink = True title = 'Enter new password' if request.method == 'POST': form = set_password_form(user, request.POST) if form.is_valid(): form.save() return HttpResponseRedirect(post_reset_redirect) else: form = set_password_form(user) else: validlink = False form = None title = 'Password reset unsuccessful' context = { 'form': form, 'title': title, 'validlink': validlink, } if extra_context is not None: context.update(extra_context) return render(request, template_name, context=context)
def custom_reset_password( request, template_name="core_main_app/user/registration/password_reset_form.html", email_template_name="core_main_app/user/registration/password_reset_email.html", subject_template_name="core_main_app/user/registration/password_reset_subject.txt", password_reset_form=PasswordResetForm, token_generator=default_token_generator, post_reset_redirect=None, from_email=None, extra_context=None, html_email_template_name=None, extra_email_context=None, ): """Custom reset password page. Parameters: :param request: :param template_name: :param email_template_name: :param subject_template_name: :param password_reset_form: :param token_generator: :param post_reset_redirect: :param from_email: :param extra_context: :param extra_email_context: :param html_email_template_name: Returns: :return request """ if post_reset_redirect is None: post_reset_redirect = reverse("password_reset_done") else: post_reset_redirect = resolve_url(post_reset_redirect) if request.method == "POST": form = password_reset_form(request.POST) if form.is_valid(): opts = { "use_https": request.is_secure(), "token_generator": token_generator, "from_email": from_email, "email_template_name": email_template_name, "subject_template_name": subject_template_name, "request": request, "html_email_template_name": html_email_template_name, "extra_email_context": extra_email_context, "domain_override": PASSWORD_RESET_DOMAIN_OVERRIDE, } form.save(**opts) return HttpResponseRedirect(post_reset_redirect) else: form = password_reset_form() context = { "form": form, "title": "Password reset", } if extra_context is not None: context.update(extra_context) return render(request, template_name, context=context)
def get(self, request, *args, **kwargs): self.context.update({'upload_form': self.form_class()}) return render(request, self.template_name, context=self.context)
def request_new_account(request): """Page that allows to request a user account Parameters: request: Returns: Http response """ assets = { "js": [ { "path": "core_website_app/user/js/user_account_req.js", "is_raw": False } ], "css": ['core_website_app/user/css/list.css'] } if request.method == 'POST': request_form = RequestAccountForm(request.POST) if request_form.is_valid(): # Call the API try: user = User(username=request.POST['username'], first_name=request.POST['firstname'], last_name=request.POST['lastname'], password=make_password(request.POST['password']), email=request.POST['email'], is_active=False) account_request_api.insert(user) messages.add_message(request, messages.INFO, 'User Account Request sent to the administrator.') return redirect(reverse("core_main_app_homepage")) except ApiError as e: error_message = e.message error_template = get_template("core_website_app/user/request_error.html") error_box = error_template.render({"error_message": error_message}) return render(request, 'core_website_app/user/request_new_account.html', assets=assets, context={'request_form': request_form, 'action_result': error_box}) except ValidationError as e: error_message = "The following error(s) occurred during validation:" error_items = [str(field).capitalize() + ": " + str(error) for field, error in e.errors.items()] error_template = get_template("core_website_app/user/request_error.html") error_box = error_template.render({"error_message": error_message, "error_items": error_items}) return render(request, 'core_website_app/user/request_new_account.html', assets=assets, context={'request_form': request_form, 'action_result': error_box}) else: request_form = RequestAccountForm() context = { "request_form": request_form } return render(request, 'core_website_app/user/request_new_account.html', assets=assets, context=context)