From 2846a66333016e40a83cb785f40ba443584a0483 Mon Sep 17 00:00:00 2001
From: Sagar Ghimire <info@sagarg.com.np>
Date: Wed, 24 Apr 2024 19:40:30 +0545
Subject: [PATCH 1/3] [Improve][l]: Code formatting

---
 ckanext/rvr/actions.py                        | 341 +++++-----
 .../rvr/commands/migrate_spatial_fields.py    | 151 +++--
 ckanext/rvr/helpers.py                        | 167 ++---
 ckanext/rvr/plugin.py                         | 134 ++--
 ckanext/rvr/tests/test_plugin.py              |   4 +-
 ckanext/rvr/views/dataset.py                  | 597 ++++++++----------
 ckanext/rvr/views/faq.py                      |   8 +-
 ckanext/rvr/views/organization.py             | 209 +++---
 8 files changed, 828 insertions(+), 783 deletions(-)

diff --git a/ckanext/rvr/actions.py b/ckanext/rvr/actions.py
index 0276d0e..e41bb9f 100644
--- a/ckanext/rvr/actions.py
+++ b/ckanext/rvr/actions.py
@@ -20,25 +20,27 @@
 _check_access = logic.check_access
 get_action = logic.get_action
 
+
 def get_package_field(field, package):
-    '''
+    """
     Check package and package extras and get the value of the field if \
     it exists
-    '''
+    """
     value = None
-    if package.get(field, ''):
+    if package.get(field, ""):
         value = package[field]
     else:
-        for item in package['extras']:
-            if item.get('key', '') == field:
-                value = item['value']
+        for item in package["extras"]:
+            if item.get("key", "") == field:
+                value = item["value"]
     return value
 
+
 def filter_daterange(facet, dates, package):
-    '''
+    """
     Checks if the date of a field in a dataset is within a defined date \
     range.
-    '''
+    """
 
     # Check that there is at least a start or end date
     # No dates specified, packages passes
@@ -55,7 +57,7 @@ def filter_daterange(facet, dates, package):
             end_date = parser.parse(dates[1]).date()
     except ValueError as e:
         # Incorrect date format from parameter, package passes
-        log.error('Date parsing failed with error: {}'.format(e))
+        log.error("Date parsing failed with error: {}".format(e))
         return True
 
     is_in_range = True
@@ -66,7 +68,7 @@ def filter_daterange(facet, dates, package):
             facet_date = parser.parse(facet_date_str).date()
         except ValueError as e:
             # Package is storing incorrect date type, don't show package
-            log.error('Date parsing failed with error: {}'.format(e))
+            log.error("Date parsing failed with error: {}".format(e))
             return False
 
         # Check if datetime object is in range
@@ -81,34 +83,35 @@ def filter_daterange(facet, dates, package):
 
     return is_in_range
 
+
 def update_facets(facets, package):
-    '''
+    """
     After filtering, update the facets being sent from solr to reflect the \
     changes.
-    '''
+    """
     for facet in facets:
-        if facet in ['tags', 'groups', 'organization']:
+        if facet in ["tags", "groups", "organization"]:
             pop_items = []
             for facet_item in facets[facet]:
-                if facet in ['organization']:
+                if facet in ["organization"]:
                     item = package[facet]
-                    if item['name'] == facet_item:
+                    if item["name"] == facet_item:
                         facets[facet][facet_item] -= 1
                         if facets[facet][facet_item] == 0:
                             pop_items.append(facet_item)
-                if facet in ['tags', 'groups']:
+                if facet in ["tags", "groups"]:
                     for item in package[facet]:
-                        if item['name'] == facet_item:
+                        if item["name"] == facet_item:
                             facets[facet][facet_item] -= 1
                             if facets[facet][facet_item] == 0:
                                 pop_items.append(facet_item)
             for i in pop_items:
                 facets[facet].pop(i)
-        elif facet == 'res_format':
+        elif facet == "res_format":
             pop_items = []
             for facet_item in facets[facet]:
-                for item in package['resources']:
-                    if item['format'] == facet_item:
+                for item in package["resources"]:
+                    if item["format"] == facet_item:
                         facets[facet][facet_item] -= 1
                         if facets[facet][facet_item] == 0:
                             pop_items.append(facet_item)
@@ -117,12 +120,14 @@ def update_facets(facets, package):
         else:
             pop_items = []
             value = get_package_field(facet, package)
-            if facet in ['metadata_created', 'metadata_modified']:
-                value = parser.parse(value).date().strftime('%m-%d-%Y')
+            if facet in ["metadata_created", "metadata_modified"]:
+                value = parser.parse(value).date().strftime("%m-%d-%Y")
             for item in facets[facet]:
-                if value == item or \
-                facet in ['metadata_created', 'metadata_modified'] and \
-                value == parser.parse(item).date().strftime('%m-%d-%Y'):
+                if (
+                    value == item
+                    or facet in ["metadata_created", "metadata_modified"]
+                    and value == parser.parse(item).date().strftime("%m-%d-%Y")
+                ):
                     facets[facet][item] -= 1
                     if facets[facet][item] == 0:
                         pop_items.append(item)
@@ -130,9 +135,10 @@ def update_facets(facets, package):
                 facets[facet].pop(i)
     return facets
 
+
 @toolkit.side_effect_free
 def package_search(context, data_dict):
-    '''
+    """
     RVR implementation for ckan's package_search
     Searches for packages satisfying a given search criteria.
 
@@ -258,40 +264,39 @@ def package_search(context, data_dict):
         query.
         fl can be  None or a list of result fields, such as ['id', 'extras_custom_field'].
         if fl = None, datasets are returned as a list of full dictionary.
-    '''
+    """
     # Get dateranges
-    dateranges = data_dict.pop('dateranges', {})
-    data_dict.pop('date_filters', {})
-    items_per_page = int(data_dict.pop('rows', 20))
-    start = int(data_dict.pop('start', 0))
-    data_dict['rows'] = 1000
-    data_dict['start'] = 0
+    dateranges = data_dict.pop("dateranges", {})
+    data_dict.pop("date_filters", {})
+    items_per_page = int(data_dict.pop("rows", 20))
+    start = int(data_dict.pop("start", 0))
+    data_dict["rows"] = 1000
+    data_dict["start"] = 0
 
     # sometimes context['schema'] is None
-    schema = (context.get('schema') or
-              logic.schema.default_package_search_schema())
+    schema = context.get("schema") or logic.schema.default_package_search_schema()
     data_dict, errors = _validate(data_dict, schema, context)
     # put the extras back into the data_dict so that the search can
     # report needless parameters
-    data_dict.update(data_dict.get('__extras', {}))
-    data_dict.pop('__extras', None)
+    data_dict.update(data_dict.get("__extras", {}))
+    data_dict.pop("__extras", None)
     if errors:
         raise ValidationError(errors)
 
-    model = context['model']
-    session = context['session']
-    user = context.get('user')
+    model = context["model"]
+    session = context["session"]
+    user = context.get("user")
 
-    _check_access('package_search', context, data_dict)
+    _check_access("package_search", context, data_dict)
 
     # Move ext_ params to extras and remove them from the root of the search
     # params, so they don't cause and error
-    data_dict['extras'] = data_dict.get('extras', {})
-    for key in [key for key in data_dict.keys() if key.startswith('ext_')]:
-        data_dict['extras'][key] = data_dict.pop(key)
+    data_dict["extras"] = data_dict.get("extras", {})
+    for key in [key for key in data_dict.keys() if key.startswith("ext_")]:
+        data_dict["extras"][key] = data_dict.pop(key)
 
     # set default search field
-    data_dict['df'] = 'text'
+    data_dict["df"] = "text"
 
     # check if some extension needs to modify the search params
     for item in plugins.PluginImplementations(plugins.IPackageController):
@@ -299,43 +304,47 @@ def package_search(context, data_dict):
 
     # the extension may have decided that it is not necessary to perform
     # the query
-    abort = data_dict.get('abort_search', False)
+    abort = data_dict.get("abort_search", False)
 
-    if data_dict.get('sort') in (None, 'rank'):
-        data_dict['sort'] = config.get('ckan.search.default_package_sort') or 'score desc, metadata_modified desc'
+    if data_dict.get("sort") in (None, "rank"):
+        data_dict["sort"] = (
+            config.get("ckan.search.default_package_sort")
+            or "score desc, metadata_modified desc"
+        )
 
     results = []
     if not abort:
-        if asbool(data_dict.get('use_default_schema')):
-            data_source = 'data_dict'
+        if asbool(data_dict.get("use_default_schema")):
+            data_source = "data_dict"
         else:
-            data_source = 'validated_data_dict'
-        data_dict.pop('use_default_schema', None)
+            data_source = "validated_data_dict"
+        data_dict.pop("use_default_schema", None)
 
-        result_fl = data_dict.get('fl')
+        result_fl = data_dict.get("fl")
         if not result_fl:
-            data_dict['fl'] = 'id {0}'.format(data_source)
+            data_dict["fl"] = "id {0}".format(data_source)
         else:
-            data_dict['fl'] = ' '.join(result_fl)
+            data_dict["fl"] = " ".join(result_fl)
 
         # Remove before these hit solr FIXME: whitelist instead
-        include_private = asbool(data_dict.pop('include_private', False))
-        include_drafts = asbool(data_dict.pop('include_drafts', False))
-        data_dict.setdefault('fq', '')
+        include_private = asbool(data_dict.pop("include_private", False))
+        include_drafts = asbool(data_dict.pop("include_drafts", False))
+        data_dict.setdefault("fq", "")
         if not include_private:
-            data_dict['fq'] = '+capacity:public ' + data_dict['fq']
+            data_dict["fq"] = "+capacity:public " + data_dict["fq"]
         if include_drafts:
-            data_dict['fq'] += ' +state:(active OR draft)'
+            data_dict["fq"] += " +state:(active OR draft)"
 
         # Pop these ones as Solr does not need them
-        extras = data_dict.pop('extras', None)
+        extras = data_dict.pop("extras", None)
 
         # enforce permission filter based on user
-        if context.get('ignore_auth') or (user and authz.is_sysadmin(user)):
+        if context.get("ignore_auth") or (user and authz.is_sysadmin(user)):
             labels = None
         else:
-            labels = lib_plugins.get_permission_labels(
-                ).get_user_dataset_labels(context['auth_user_obj'])
+            labels = lib_plugins.get_permission_labels().get_user_dataset_labels(
+                context["auth_user_obj"]
+            )
 
         query = search.query_for(model.Package)
         # Save a copy of the original data_dict
@@ -344,13 +353,13 @@ def package_search(context, data_dict):
         def get_filtered_packages(
             scanned_package_count=0, removed_packages_count=0, facets={}, extras=extras
         ):
-            '''
+            """
             Make query to solr and also filter results by dateranges if available
-            '''
+            """
             # Pass the original data_dict as it changes after each iteration
             data_dict = permanent_data_dict.copy()
             if scanned_package_count:
-                data_dict['start'] = scanned_package_count
+                data_dict["start"] = scanned_package_count
             query.run(data_dict, permission_labels=labels)
             if not facets:
                 current_facets = query.facets
@@ -358,20 +367,20 @@ def get_filtered_packages(
                 current_facets = facets
 
             # Add them back so extensions can use them on after_search
-            data_dict['extras'] = extras
+            data_dict["extras"] = extras
 
             if result_fl:
                 for package in query.results:
                     scanned_package_count += 1
                     if isinstance(package, text_type):
                         package = {result_fl[0]: package}
-                    extras = package.pop('extras', {})
+                    extras = package.pop("extras", {})
                     package.update(extras)
 
                     # Check daterange
                     is_in_range = True
                     for k in dateranges:
-                        if not filter_daterange(k, dateranges[k]['params'], package):
+                        if not filter_daterange(k, dateranges[k]["params"], package):
                             is_in_range = False
                             break
                     if not is_in_range:
@@ -389,14 +398,17 @@ def get_filtered_packages(
                     if package_dict:
                         # the package_dict still needs translating when being viewed
                         package_dict = json.loads(package_dict)
-                        if context.get('for_view'):
+                        if context.get("for_view"):
                             for item in plugins.PluginImplementations(
-                                    plugins.IPackageController):
+                                plugins.IPackageController
+                            ):
                                 package_dict = item.before_dataset_view(package_dict)
                         # Check daterange
                         is_in_range = True
                         for k in dateranges:
-                            if not filter_daterange(k, dateranges[k]['params'], package_dict):
+                            if not filter_daterange(
+                                k, dateranges[k]["params"], package_dict
+                            ):
                                 is_in_range = False
                                 break
                         if not is_in_range:
@@ -406,8 +418,10 @@ def get_filtered_packages(
                             continue
                         results.append(package_dict)
                     else:
-                        log.error('No package_dict is coming from solr for package '
-                                'id %s', package['id'])
+                        log.error(
+                            "No package_dict is coming from solr for package " "id %s",
+                            package["id"],
+                        )
             return scanned_package_count, removed_packages_count, current_facets
 
         scanned_packages_count = 0
@@ -417,10 +431,12 @@ def get_filtered_packages(
         # and keep running searches till all the packages from the original
         # search have been filtered
         while True:
-            scanned_packages_count, removed_packages_count, facets = get_filtered_packages(
-                scanned_package_count=scanned_packages_count,
-                removed_packages_count=removed_packages_count,
-                facets=facets
+            scanned_packages_count, removed_packages_count, facets = (
+                get_filtered_packages(
+                    scanned_package_count=scanned_packages_count,
+                    removed_packages_count=removed_packages_count,
+                    facets=facets,
+                )
             )
             # Break loop once all query results have been searched through
             if int(query.count) <= scanned_packages_count:
@@ -431,52 +447,54 @@ def get_filtered_packages(
         facets = {}
         results = []
 
-    paginated_results = results[start:start+items_per_page]
+    paginated_results = results[start : start + items_per_page]
 
     search_results = {
-        'count': count,
-        'facets': facets,
-        'results': paginated_results,
-        'sort': data_dict['sort']
+        "count": count,
+        "facets": facets,
+        "results": paginated_results,
+        "sort": data_dict["sort"],
     }
 
     # create a lookup table of group name to title for all the groups and
     # organizations in the current search's facets.
     group_names = []
-    for field_name in ('groups', 'organization'):
+    for field_name in ("groups", "organization"):
         group_names.extend(facets.get(field_name, {}).keys())
 
-    groups = (session.query(model.Group.name, model.Group.title)
-                    .filter(model.Group.name.in_(group_names))
-                    .all()
-              if group_names else [])
+    groups = (
+        session.query(model.Group.name, model.Group.title)
+        .filter(model.Group.name.in_(group_names))
+        .all()
+        if group_names
+        else []
+    )
     group_titles_by_name = dict(groups)
 
     # Transform facets into a more useful data structure.
     restructured_facets = {}
     for key, value in facets.items():
-        restructured_facets[key] = {
-            'title': key,
-            'items': []
-        }
+        restructured_facets[key] = {"title": key, "items": []}
         for key_, value_ in value.items():
             new_facet_dict = {}
-            new_facet_dict['name'] = key_
-            if key in ('groups', 'organization'):
+            new_facet_dict["name"] = key_
+            if key in ("groups", "organization"):
                 display_name = group_titles_by_name.get(key_, key_)
-                display_name = display_name if display_name and display_name.strip() else key_
-                new_facet_dict['display_name'] = display_name
-            elif key == 'license_id':
+                display_name = (
+                    display_name if display_name and display_name.strip() else key_
+                )
+                new_facet_dict["display_name"] = display_name
+            elif key == "license_id":
                 license = model.Package.get_license_register().get(key_)
                 if license:
-                    new_facet_dict['display_name'] = license.title
+                    new_facet_dict["display_name"] = license.title
                 else:
-                    new_facet_dict['display_name'] = key_
+                    new_facet_dict["display_name"] = key_
             else:
-                new_facet_dict['display_name'] = key_
-            new_facet_dict['count'] = value_
-            restructured_facets[key]['items'].append(new_facet_dict)
-    search_results['search_facets'] = restructured_facets
+                new_facet_dict["display_name"] = key_
+            new_facet_dict["count"] = value_
+            restructured_facets[key]["items"].append(new_facet_dict)
+    search_results["search_facets"] = restructured_facets
 
     # check if some extension needs to modify the search results
     for item in plugins.PluginImplementations(plugins.IPackageController):
@@ -484,13 +502,16 @@ def get_filtered_packages(
 
     # After extensions have had a chance to modify the facets, sort them by
     # display name.
-    for facet in search_results['search_facets']:
-        search_results['search_facets'][facet]['items'] = sorted(
-            search_results['search_facets'][facet]['items'],
-            key=lambda facet: facet['display_name'], reverse=True)
+    for facet in search_results["search_facets"]:
+        search_results["search_facets"][facet]["items"] = sorted(
+            search_results["search_facets"][facet]["items"],
+            key=lambda facet: facet["display_name"],
+            reverse=True,
+        )
 
     return search_results
 
+
 @toolkit.side_effect_free
 def package_show(context, data_dict):
     """
@@ -500,34 +521,35 @@ def package_show(context, data_dict):
     This is necessary to fix bugs with the package dict getting updated with \
     both fields in the extras and the main package schema.
     """
-    context['api_version'] = 3
-    context['use_cache'] = False
+    context["api_version"] = 3
+    context["use_cache"] = False
     dataset = ckan_package_show(context, data_dict)
-    
+
     spatial_dict = {}
     dataset_spatial_dict = {}
-    for extra in dataset.get('extras', []):
-        if extra.get('key', '') == 'spatial':
+    for extra in dataset.get("extras", []):
+        if extra.get("key", "") == "spatial":
             spatial_dict = extra
-        if extra.get('key', '')== 'dataset_spatial':
+        if extra.get("key", "") == "dataset_spatial":
             dataset_spatial_dict = extra
     try:
-        dataset['extras'].remove(spatial_dict)
+        dataset["extras"].remove(spatial_dict)
     except KeyError:
         pass
     except ValueError:
         pass
     try:
-        dataset['extras'].remove(dataset_spatial_dict)
+        dataset["extras"].remove(dataset_spatial_dict)
     except KeyError:
         pass
     except ValueError:
         pass
-    dataset['spatial'] = spatial_dict.get('value', '')
-    dataset['dataset_spatial'] = dataset_spatial_dict.get('value', '')
+    dataset["spatial"] = spatial_dict.get("value", "")
+    dataset["dataset_spatial"] = dataset_spatial_dict.get("value", "")
 
     return dataset
 
+
 def add_org_spatial_to_dataset_dict(pkg_dict: dict, org_id: str) -> dict:
     """
     Gets the bbox coordinates from the organization if it has one and adds \
@@ -546,35 +568,32 @@ def add_org_spatial_to_dataset_dict(pkg_dict: dict, org_id: str) -> dict:
         (dict) Updated dictionary with the `extras_spatial` field if the \
         organization had coordinates, if not, just returns back the `pkg_dict`
     """
-    context = { u'model': model, u'session': model.Session }
-    data_dict = { u'id': org_id, u'include_datasets': False }
+    context = {"model": model, "session": model.Session}
+    data_dict = {"id": org_id, "include_datasets": False}
     try:
-        group_dict = get_action(u'organization_show')(context, data_dict)
-        extras = group_dict.get('extras', [])
+        group_dict = get_action("organization_show")(context, data_dict)
+        extras = group_dict.get("extras", [])
         org_spatial = None
         for extra in extras:
-            if extra['key'] == 'org_spatial':
-                org_spatial = extra['value']
-        if org_spatial and org_spatial.startswith('[['):
+            if extra["key"] == "org_spatial":
+                org_spatial = extra["value"]
+        if org_spatial and org_spatial.startswith("[["):
             coordinates = json.loads(org_spatial)
-            pkg_geojson = {
-                "type": "Polygon",
-                "coordinates": coordinates
-            }
+            pkg_geojson = {"type": "Polygon", "coordinates": coordinates}
             spatial = json.dumps(pkg_geojson)
-            pkg_dict['extras_spatial'] = spatial
+            pkg_dict["extras_spatial"] = spatial
 
             # Add spatial to data_dict
-            if pkg_dict.get('data_dict', None):
-                data = json.loads(pkg_dict['data_dict'])
-                data['extras'].append({'key': 'spatial', 'value': spatial})
-                pkg_dict['data_dict'] = json.dumps(data)
+            if pkg_dict.get("data_dict", None):
+                data = json.loads(pkg_dict["data_dict"])
+                data["extras"].append({"key": "spatial", "value": spatial})
+                pkg_dict["data_dict"] = json.dumps(data)
 
             # Add spatial to validated_data_dict
-            if pkg_dict.get('validated_data_dict', None):
-                validated_data = json.loads(pkg_dict['validated_data_dict'])
-                validated_data['extras'].append({'key': 'spatial', 'value': spatial})
-                pkg_dict['validated_data_dict'] = json.dumps(validated_data)
+            if pkg_dict.get("validated_data_dict", None):
+                validated_data = json.loads(pkg_dict["validated_data_dict"])
+                validated_data["extras"].append({"key": "spatial", "value": spatial})
+                pkg_dict["validated_data_dict"] = json.dumps(validated_data)
 
             return pkg_dict
         else:
@@ -583,17 +602,16 @@ def add_org_spatial_to_dataset_dict(pkg_dict: dict, org_id: str) -> dict:
         log.error(e)
         return pkg_dict
 
+
 def generate_spatial_from_bbox(bbox: str) -> str:
     """
     Takes a bbox string and adds it to the spatial polygon
     """
     bbox_json = json.loads(bbox)
-    spatial_json = {
-        "type": "Polygon",
-        "coordinates": bbox_json
-    }
+    spatial_json = {"type": "Polygon", "coordinates": bbox_json}
     return json.dumps(spatial_json)
 
+
 def update_dataset_spatial(data: dict) -> None:
     """
     This should be called when the organization bbox string has changed.
@@ -607,14 +625,14 @@ def update_dataset_spatial(data: dict) -> None:
     """
     from ckan.views.group import _force_reindex
 
-    for extra in data.get('extras', []):
-        if extra.get('key', None) == 'org_spatial':
-            org_spatial = extra['value']
+    for extra in data.get("extras", []):
+        if extra.get("key", None) == "org_spatial":
+            org_spatial = extra["value"]
 
-    context = { u'model': model, u'session': model.Session }
+    context = {"model": model, "session": model.Session}
 
-    for pkg in data.get('packages', []):
-        dataset = get_action('package_show')(context, {'id': pkg['id']})
+    for pkg in data.get("packages", []):
+        dataset = get_action("package_show")(context, {"id": pkg["id"]})
         has_bbox = False
 
         # Before the addition of the features to allows datasets inherit spatial
@@ -623,24 +641,33 @@ def update_dataset_spatial(data: dict) -> None:
         # In the event that the fields are not updated before using the
         # feature, we don't want to lose the coordinates for those datasets,
         # hence we would also not override datasets that have any of these extras
-        # TODO: This is temporary and when it is certain that the data has been 
+        # TODO: This is temporary and when it is certain that the data has been
         # normalized, this should be set to use only the 'dataset_spatial' field
-        required = ['bbox-east-long', 'bbox-north-lat', 'bbox-south-lat', 'bbox-west-long']
+        required = [
+            "bbox-east-long",
+            "bbox-north-lat",
+            "bbox-south-lat",
+            "bbox-west-long",
+        ]
         # Check if the dataset has a bbox value
-        if dataset.get('dataset_spatial', None):
+        if dataset.get("dataset_spatial", None):
             has_bbox = True
         else:
-            for extra in dataset.get('extras', []):
-                if extra['key'] in required and len(extra['value']) > 0:
+            for extra in dataset.get("extras", []):
+                if extra["key"] in required and len(extra["value"]) > 0:
                     has_bbox = True
                     break
         if not has_bbox:
             try:
                 # Update the package spatial field to the org bbox value
-                dataset['spatial'] = org_spatial
-                get_action('package_update')(context, dataset)
+                dataset["spatial"] = org_spatial
+                get_action("package_update")(context, dataset)
             except Exception as e:
-                log.warn("""Failed to update dataset: {} with spatial data from \
-                    organization: {}""".format(dataset['name'], data['name']))
+                log.warn(
+                    """Failed to update dataset: {} with spatial data from \
+                    organization: {}""".format(
+                        dataset["name"], data["name"]
+                    )
+                )
                 log.warn(e)
     _force_reindex(data)
diff --git a/ckanext/rvr/commands/migrate_spatial_fields.py b/ckanext/rvr/commands/migrate_spatial_fields.py
index e33dd7b..5cd4cbb 100644
--- a/ckanext/rvr/commands/migrate_spatial_fields.py
+++ b/ckanext/rvr/commands/migrate_spatial_fields.py
@@ -7,11 +7,7 @@
 from ckanext.rvr.helpers import is_valid_spatial, all_package_list
 
 echo = click.echo
-context = {
-    'model': model,
-    'session': model.Session,
-    'ignore_auth': True
-}
+context = {"model": model, "session": model.Session, "ignore_auth": True}
 
 short_help = "Migrates spatial fields for datasets, to prepare them for the spatial inheritance feature of the ckanext-rvr extension"
 help = """Migrate spatial fields for datasets and organizations\n
@@ -49,17 +45,18 @@
 migrating them.
 """
 
+
 @click.command(
-    name='migrate',
+    name="migrate",
     # There's a bug with ckan 2.9.4 that has been fixed in 2.9.5 where the
     # --help flag doesn't work as expected: https://github.com/ckan/ckan/issues/5755
     # For now the short_help will display the full help
     short_help=help,
     help=help,
     epilog=epilog,
-    add_help_option=True
+    add_help_option=True,
 )
-@click.option('--dry-run', 'dry_run', is_flag=True, help=dry_run_help)
+@click.option("--dry-run", "dry_run", is_flag=True, help=dry_run_help)
 def migrate_spatial(dry_run) -> None:
     """
     Function handling the `ckan rvr-spatial migrate` command
@@ -68,23 +65,24 @@ def migrate_spatial(dry_run) -> None:
     echo("Getting datasets to migrate...")
     mig_dict = get_datasets_to_migrate()
 
-    if mig_dict['pkg_count'] < 1:
-        echo('There are no datasets that need to be migrated.')
+    if mig_dict["pkg_count"] < 1:
+        echo("There are no datasets that need to be migrated.")
         return
 
     found_message = "Found {} datasets across {} organizations whose spatial fields need to be migrated.".format(
-        mig_dict['pkg_count'], mig_dict['org_count'])
+        mig_dict["pkg_count"], mig_dict["org_count"]
+    )
     if dry_run:
         message = """DATASETS TO BE MIGRATED BY ORGANIZATION\n\n"""
-        for org_id in mig_dict['migration_dict']:
-            title = mig_dict['migration_dict'][org_id]['title']
-            name = mig_dict['migration_dict'][org_id]['name']
+        for org_id in mig_dict["migration_dict"]:
+            title = mig_dict["migration_dict"][org_id]["title"]
+            name = mig_dict["migration_dict"][org_id]["name"]
             message += '<ORGANIZATION title="{}" name={}>\n'.format(title, name)
-            for data in mig_dict['migration_dict'][org_id]['datasets']:
-                echo('DATASETS DATA')
+            for data in mig_dict["migration_dict"][org_id]["datasets"]:
+                echo("DATASETS DATA")
                 echo(data)
-                title = data['title']
-                name = data['name']
+                title = data["title"]
+                name = data["name"]
                 message += '\t<DATASET title="{}" name={}>\n'.format(title, name)
         echo(message)
 
@@ -93,22 +91,32 @@ def migrate_spatial(dry_run) -> None:
 
     echo(found_message)
     ctx = context.copy()
-    ctx['allow_partial_update'] = True
-    ctx['user'] = get_action('get_site_user')(context, {})['name']
-    for org_id in mig_dict['migration_dict']:
-        for data in mig_dict['migration_dict'][org_id]['datasets']:
+    ctx["allow_partial_update"] = True
+    ctx["user"] = get_action("get_site_user")(context, {})["name"]
+    for org_id in mig_dict["migration_dict"]:
+        for data in mig_dict["migration_dict"][org_id]["datasets"]:
             try:
-                echo('\n\nATTEMPTING TO MIGRATE: <DATASET title="{}" name={}>'.format(
-                    data['title'], data['name']))
+                echo(
+                    '\n\nATTEMPTING TO MIGRATE: <DATASET title="{}" name={}>'.format(
+                        data["title"], data["name"]
+                    )
+                )
                 migrate_dataset(data, ctx)
             except Exception as e:
                 echo(e)
-                echo("UNABLE TO MIGRATE: <DATASET title={} name={}>".format(
-                    data['title'], data['name']))
-            echo('SUCCESSFULLY MIGRATED <DATASET title="{}" name={}>'.format(
-                    data['title'], data['name']))
+                echo(
+                    "UNABLE TO MIGRATE: <DATASET title={} name={}>".format(
+                        data["title"], data["name"]
+                    )
+                )
+            echo(
+                'SUCCESSFULLY MIGRATED <DATASET title="{}" name={}>'.format(
+                    data["title"], data["name"]
+                )
+            )
     return
 
+
 def get_org_spatials() -> dict:
     """Get all organizations and their spatial data
 
@@ -122,32 +130,36 @@ def get_org_spatials() -> dict:
             } 
     """
     # Get all organizations
-    org_ids = get_action('organization_list')(context, {})
+    org_ids = get_action("organization_list")(context, {})
     org_spatials = {}
 
     # For each organization, get the org spatial from that organization.
     for org_id in org_ids:
-        org_dict = get_action('organization_show')(context, {
-            "id": org_id,
-            "include_datasets": False,
-            "include_users": False,
-            "include_groups": False,
-            "include_tags": False,
-            "include_followers": False
-        })
-        org_spatial = ''
-        for extra in org_dict.get('extras', []):
-            if extra['key'] == 'org_spatial':
-                org_spatial = extra['value']
-        org_spatials[org_dict['id']] = {
-            'title': org_dict['title'],
-            'name': org_dict['name'],
-            'org_spatial': org_spatial
+        org_dict = get_action("organization_show")(
+            context,
+            {
+                "id": org_id,
+                "include_datasets": False,
+                "include_users": False,
+                "include_groups": False,
+                "include_tags": False,
+                "include_followers": False,
+            },
+        )
+        org_spatial = ""
+        for extra in org_dict.get("extras", []):
+            if extra["key"] == "org_spatial":
+                org_spatial = extra["value"]
+        org_spatials[org_dict["id"]] = {
+            "title": org_dict["title"],
+            "name": org_dict["name"],
+            "org_spatial": org_spatial,
         }
         del org_dict
-    
+
     return org_spatials
 
+
 def needs_migration(pkg_dict: dict, org_spatials: dict):
     """Checks if a dataset needs to be migrated
 
@@ -165,16 +177,20 @@ def needs_migration(pkg_dict: dict, org_spatials: dict):
         (bool | str) : `False` if the dataset doesn't need to be migrated or \
             the spatial value if it does
     """
-    dataset_spatial = pkg_dict['dataset_spatial']
-    spatial = pkg_dict['spatial']
-    
+    dataset_spatial = pkg_dict["dataset_spatial"]
+    spatial = pkg_dict["spatial"]
+
     if is_valid_spatial(dataset_spatial):
         return False
-    elif is_valid_spatial(spatial) and spatial != org_spatials[pkg_dict['owner_org']]['org_spatial']:
+    elif (
+        is_valid_spatial(spatial)
+        and spatial != org_spatials[pkg_dict["owner_org"]]["org_spatial"]
+    ):
         return spatial
 
     return False
 
+
 def get_datasets_to_migrate() -> dict:
     """Gets the datasets that need to be migrated grouped by their organizations
 
@@ -202,33 +218,36 @@ def get_datasets_to_migrate() -> dict:
     pkg_count = 0
     org_count = 0
     org_spatials = get_org_spatials()
-    
+
     pkg_ids = all_package_list()
-    echo('Found a total of {} datasets on the portal. Checking which ones need to be migrated'.format(len(pkg_ids)))
+    echo(
+        "Found a total of {} datasets on the portal. Checking which ones need to be migrated".format(
+            len(pkg_ids)
+        )
+    )
     for pkg_id in pkg_ids:
-        data = get_action('package_show')(context, {
-            "id": pkg_id
-        })
+        data = get_action("package_show")(context, {"id": pkg_id})
         dataset_spatial = needs_migration(data, org_spatials)
         if dataset_spatial:
-            data['dataset_spatial'] = dataset_spatial
-            if migration_dict.get(data['owner_org'], None):
-                migration_dict[data['owner_org']]['datasets'].append(data)
-                migration_dict[data['owner_org']]['count'] += 1
+            data["dataset_spatial"] = dataset_spatial
+            if migration_dict.get(data["owner_org"], None):
+                migration_dict[data["owner_org"]]["datasets"].append(data)
+                migration_dict[data["owner_org"]]["count"] += 1
                 pkg_count += 1
             else:
-                migration_dict[data['owner_org']] = org_spatials[data['owner_org']]
-                migration_dict[data['owner_org']]['datasets'] = [data]
-                migration_dict[data['owner_org']]['count'] = 1
+                migration_dict[data["owner_org"]] = org_spatials[data["owner_org"]]
+                migration_dict[data["owner_org"]]["datasets"] = [data]
+                migration_dict[data["owner_org"]]["count"] = 1
                 org_count += 1
                 pkg_count += 1
     del org_spatials
     return {
-        'migration_dict': migration_dict,
-        'org_count': org_count,
-        'pkg_count': pkg_count
+        "migration_dict": migration_dict,
+        "org_count": org_count,
+        "pkg_count": pkg_count,
     }
 
+
 def migrate_dataset(data: dict, context: dict = context):
     """Updates the dataset_spatial field of a dataset
 
@@ -237,4 +256,4 @@ def migrate_dataset(data: dict, context: dict = context):
             other required fields as per the schema
         context (dict, optional): context object. Defaults to script context.
     """
-    updated = get_action('package_update')(context, data)
\ No newline at end of file
+    updated = get_action("package_update")(context, data)
diff --git a/ckanext/rvr/helpers.py b/ckanext/rvr/helpers.py
index 0de13cc..ca9478a 100644
--- a/ckanext/rvr/helpers.py
+++ b/ckanext/rvr/helpers.py
@@ -14,13 +14,10 @@
 
 log = logging.getLogger(__name__)
 config = tk.config
-ignore_missing = tk.get_validator('ignore_missing')
+ignore_missing = tk.get_validator("ignore_missing")
+
+context = {"model": model, "session": model.Session, "ignore_auth": True}
 
-context = {
-    'model': model,
-    'session': model.Session,
-    'ignore_auth': True
-}
 
 def is_valid_spatial(spatial: str) -> bool:
     """Checks is a spatial string is a valid GeoJSON spatial
@@ -33,15 +30,16 @@ def is_valid_spatial(spatial: str) -> bool:
     """
     try:
         spatial_dict = json.loads(spatial)
-        if spatial_dict['type'].lower() != 'polygon':
+        if spatial_dict["type"].lower() != "polygon":
             return False
-        if type(spatial_dict['coordinates']) != type([]):
+        if type(spatial_dict["coordinates"]) != type([]):
             return False
         del spatial_dict
         return True
     except:
         return False
 
+
 def get_org_spatial(org_id: str, context: dict = context) -> str:
     """Get the spatial data for the organization
 
@@ -52,15 +50,16 @@ def get_org_spatial(org_id: str, context: dict = context) -> str:
     Returns:
         str: The organization spatial string
     """
-    org_dict = get_action(u'organization_show')(context,
-        {u'id': org_id, u'include_datasets': False}
+    org_dict = get_action("organization_show")(
+        context, {"id": org_id, "include_datasets": False}
     )
-    org_spatial = ''
-    for extra in org_dict.get('extras', []):
-        if extra.get('key') == 'org_spatial':
-            org_spatial = extra.get('value')
+    org_spatial = ""
+    for extra in org_dict.get("extras", []):
+        if extra.get("key") == "org_spatial":
+            org_spatial = extra.get("value")
     return org_spatial
 
+
 def all_package_list(include_private: bool = True):
     """
     Like ckan's package_list but returns only private packages which are \
@@ -72,15 +71,14 @@ def all_package_list(include_private: bool = True):
         include_private (bool, optional): include private datasets. Defaults to True.
     """
     package_table = model.package_table
-    col = (package_table.c.name)
+    col = package_table.c.name
     query = select([col])
     if include_private:
-        query = query.where(and_(
-            package_table.c.state == 'active',
-            package_table.c.type == 'dataset'
-        ))
+        query = query.where(
+            and_(package_table.c.state == "active", package_table.c.type == "dataset")
+        )
     else:
-        return get_action('package_list')(context, {})
+        return get_action("package_list")(context, {})
     query = query.order_by(col)
 
     ## Returns the first field in each result record
@@ -88,34 +86,39 @@ def all_package_list(include_private: bool = True):
 
 
 def get_newest_datasets():
-    results = tk.get_action('current_package_list_with_resources')({},{"limit":5})
+    results = tk.get_action("current_package_list_with_resources")({}, {"limit": 5})
     return results
 
 
 def get_nav_transport():
-    link = h.literal(u'<a href="/{}">{}</a>'.format("verkehrsdaten", "Verkehrsdaten"))
-    return h.literal("<li>")+ link + h.literal("</li>")
+    link = h.literal('<a href="/{}">{}</a>'.format("verkehrsdaten", "Verkehrsdaten"))
+    return h.literal("<li>") + link + h.literal("</li>")
 
 
 def get_specific_page(name=""):
-    page_list = tk.get_action('ckanext_pages_list')(
-        None, {
-               'page_type': 'page'}
-    )
-    
+    page_list = tk.get_action("ckanext_pages_list")(None, {"page_type": "page"})
+
     new_list = []
     for page in page_list:
-        if page['name'] == name:
+        if page["name"] == name:
             new_list.append(page)
     return new_list
 
 
 def get_faq_page():
 
-    page_list = tk.get_action('ckanext_pages_list')(None, {'ignore_auth': True, 'user': 'ckan_admin', 'page_type': 'page', 'private': True})
+    page_list = tk.get_action("ckanext_pages_list")(
+        None,
+        {
+            "ignore_auth": True,
+            "user": "ckan_admin",
+            "page_type": "page",
+            "private": True,
+        },
+    )
     print(f"OVO JE {page_list}")
     for page in page_list:
-        if page['name'] == "faq":
+        if page["name"] == "faq":
             faq_page = page["content"]
             if isinstance(faq_page, str):
                 faq_page = faq_page.replace("\r\n", "")
@@ -127,7 +130,7 @@ def get_faq_page():
 
     tag_is_p = False
     idx = 0
-    for element in doc.xpath('//h1 | //h2 | //p'):
+    for element in doc.xpath("//h1 | //h2 | //p"):
         tag = element.tag
         if tag != "p":
             tag = element.tag
@@ -144,27 +147,27 @@ def get_faq_page():
                 idx += 1
                 tag_is_p = True
             else:
-                last_el = faq_page_dict[idx-1]
+                last_el = faq_page_dict[idx - 1]
                 last_el["value"].append(element.text)
-                faq_page_dict[idx-1] = last_el
+                faq_page_dict[idx - 1] = last_el
                 tag_is_p = True
     return faq_page_dict
 
 
 def faq():
-    return tk.render('home/faq.html')
+    return tk.render("home/faq.html")
 
 
 def build_pages_nav_main(*args):
 
-    about_menu = tk.asbool(config.get('ckanext.pages.about_menu', True))
-    group_menu = tk.asbool(config.get('ckanext.pages.group_menu', True))
-    org_menu = tk.asbool(config.get('ckanext.pages.organization_menu', True))
+    about_menu = tk.asbool(config.get("ckanext.pages.about_menu", True))
+    group_menu = tk.asbool(config.get("ckanext.pages.group_menu", True))
+    org_menu = tk.asbool(config.get("ckanext.pages.organization_menu", True))
 
     # Different CKAN versions use different route names - gotta catch em all!
-    about_menu_routes = ['about', 'home.about']
-    group_menu_routes = ['group_index', 'home.group_index']
-    org_menu_routes = ['organizations.index', 'home.organizations.index']
+    about_menu_routes = ["about", "home.about"]
+    group_menu_routes = ["group_index", "home.group_index"]
+    org_menu_routes = ["organizations.index", "home.organizations.index"]
 
     new_args = []
     for arg in args:
@@ -176,65 +179,63 @@ def build_pages_nav_main(*args):
             continue
         new_args.append(arg)
 
-    output = h.build_nav_main(*new_args) 
+    output = h.build_nav_main(*new_args)
     # do not display any private datasets in menu even for sysadmins
-    pages_list = tk.get_action('ckanext_pages_list')(None, {'order': True, 'private': False})
+    pages_list = tk.get_action("ckanext_pages_list")(
+        None, {"order": True, "private": False}
+    )
 
-    page_name = ''
-    if tk.get_endpoint() in (('pages', 'pages_show'), ('pages', 'blog_show')):
-        page_name = tk.request.path.split('/')[-1]
-    #output = output + get_nav_transport()
+    page_name = ""
+    if tk.get_endpoint() in (("pages", "pages_show"), ("pages", "blog_show")):
+        page_name = tk.request.path.split("/")[-1]
+    # output = output + get_nav_transport()
     for page in pages_list:
-        type_ = 'blog' if page['page_type'] == 'blog' else 'pages'
-        name = urllib.parse.quote(page['name'].encode('utf-8')) #.decode('utf-8')
-        title = cgi.escape(page['title'])
-        link = h.literal(u'<a href="/{}/{}">{}</a>'.format(type_, name, title))
-        if page['name'] == page_name:
-            li = h.literal('<li class="active">') + link + h.literal('</li>')
+        type_ = "blog" if page["page_type"] == "blog" else "pages"
+        name = urllib.parse.quote(page["name"].encode("utf-8"))  # .decode('utf-8')
+        title = cgi.escape(page["title"])
+        link = h.literal('<a href="/{}/{}">{}</a>'.format(type_, name, title))
+        if page["name"] == page_name:
+            li = h.literal('<li class="active">') + link + h.literal("</li>")
         else:
-            li = h.literal('<li>') + link + h.literal('</li>')
+            li = h.literal("<li>") + link + h.literal("</li>")
         output = output + li
 
-    return  output 
-
+    return output
 
 
 def get_facet_description(facet_name):
     facet_description = {
-        
-        'organization': tk._('Datenbereitstellende Institutionen'),
-        'groups': tk._('Nach CKAN standardisierte Datenkategorien'),
-        'tags': tk._('Selbstgewählte Schlagworte'),
-        'res_format': tk._('Zur Auswahl stehende Dateiformate'),
-        'license_id': tk._('Rechtliche Vorgaben zur Nutzung der Daten'), 
-        'date_filters': tk._('Filter nach Erstellungsdatum der Daten'),
-        'frequency': tk._('Frequenz'),
-        'source_type': tk._('Quelle Typ')
-        }
+        "organization": tk._("Datenbereitstellende Institutionen"),
+        "groups": tk._("Nach CKAN standardisierte Datenkategorien"),
+        "tags": tk._("Selbstgewählte Schlagworte"),
+        "res_format": tk._("Zur Auswahl stehende Dateiformate"),
+        "license_id": tk._("Rechtliche Vorgaben zur Nutzung der Daten"),
+        "date_filters": tk._("Filter nach Erstellungsdatum der Daten"),
+        "frequency": tk._("Frequenz"),
+        "source_type": tk._("Quelle Typ"),
+    }
     return facet_description[facet_name]
 
+
 def get_cookie_control_config():
 
-        cookie_control_config = {}
+    cookie_control_config = {}
 
-        api_key = tk.config.get(
-            'ckanext.rvr.cc.api_key', '8740495678e47134ca596e8ec7e65d2ca3522b63')
-        cookie_control_config['api_key'] = api_key 
+    api_key = tk.config.get(
+        "ckanext.rvr.cc.api_key", "8740495678e47134ca596e8ec7e65d2ca3522b63"
+    )
+    cookie_control_config["api_key"] = api_key
 
-        license_type = tk.config.get(
-            'ckanext.rvr.cc.license_type', 'COMMUNITY')
-        cookie_control_config['license_type'] = license_type
+    license_type = tk.config.get("ckanext.rvr.cc.license_type", "COMMUNITY")
+    cookie_control_config["license_type"] = license_type
 
-        popup_position = tk.config.get(
-            'ckanext.rvr.cc.popup_position', 'LEFT')
-        cookie_control_config['popup_position'] = popup_position
+    popup_position = tk.config.get("ckanext.rvr.cc.popup_position", "LEFT")
+    cookie_control_config["popup_position"] = popup_position
 
-        theme_color = tk.config.get(
-            'ckanext.rvr.cc.theme_color', 'DARK')
-        cookie_control_config['theme_color'] = theme_color
+    theme_color = tk.config.get("ckanext.rvr.cc.theme_color", "DARK")
+    cookie_control_config["theme_color"] = theme_color
 
-        initial_state = tk.config.get(
-            'ckanext.rvr.cc.initial_state', 'OPEN')
-        cookie_control_config['initial_state'] = initial_state
+    initial_state = tk.config.get("ckanext.rvr.cc.initial_state", "OPEN")
+    cookie_control_config["initial_state"] = initial_state
 
-        return cookie_control_config
+    return cookie_control_config
diff --git a/ckanext/rvr/plugin.py b/ckanext/rvr/plugin.py
index 15e2547..b9dd7a5 100644
--- a/ckanext/rvr/plugin.py
+++ b/ckanext/rvr/plugin.py
@@ -19,7 +19,8 @@
 log = logging.getLogger(__name__)
 
 config = tk.config
-ignore_missing = tk.get_validator('ignore_missing')
+ignore_missing = tk.get_validator("ignore_missing")
+
 
 class RvrPlugin(p.SingletonPlugin, tk.DefaultDatasetForm, DefaultTranslation):
     p.implements(p.ITranslation)
@@ -30,45 +31,41 @@ class RvrPlugin(p.SingletonPlugin, tk.DefaultDatasetForm, DefaultTranslation):
     p.implements(p.IBlueprint)
     p.implements(p.IActions)
 
-    schema_options = { 
-        'default': [
-            tk.get_validator('ignore_missing'),
-            tk.get_converter('convert_to_extras')
+    schema_options = {
+        "default": [
+            tk.get_validator("ignore_missing"),
+            tk.get_converter("convert_to_extras"),
         ],
-        'not_empty': [tk.get_validator('not_empty')]
+        "not_empty": [tk.get_validator("not_empty")],
     }
 
-
     # IBlueprint
     def get_blueprint(self):
-        return [
-            dataset_blueprint
-        ]
+        return [dataset_blueprint]
 
-    
     # IConfigurer
     def update_config(self, config_):
-        tk.add_template_directory(config_, 'templates')
-        tk.add_public_directory(config_, 'public')
-        tk.add_resource('assets', 'rvr')
+        tk.add_template_directory(config_, "templates")
+        tk.add_public_directory(config_, "public")
+        tk.add_resource("assets", "rvr")
 
     # ITemplateHelpers
     def get_helpers(self):
-        '''
+        """
         Register template helper functions.
-        '''
+        """
         return {
-            'get_newest_datasets': rvrHelpers.get_newest_datasets,
-            'build_nav_main': rvrHelpers.build_pages_nav_main,
-            'get_specific_page': rvrHelpers.get_specific_page,
-            'get_faq_page': rvrHelpers.get_faq_page,
-            'get_facet_description': rvrHelpers.get_facet_description,
-            'get_cookie_control_config': rvrHelpers.get_cookie_control_config
+            "get_newest_datasets": rvrHelpers.get_newest_datasets,
+            "build_nav_main": rvrHelpers.build_pages_nav_main,
+            "get_specific_page": rvrHelpers.get_specific_page,
+            "get_faq_page": rvrHelpers.get_faq_page,
+            "get_facet_description": rvrHelpers.get_facet_description,
+            "get_cookie_control_config": rvrHelpers.get_cookie_control_config,
         }
-    
+
     # IBlueprint
     def get_blueprint(self):
-        '''Return a Flask blueprint to be registered in the app.'''
+        """Return a Flask blueprint to be registered in the app."""
         return rvrViews.get_rvr_blueprint()
 
     # IDatasetForm
@@ -76,26 +73,30 @@ def create_package_schema(self):
         # let's grab the default schema in our pluginWS
         schema = super(RvrPlugin, self).create_package_schema()
         # our custom field
-        schema.update({
-            'notes': self.schema_options['not_empty'],
-            'owner_org': self.schema_options['not_empty'],
-            'dataset_spatial': self.schema_options['default'],
-            'spatial': self.schema_options['default']
-        })
+        schema.update(
+            {
+                "notes": self.schema_options["not_empty"],
+                "owner_org": self.schema_options["not_empty"],
+                "dataset_spatial": self.schema_options["default"],
+                "spatial": self.schema_options["default"],
+            }
+        )
         return schema
 
     def update_package_schema(self):
         # let's grab the default schema in our plugin
         schema = super(RvrPlugin, self).update_package_schema()
         # our custom field
-        schema.update({
-            'notes': self.schema_options['not_empty'],
-            'owner_org': self.schema_options['not_empty'],
-            'dataset_spatial': self.schema_options['default'],
-            'spatial': self.schema_options['default']
-        })
+        schema.update(
+            {
+                "notes": self.schema_options["not_empty"],
+                "owner_org": self.schema_options["not_empty"],
+                "dataset_spatial": self.schema_options["default"],
+                "spatial": self.schema_options["default"],
+            }
+        )
         return schema
-        
+
     def is_fallback(self):
         # Return True to register this plugin as the default handler for
         # package types not handled by any other IDatasetForm plugin.
@@ -105,24 +106,24 @@ def package_types(self):
         # This plugin doesn't handle any special package types, it just
         # registers itself as the default (above).
         return []
-    
-    #IFacets
+
+    # IFacets
     def dataset_facets(self, facets_dict, package_type):
-        '''
+        """
         Override core search fasets for datasets
-        '''
-        facets_dict['date_filters'] = "Datumsfilter"
+        """
+        facets_dict["date_filters"] = "Datumsfilter"
         return facets_dict
 
     # IActions
     def get_actions(self):
-        '''
+        """
         Define custom functions (or override existing ones).
         Available via API /api/action/{action-name}
-        '''
+        """
         return {
-            'package_search': rvrActions.package_search,
-            'package_show': rvrActions.package_show
+            "package_search": rvrActions.package_search,
+            "package_show": rvrActions.package_show,
         }
 
 
@@ -137,9 +138,7 @@ def get_commands(self):
 
     # ITemplateHelpers
     def get_helpers(self):
-        return {
-            'is_valid_spatial': is_valid_spatial
-        }
+        return {"is_valid_spatial": is_valid_spatial}
 
     # IBlueprint
     def get_blueprint(self):
@@ -149,26 +148,41 @@ def is_fallback(self):
         return False
 
     def group_types(self):
-        return ('organization',)
+        return ("organization",)
 
     # IGroupForm
     def form_to_db_schema(self):
         schema = ckan_schema.group_form_schema()
-        schema.update({'org_spatial' : [tk.get_validator('ignore_missing'),
-                                        tk.get_converter('convert_to_extras')]})
+        schema.update(
+            {
+                "org_spatial": [
+                    tk.get_validator("ignore_missing"),
+                    tk.get_converter("convert_to_extras"),
+                ]
+            }
+        )
         return schema
 
     def db_to_form_schema(self):
         schema = ckan_schema.default_show_group_schema()
-        schema.update({'org_spatial' : [tk.get_validator('ignore_missing'),
-                                        tk.get_converter('convert_to_extras')]})
+        schema.update(
+            {
+                "org_spatial": [
+                    tk.get_validator("ignore_missing"),
+                    tk.get_converter("convert_to_extras"),
+                ]
+            }
+        )
         return schema
 
-    def group_form(self, group_type='organization'):
-        return 'organization/snippets/organization_form.html'
+    def group_form(self, group_type="organization"):
+        return "organization/snippets/organization_form.html"
+
     def configure(self, config):
-        self.search_backend = config.get('ckanext.spatial.search_backend', 'postgis')
-        if self.search_backend != 'postgis' and not tk.check_ckan_version('2.0.1'):
-            msg = 'The Solr backends for the spatial search require CKAN 2.0.1 or higher. ' + \
-                  'Please upgrade CKAN or select the \'postgis\' backend.'
+        self.search_backend = config.get("ckanext.spatial.search_backend", "postgis")
+        if self.search_backend != "postgis" and not tk.check_ckan_version("2.0.1"):
+            msg = (
+                "The Solr backends for the spatial search require CKAN 2.0.1 or higher. "
+                + "Please upgrade CKAN or select the 'postgis' backend."
+            )
             raise tk.CkanVersionException(msg)
diff --git a/ckanext/rvr/tests/test_plugin.py b/ckanext/rvr/tests/test_plugin.py
index 133c431..eb05813 100644
--- a/ckanext/rvr/tests/test_plugin.py
+++ b/ckanext/rvr/tests/test_plugin.py
@@ -1,5 +1,7 @@
 """Tests for plugin.py."""
+
 import ckanext.rvr.plugin as plugin
 
+
 def test_plugin():
-    pass
\ No newline at end of file
+    pass
diff --git a/ckanext/rvr/views/dataset.py b/ckanext/rvr/views/dataset.py
index 80e625e..d4b0e68 100644
--- a/ckanext/rvr/views/dataset.py
+++ b/ckanext/rvr/views/dataset.py
@@ -19,7 +19,14 @@
 from ckan.common import _, config, g, request
 from ckan.lib.plugins import lookup_package_plugin
 from ckan.lib.search import SearchError, SearchQueryError, SearchIndexError
-from ckan.views.dataset import CreateView, EditView, _get_package_type, _tag_string_to_list, _form_save_redirect, CACHE_PARAMETERS
+from ckan.views.dataset import (
+    CreateView,
+    EditView,
+    _get_package_type,
+    _tag_string_to_list,
+    _form_save_redirect,
+    CACHE_PARAMETERS,
+)
 import ckan.lib.navl.dictization_functions as dict_fns
 from ckanext.rvr.helpers import is_valid_spatial, get_org_spatial
 
@@ -37,11 +44,13 @@
 log = logging.getLogger(__name__)
 
 dataset_blueprint = Blueprint(
-    'rvr_dataset', __name__,
-    url_prefix=u'/dataset',
-    url_defaults={u'package_type': u'dataset'}
+    "rvr_dataset",
+    __name__,
+    url_prefix="/dataset",
+    url_defaults={"package_type": "dataset"},
 )
 
+
 def _setup_template_variables(context, data_dict, package_type=None):
     return lookup_package_plugin(package_type).setup_template_variables(
         context, data_dict
@@ -54,47 +63,44 @@ def _get_pkg_template(template_type, package_type=None):
     try:
         return method(package_type)
     except TypeError as err:
-        if u'takes 1' not in str(err) and u'takes exactly 1' not in str(err):
+        if "takes 1" not in str(err) and "takes exactly 1" not in str(err):
             raise
         return method()
 
 
 def _encode_params(params):
-    return [(k, v.encode(u'utf-8') if isinstance(v, string_types) else str(v))
-            for k, v in params]
+    return [
+        (k, v.encode("utf-8") if isinstance(v, string_types) else str(v))
+        for k, v in params
+    ]
 
 
 def url_with_params(url, params):
     params = _encode_params(params)
-    return url + u'?' + urlencode(params)
+    return url + "?" + urlencode(params)
 
 
 def search_url(params, package_type=None):
     if not package_type:
-        package_type = u'dataset'
-    url = h.url_for(u'{0}.search'.format(package_type))
+        package_type = "dataset"
+    url = h.url_for("{0}.search".format(package_type))
     return url_with_params(url, params)
 
 
 def drill_down_url(alternative_url=None, **by):
     return h.add_url_param(
         alternative_url=alternative_url,
-        controller=u'dataset',
-        action=u'search',
-        new_params=by
+        controller="dataset",
+        action="search",
+        new_params=by,
     )
 
 
 def remove_field(package_type, key, value=None, replace=None):
     if not package_type:
-        package_type = u'dataset'
-    url = h.url_for(u'{0}.search'.format(package_type))
-    return h.remove_url_param(
-        key,
-        value=value,
-        replace=replace,
-        alternative_url=url
-    )
+        package_type = "dataset"
+    url = h.url_for("{0}.search".format(package_type))
+    return h.remove_url_param(key, value=value, replace=replace, alternative_url=url)
 
 
 def _sort_by(params_nosort, package_type, fields):
@@ -107,18 +113,19 @@ def _sort_by(params_nosort, package_type, fields):
     params = params_nosort[:]
 
     if fields:
-        sort_string = u', '.join(u'%s %s' % f for f in fields)
-        params.append((u'sort', sort_string))
+        sort_string = ", ".join("%s %s" % f for f in fields)
+        params.append(("sort", sort_string))
     return search_url(params, package_type)
 
 
 def _pager_url(params_nopage, package_type, q=None, page=None):
     params = list(params_nopage)
-    params.append((u'page', page))
+    params.append(("page", page))
     return search_url(params, package_type)
 
+
 def _get_search_details():
-    fq = u''
+    fq = ""
 
     # fields_grouped will contain a dict of params containing
     # a list of values eg {u'tags':[u'tag1', u'tag2']}
@@ -127,12 +134,15 @@ def _get_search_details():
     fields_grouped = {}
     search_extras = MultiDict()
 
-    for (param, value) in request.args.items(multi=True):
-        if param not in [u'q', u'page', u'sort'] \
-                and len(value) and not param.startswith(u'_'):
-            if not param.startswith(u'ext_'):
+    for param, value in request.args.items(multi=True):
+        if (
+            param not in ["q", "page", "sort"]
+            and len(value)
+            and not param.startswith("_")
+        ):
+            if not param.startswith("ext_"):
                 fields.append((param, value))
-                fq += u' %s:"%s"' % (param, value)
+                fq += ' %s:"%s"' % (param, value)
                 if param not in fields_grouped:
                     fields_grouped[param] = [value]
                 else:
@@ -140,123 +150,115 @@ def _get_search_details():
             else:
                 search_extras.update({param: value})
 
-    search_extras = dict([
-        (k, v[0]) if len(v) == 1 else (k, v)
-        for k, v in search_extras.lists()
-    ])
+    search_extras = dict(
+        [(k, v[0]) if len(v) == 1 else (k, v) for k, v in search_extras.lists()]
+    )
     return {
-        u'fields': fields,
-        u'fields_grouped': fields_grouped,
-        u'fq': fq,
-        u'search_extras': search_extras,
+        "fields": fields,
+        "fields_grouped": fields_grouped,
+        "fq": fq,
+        "search_extras": search_extras,
     }
 
+
 def search(package_type):
     extra_vars = {}
 
     try:
-        context = {
-            u'model': model,
-            u'user': g.user,
-            u'auth_user_obj': g.userobj
-        }
-        check_access(u'site_read', context)
+        context = {"model": model, "user": g.user, "auth_user_obj": g.userobj}
+        check_access("site_read", context)
     except NotAuthorized:
-        base.abort(403, _(u'Not authorized to see this page'))
+        base.abort(403, _("Not authorized to see this page"))
 
     # unicode format (decoded from utf8)
-    extra_vars[u'q'] = q = request.args.get(u'q', u'')
+    extra_vars["q"] = q = request.args.get("q", "")
 
     # Get Active date range filter
-    active_range = request.args.get('_active_range')
+    active_range = request.args.get("_active_range")
     # Get Daterange fields
     dateranges = {
-        'metadata_created': {
-            'title': 'erstellt',
-            'params': [
-                request.args.get('_metadata_created_start', ''),
-                request.args.get('_metadata_created_end', '')
-            ]
+        "metadata_created": {
+            "title": "erstellt",
+            "params": [
+                request.args.get("_metadata_created_start", ""),
+                request.args.get("_metadata_created_end", ""),
+            ],
         },
-        'metadata_modified': {
-            'title': 'zuletzt aktualisiert',
-            'params': [
-                request.args.get('_metadata_modified_start', ''),
-                request.args.get('_metadata_modified_end', '')
-            ]
+        "metadata_modified": {
+            "title": "zuletzt aktualisiert",
+            "params": [
+                request.args.get("_metadata_modified_start", ""),
+                request.args.get("_metadata_modified_end", ""),
+            ],
         },
-        'issued': {
-            'title': 'veröffentlicht',
-            'params': [
-                request.args.get('_issued_start', ''),
-                request.args.get('_issued_end', '')
+        "issued": {
+            "title": "veröffentlicht",
+            "params": [
+                request.args.get("_issued_start", ""),
+                request.args.get("_issued_end", ""),
+            ],
+        },
+        "modified": {
+            "title": "zuletzt geändert",
+            "params": [
+                request.args.get("_modified_start", ""),
+                request.args.get("_modified_end", ""),
             ],
         },
-        'modified': {
-            'title': 'zuletzt geändert',
-            'params': [
-                request.args.get('_modified_start', ''),
-                request.args.get('_modified_end', '')
-            ]
-        }
     }
     # Set default if a valid active_range was not sent by the user
     if active_range not in dateranges.keys():
-        active_range = 'metadata_created'
+        active_range = "metadata_created"
     # Generate date range options list to be sent to the client
     daterange_options = []
     for k, v in dateranges.items():
-        daterange_options.append({
-            'name': k,
-            'title': v['title']
-        })
+        daterange_options.append({"name": k, "title": v["title"]})
 
-    extra_vars['query_error'] = False
+    extra_vars["query_error"] = False
     page = h.get_page_number(request.args)
 
-    limit = int(config.get(u'ckan.datasets_per_page', 20))
+    limit = int(config.get("ckan.datasets_per_page", 20))
 
     # most search operations should reset the page counter:
-    params_nopage = [(k, v) for k, v in request.args.items(multi=True)
-                     if k != u'page']
+    params_nopage = [(k, v) for k, v in request.args.items(multi=True) if k != "page"]
 
-    extra_vars[u'drill_down_url'] = drill_down_url
-    extra_vars[u'remove_field'] = partial(remove_field, package_type)
+    extra_vars["drill_down_url"] = drill_down_url
+    extra_vars["remove_field"] = partial(remove_field, package_type)
 
-    sort_by = request.args.get(u'sort', None)
-    params_nosort = [(k, v) for k, v in params_nopage if k != u'sort']
+    sort_by = request.args.get("sort", None)
+    params_nosort = [(k, v) for k, v in params_nopage if k != "sort"]
 
-    extra_vars[u'sort_by'] = partial(_sort_by, params_nosort, package_type)
+    extra_vars["sort_by"] = partial(_sort_by, params_nosort, package_type)
 
     if not sort_by:
         sort_by_fields = []
     else:
-        sort_by_fields = [field.split()[0] for field in sort_by.split(u',')]
-    extra_vars[u'sort_by_fields'] = sort_by_fields
+        sort_by_fields = [field.split()[0] for field in sort_by.split(",")]
+    extra_vars["sort_by_fields"] = sort_by_fields
 
     pager_url = partial(_pager_url, params_nopage, package_type)
 
     search_url_params = urlencode(_encode_params(params_nopage))
-    extra_vars[u'search_url_params'] = search_url_params
+    extra_vars["search_url_params"] = search_url_params
 
     details = _get_search_details()
-    extra_vars[u'fields'] = details[u'fields']
-    extra_vars[u'fields_grouped'] = details[u'fields_grouped']
-    fq = details[u'fq']
-    search_extras = details[u'search_extras']
+    extra_vars["fields"] = details["fields"]
+    extra_vars["fields_grouped"] = details["fields_grouped"]
+    fq = details["fq"]
+    search_extras = details["search_extras"]
 
     context = {
-        u'model': model,
-        u'session': model.Session,
-        u'user': g.user,
-        u'for_view': True,
-        u'auth_user_obj': g.userobj
+        "model": model,
+        "session": model.Session,
+        "user": g.user,
+        "for_view": True,
+        "auth_user_obj": g.userobj,
     }
 
     # Unless changed via config options, don't show other dataset
     # types any search page. Potential alternatives are do show them
     # on the default search page (dataset) or on one other search page
-    search_all_type = config.get(u'ckan.search.show_all_types', u'dataset')
+    search_all_type = config.get("ckan.search.show_all_types", "dataset")
     search_all = False
 
     try:
@@ -264,23 +266,23 @@ def search(package_type):
         # and we know that no type was specified, so use traditional
         # behaviour of applying this only to dataset type
         search_all = asbool(search_all_type)
-        search_all_type = u'dataset'
+        search_all_type = "dataset"
     # Otherwise we treat as a string representing a type
     except ValueError:
         search_all = True
 
     if not search_all or package_type != search_all_type:
         # Only show datasets of this particular type
-        fq += u' +dataset_type:{type}'.format(type=package_type)
+        fq += " +dataset_type:{type}".format(type=package_type)
 
     facets = OrderedDict()
 
     default_facet_titles = {
-        u'organization': _(u'Organizations'),
-        u'groups': _(u'Groups'),
-        u'tags': _(u'Tags'),
-        u'res_format': _(u'Formats'),
-        u'license_id': _(u'Licenses'),
+        "organization": _("Organizations"),
+        "groups": _("Groups"),
+        "tags": _("Tags"),
+        "res_format": _("Formats"),
+        "license_id": _("Licenses"),
     }
 
     for facet in h.facets():
@@ -293,96 +295,95 @@ def search(package_type):
     for plugin in plugins.PluginImplementations(plugins.IFacets):
         facets = plugin.dataset_facets(facets, package_type)
 
-    extra_vars[u'facet_titles'] = facets
+    extra_vars["facet_titles"] = facets
     data_dict = {
-        u'q': q,
-        u'fq': fq.strip(),
-        u'facet.field': list(facets.keys()),
-        u'facet.limit': -1,
-        u'rows': limit,
-        u'start': (page - 1) * limit,
-        u'sort': sort_by,
-        u'extras': search_extras,
-        u'include_private': asbool(
-            config.get(u'ckan.search.default_include_private', True)
+        "q": q,
+        "fq": fq.strip(),
+        "facet.field": list(facets.keys()),
+        "facet.limit": -1,
+        "rows": limit,
+        "start": (page - 1) * limit,
+        "sort": sort_by,
+        "extras": search_extras,
+        "include_private": asbool(
+            config.get("ckan.search.default_include_private", True)
         ),
-        u'dateranges': dateranges
+        "dateranges": dateranges,
     }
 
     try:
-        query = get_action(u'package_search')(context, data_dict)
+        query = get_action("package_search")(context, data_dict)
 
-        extra_vars[u'sort_by_selected'] = query[u'sort']
+        extra_vars["sort_by_selected"] = query["sort"]
 
-        extra_vars[u'page'] = h.Page(
-            collection=query[u'results'],
+        extra_vars["page"] = h.Page(
+            collection=query["results"],
             page=page,
             url=pager_url,
-            item_count=query[u'count'],
-            items_per_page=limit
+            item_count=query["count"],
+            items_per_page=limit,
         )
-        extra_vars[u'search_facets'] = query[u'search_facets']
-        extra_vars[u'page'].items = query[u'results']
-        extra_vars[u'dateranges'] = dateranges
-        extra_vars[u'active_range'] = active_range
-        extra_vars[u'daterange_options'] = daterange_options
+        extra_vars["search_facets"] = query["search_facets"]
+        extra_vars["page"].items = query["results"]
+        extra_vars["dateranges"] = dateranges
+        extra_vars["active_range"] = active_range
+        extra_vars["daterange_options"] = daterange_options
     except SearchQueryError as se:
         # User's search parameters are invalid, in such a way that is not
         # achievable with the web interface, so return a proper error to
         # discourage spiders which are the main cause of this.
-        log.info(u'Dataset search query rejected: %r', se.args)
+        log.info("Dataset search query rejected: %r", se.args)
         base.abort(
             400,
-            _(u'Invalid search query: {error_message}')
-            .format(error_message=str(se))
+            _("Invalid search query: {error_message}").format(error_message=str(se)),
         )
     except SearchError as se:
         # May be bad input from the user, but may also be more serious like
         # bad code causing a SOLR syntax error, or a problem connecting to
         # SOLR
-        log.error(u'Dataset search error: %r', se.args)
-        extra_vars[u'query_error'] = True
-        extra_vars[u'search_facets'] = {}
-        extra_vars[u'page'] = h.Page(collection=[])
+        log.error("Dataset search error: %r", se.args)
+        extra_vars["query_error"] = True
+        extra_vars["search_facets"] = {}
+        extra_vars["page"] = h.Page(collection=[])
 
     # FIXME: try to avoid using global variables
     g.search_facets_limits = {}
-    for facet in extra_vars[u'search_facets'].keys():
+    for facet in extra_vars["search_facets"].keys():
         try:
             limit = 0
         except ValueError:
             base.abort(
                 400,
-                _(u'Parameter u"{parameter_name}" is not '
-                  u'an integer').format(parameter_name=u'_%s_limit' % facet)
+                _('Parameter u"{parameter_name}" is not ' "an integer").format(
+                    parameter_name="_%s_limit" % facet
+                ),
             )
 
         g.search_facets_limits[facet] = 0
 
     _setup_template_variables(context, {}, package_type=package_type)
 
-    extra_vars[u'dataset_type'] = package_type
+    extra_vars["dataset_type"] = package_type
 
     # TODO: remove
     for key, value in six.iteritems(extra_vars):
         setattr(g, key, value)
 
-    return base.render(
-        _get_pkg_template(u'search_template', package_type), extra_vars
-    )
+    return base.render(_get_pkg_template("search_template", package_type), extra_vars)
+
 
 def _group_string_to_list(group_string):
-    """This is used to change groups from a string to a list of dicts.
-    """
+    """This is used to change groups from a string to a list of dicts."""
     out = []
-    for group in group_string.split(u'___'):
-     group = group.strip()
-     if group:
-         # Get the group from the database
-         group_item = {"id": group}
-         out.append(group_item)
+    for group in group_string.split("___"):
+        group = group.strip()
+        if group:
+            # Get the group from the database
+            group_item = {"id": group}
+            out.append(group_item)
     return out
 
+
 class RvrCreateView(CreateView):
     def post(self, package_type):
         # The staged add dataset used the new functionality when the dataset is
@@ -390,91 +391,80 @@ def post(self, package_type):
         # this is a real new.
         context = self._prepare()
         is_an_update = False
-        ckan_phase = request.form.get(u'_ckan_phase')
+        ckan_phase = request.form.get("_ckan_phase")
         try:
             data_dict = clean_dict(
                 dict_fns.unflatten(tuplize_dict(parse_params(request.form)))
             )
         except dict_fns.DataError:
-            return base.abort(400, _(u'Integrity Error'))
+            return base.abort(400, _("Integrity Error"))
         try:
             if ckan_phase:
                 # prevent clearing of groups etc
-                context[u'allow_partial_update'] = True
+                context["allow_partial_update"] = True
                 # sort the tags
-                if u'tag_string' in data_dict:
-                    data_dict[u'tags'] = _tag_string_to_list(
-                        data_dict[u'tag_string']
-                    )
-                if data_dict.get(u'pkg_name'):
+                if "tag_string" in data_dict:
+                    data_dict["tags"] = _tag_string_to_list(data_dict["tag_string"])
+                if data_dict.get("pkg_name"):
                     is_an_update = True
                     # This is actually an update not a save
-                    data_dict[u'id'] = data_dict[u'pkg_name']
-                    del data_dict[u'pkg_name']
+                    data_dict["id"] = data_dict["pkg_name"]
+                    del data_dict["pkg_name"]
                     # don't change the dataset state
-                    data_dict[u'state'] = u'draft'
+                    data_dict["state"] = "draft"
                     # this is actually an edit not a save
-                    pkg_dict = get_action(u'package_update')(
-                        context, data_dict
-                    )
+                    pkg_dict = get_action("package_update")(context, data_dict)
 
                     # redirect to add dataset resources
                     url = h.url_for(
-                        u'{}_resource.new'.format(package_type),
-                        id=pkg_dict[u'name']
+                        "{}_resource.new".format(package_type), id=pkg_dict["name"]
                     )
                     return h.redirect_to(url)
                 # Make sure we don't index this dataset
-                if request.form[u'save'] not in [
-                    u'go-resource', u'go-metadata'
-                ]:
-                    data_dict[u'state'] = u'draft'
+                if request.form["save"] not in ["go-resource", "go-metadata"]:
+                    data_dict["state"] = "draft"
                 # allow the state to be changed
-                context[u'allow_state_change'] = True
+                context["allow_state_change"] = True
 
-            data_dict[u'type'] = package_type
-            context[u'message'] = data_dict.get(u'log_message', u'')
+            data_dict["type"] = package_type
+            context["message"] = data_dict.get("log_message", "")
 
             # If the dataset has a spatial and it is valid, make it the default
-            spatial = data_dict.get('spatial', '')
-            dataset_spatial = data_dict.get('dataset_spatial', '')
+            spatial = data_dict.get("spatial", "")
+            dataset_spatial = data_dict.get("dataset_spatial", "")
             if is_valid_spatial(dataset_spatial) and spatial != dataset_spatial:
-                data_dict['spatial'] = dataset_spatial
+                data_dict["spatial"] = dataset_spatial
             else:
                 # if the organization has a spatial, use that
-                data_dict['spatial'] = ''
-                if data_dict.get('owner_org', None):
-                    org_spatial = get_org_spatial(data_dict['owner_org'])
+                data_dict["spatial"] = ""
+                if data_dict.get("owner_org", None):
+                    org_spatial = get_org_spatial(data_dict["owner_org"])
                     if org_spatial:
-                        data_dict['spatial'] = org_spatial
-            if u'group_string' in data_dict:
-                data_dict[u'groups'] = _group_string_to_list(
-                data_dict[u'group_string']
-                )            
-            pkg_dict = get_action(u'package_create')(context, data_dict)
+                        data_dict["spatial"] = org_spatial
+            if "group_string" in data_dict:
+                data_dict["groups"] = _group_string_to_list(data_dict["group_string"])
+            pkg_dict = get_action("package_create")(context, data_dict)
 
             if ckan_phase:
                 # redirect to add dataset resources
                 url = h.url_for(
-                    u'{}_resource.new'.format(package_type),
-                    id=pkg_dict[u'name']
+                    "{}_resource.new".format(package_type), id=pkg_dict["name"]
                 )
                 return h.redirect_to(url)
             return _form_save_redirect(
-                pkg_dict[u'name'], u'new', package_type=package_type
+                pkg_dict["name"], "new", package_type=package_type
             )
         except NotAuthorized:
-            return base.abort(403, _(u'Unauthorized to read package'))
+            return base.abort(403, _("Unauthorized to read package"))
         except NotFound as e:
-            return base.abort(404, _(u'Dataset not found'))
+            return base.abort(404, _("Dataset not found"))
         except SearchIndexError as e:
             try:
                 exc_str = str(repr(e.args))
             except Exception:  # We don't like bare excepts
                 exc_str = str(str(e))
             return base.abort(
-                500,
-                _(u'Unable to add package to search index.') + exc_str
+                500, _("Unable to add package to search index.") + exc_str
             )
         except ValidationError as e:
             errors = e.error_dict
@@ -482,63 +472,55 @@ def post(self, package_type):
             if is_an_update:
                 # we need to get the state of the dataset to show the stage we
                 # are on.
-                pkg_dict = get_action(u'package_show')(context, data_dict)
-                data_dict[u'state'] = pkg_dict[u'state']
+                pkg_dict = get_action("package_show")(context, data_dict)
+                data_dict["state"] = pkg_dict["state"]
                 return EditView().get(
-                    package_type,
-                    data_dict[u'id'],
-                    data_dict,
-                    errors,
-                    error_summary
+                    package_type, data_dict["id"], data_dict, errors, error_summary
                 )
-            data_dict[u'state'] = u'none'
+            data_dict["state"] = "none"
             return self.get(package_type, data_dict, errors, error_summary)
 
     def get(self, package_type, data=None, errors=None, error_summary=None):
         context = self._prepare()
-        if data and u'type' in data:
-            package_type = data[u'type']
+        if data and "type" in data:
+            package_type = data["type"]
 
         data = data or clean_dict(
             dict_fns.unflatten(
-                tuplize_dict(
-                    parse_params(request.args, ignore_keys=CACHE_PARAMETERS)
-                )
+                tuplize_dict(parse_params(request.args, ignore_keys=CACHE_PARAMETERS))
             )
         )
-        resources_json = h.json.dumps(data.get(u'resources', []))
+        resources_json = h.json.dumps(data.get("resources", []))
         # convert tags if not supplied in data
-        if data and not data.get(u'tag_string'):
-            data[u'tag_string'] = u', '.join(
-                h.dict_list_reduce(data.get(u'tags', {}), u'name')
+        if data and not data.get("tag_string"):
+            data["tag_string"] = ", ".join(
+                h.dict_list_reduce(data.get("tags", {}), "name")
             )
 
         errors = errors or {}
         error_summary = error_summary or {}
         # in the phased add dataset we need to know that
         # we have already completed stage 1
-        stage = [u'active']
-        if data.get(u'state', u'').startswith(u'draft'):
-            stage = [u'active', u'complete']
+        stage = ["active"]
+        if data.get("state", "").startswith("draft"):
+            stage = ["active", "complete"]
 
         # if we are creating from a group then this allows the group to be
         # set automatically
-        data[
-            u'group_id'
-        ] = request.args.get(u'group') or request.args.get(u'groups__0__id')
-
-        form_snippet = _get_pkg_template(
-            u'package_form', package_type=package_type
+        data["group_id"] = request.args.get("group") or request.args.get(
+            "groups__0__id"
         )
 
+        form_snippet = _get_pkg_template("package_form", package_type=package_type)
+
         form_vars = {
-            u'data': data,
-            u'errors': errors,
-            u'error_summary': error_summary,
-            u'action': u'new',
-            u'stage': stage,
-            u'dataset_type': package_type,
-            u'form_style': u'new'
+            "data": data,
+            "errors": errors,
+            "error_summary": error_summary,
+            "action": "new",
+            "stage": stage,
+            "dataset_type": package_type,
+            "form_style": "new",
         }
         errors_json = h.json.dumps(errors)
 
@@ -548,139 +530,123 @@ def get(self, package_type, data=None, errors=None, error_summary=None):
 
         _setup_template_variables(context, {}, package_type=package_type)
 
-        new_template = _get_pkg_template(u'new_template', package_type)
+        new_template = _get_pkg_template("new_template", package_type)
         return base.render(
             new_template,
             extra_vars={
-                u'form_vars': form_vars,
-                u'form_snippet': form_snippet,
-                u'dataset_type': package_type,
-                u'resources_json': resources_json,
-                u'form_snippet': form_snippet,
-                u'errors_json': errors_json
-            }
+                "form_vars": form_vars,
+                "form_snippet": form_snippet,
+                "dataset_type": package_type,
+                "resources_json": resources_json,
+                "form_snippet": form_snippet,
+                "errors_json": errors_json,
+            },
         )
 
+
 class RvrEditView(EditView):
     def post(self, package_type, id):
         context = self._prepare()
         package_type = _get_package_type(id) or package_type
-        log.debug(u'Package save request name: %s POST: %r', id, request.form)
+        log.debug("Package save request name: %s POST: %r", id, request.form)
         try:
             data_dict = clean_dict(
                 dict_fns.unflatten(tuplize_dict(parse_params(request.form)))
             )
         except dict_fns.DataError:
-            return base.abort(400, _(u'Integrity Error'))
+            return base.abort(400, _("Integrity Error"))
         try:
-            if u'_ckan_phase' in data_dict:
+            if "_ckan_phase" in data_dict:
                 # we allow partial updates to not destroy existing resources
-                context[u'allow_partial_update'] = True
-                if u'tag_string' in data_dict:
-                    data_dict[u'tags'] = _tag_string_to_list(
-                        data_dict[u'tag_string']
-                    )
-                del data_dict[u'_ckan_phase']
-                del data_dict[u'save']
-            context[u'message'] = data_dict.get(u'log_message', u'')
-            data_dict['id'] = id
+                context["allow_partial_update"] = True
+                if "tag_string" in data_dict:
+                    data_dict["tags"] = _tag_string_to_list(data_dict["tag_string"])
+                del data_dict["_ckan_phase"]
+                del data_dict["save"]
+            context["message"] = data_dict.get("log_message", "")
+            data_dict["id"] = id
 
             # If the dataset has a spatial, make it the default
-            spatial = data_dict.get('spatial', '')
-            dataset_spatial = data_dict.get('dataset_spatial', '')
+            spatial = data_dict.get("spatial", "")
+            dataset_spatial = data_dict.get("dataset_spatial", "")
             if is_valid_spatial(dataset_spatial) and spatial != dataset_spatial:
-                data_dict['spatial'] = dataset_spatial
-            
-            if u'group_string' in data_dict:
-                data_dict[u'groups'] = _group_string_to_list(
-                data_dict[u'group_string']
-                )
+                data_dict["spatial"] = dataset_spatial
 
-            pkg_dict = get_action(u'package_update')(context, data_dict)
+            if "group_string" in data_dict:
+                data_dict["groups"] = _group_string_to_list(data_dict["group_string"])
+
+            pkg_dict = get_action("package_update")(context, data_dict)
 
             return _form_save_redirect(
-                pkg_dict[u'name'], u'edit', package_type=package_type
+                pkg_dict["name"], "edit", package_type=package_type
             )
         except NotAuthorized:
-            return base.abort(403, _(u'Unauthorized to read package %s') % id)
+            return base.abort(403, _("Unauthorized to read package %s") % id)
         except NotFound as e:
-            return base.abort(404, _(u'Dataset not found'))
+            return base.abort(404, _("Dataset not found"))
         except SearchIndexError as e:
             try:
                 exc_str = str(repr(e.args))
             except Exception:  # We don't like bare excepts
                 exc_str = str(str(e))
-            return base.abort(
-                500,
-                _(u'Unable to update search index.') + exc_str
-            )
+            return base.abort(500, _("Unable to update search index.") + exc_str)
         except ValidationError as e:
             errors = e.error_dict
             error_summary = e.error_summary
             return self.get(package_type, id, data_dict, errors, error_summary)
 
-    def get(
-        self, package_type, id, data=None, errors=None, error_summary=None
-    ):
+    def get(self, package_type, id, data=None, errors=None, error_summary=None):
         context = self._prepare()
         package_type = _get_package_type(id) or package_type
         try:
-            pkg_dict = get_action(u'package_show')(
-                dict(context, for_view=True), {
-                    u'id': id
-                }
+            pkg_dict = get_action("package_show")(
+                dict(context, for_view=True), {"id": id}
             )
-            context[u'for_edit'] = True
-            old_data = get_action(u'package_show')(context, {u'id': id})
+            context["for_edit"] = True
+            old_data = get_action("package_show")(context, {"id": id})
             # old data is from the database and data is passed from the
             # user if there is a validation error. Use users data if there.
             if data:
                 old_data.update(data)
             data = old_data
         except (NotFound, NotAuthorized):
-            return base.abort(404, _(u'Dataset not found'))
+            return base.abort(404, _("Dataset not found"))
         # are we doing a multiphase add?
-        if data.get(u'state', u'').startswith(u'draft'):
-            g.form_action = h.url_for(u'{}.new'.format(package_type))
-            g.form_style = u'new'
+        if data.get("state", "").startswith("draft"):
+            g.form_action = h.url_for("{}.new".format(package_type))
+            g.form_style = "new"
 
             return CreateView().get(
-                package_type,
-                data=data,
-                errors=errors,
-                error_summary=error_summary
+                package_type, data=data, errors=errors, error_summary=error_summary
             )
 
-        pkg = context.get(u"package")
-        resources_json = h.json.dumps(data.get(u'resources', []))
+        pkg = context.get("package")
+        resources_json = h.json.dumps(data.get("resources", []))
 
         try:
-            check_access(u'package_update', context)
+            check_access("package_update", context)
         except NotAuthorized:
             return base.abort(
-                403,
-                _(u'User %r not authorized to edit %s') % (g.user, id)
+                403, _("User %r not authorized to edit %s") % (g.user, id)
             )
         # convert tags if not supplied in data
-        if data and not data.get(u'tag_string'):
-            data[u'tag_string'] = u', '.join(
-                h.dict_list_reduce(pkg_dict.get(u'tags', {}), u'name')
+        if data and not data.get("tag_string"):
+            data["tag_string"] = ", ".join(
+                h.dict_list_reduce(pkg_dict.get("tags", {}), "name")
             )
         errors = errors or {}
-        form_snippet = _get_pkg_template(
-            u'package_form', package_type=package_type
-        )
+        form_snippet = _get_pkg_template("package_form", package_type=package_type)
 
         # Get the org spatial
-        data['org_spatial'] = get_org_spatial(data['organization']['name'])
+        data["org_spatial"] = get_org_spatial(data["organization"]["name"])
 
         form_vars = {
-            u'data': data,
-            u'errors': errors,
-            u'error_summary': error_summary,
-            u'action': u'edit',
-            u'dataset_type': package_type,
-            u'form_style': u'edit'
+            "data": data,
+            "errors": errors,
+            "error_summary": error_summary,
+            "action": "edit",
+            "dataset_type": package_type,
+            "form_style": "edit",
         }
         errors_json = h.json.dumps(errors)
 
@@ -689,32 +655,29 @@ def get(
         g.resources_json = resources_json
         g.errors_json = errors_json
 
-        _setup_template_variables(
-            context, {u'id': id}, package_type=package_type
-        )
+        _setup_template_variables(context, {"id": id}, package_type=package_type)
 
         # we have already completed stage 1
-        form_vars[u'stage'] = [u'active']
-        if data.get(u'state', u'').startswith(u'draft'):
-            form_vars[u'stage'] = [u'active', u'complete']
+        form_vars["stage"] = ["active"]
+        if data.get("state", "").startswith("draft"):
+            form_vars["stage"] = ["active", "complete"]
 
-        edit_template = _get_pkg_template(u'edit_template', package_type)
+        edit_template = _get_pkg_template("edit_template", package_type)
         return base.render(
             edit_template,
             extra_vars={
-                u'form_vars': form_vars,
-                u'form_snippet': form_snippet,
-                u'dataset_type': package_type,
-                u'pkg_dict': pkg_dict,
-                u'pkg': pkg,
-                u'resources_json': resources_json,
-                u'form_snippet': form_snippet,
-                u'errors_json': errors_json
-            }
+                "form_vars": form_vars,
+                "form_snippet": form_snippet,
+                "dataset_type": package_type,
+                "pkg_dict": pkg_dict,
+                "pkg": pkg,
+                "resources_json": resources_json,
+                "form_snippet": form_snippet,
+                "errors_json": errors_json,
+            },
         )
 
-dataset_blueprint.add_url_rule('/', view_func=search, strict_slashes=False)
-dataset_blueprint.add_url_rule(u'/new', view_func=RvrCreateView.as_view(str(u'new')))
-dataset_blueprint.add_url_rule(
-    u'/edit/<id>', view_func=RvrEditView.as_view(str(u'edit'))
-)
+
+dataset_blueprint.add_url_rule("/", view_func=search, strict_slashes=False)
+dataset_blueprint.add_url_rule("/new", view_func=RvrCreateView.as_view(str("new")))
+dataset_blueprint.add_url_rule("/edit/<id>", view_func=RvrEditView.as_view(str("edit")))
diff --git a/ckanext/rvr/views/faq.py b/ckanext/rvr/views/faq.py
index 5ed2d34..056c57a 100644
--- a/ckanext/rvr/views/faq.py
+++ b/ckanext/rvr/views/faq.py
@@ -1,9 +1,11 @@
 from flask import Blueprint
 import ckan.plugins.toolkit as toolkit
 
-page_blueprint = Blueprint('page', __name__)
+page_blueprint = Blueprint("page", __name__)
+
 
 def faq_controller():
-    return toolkit.render('home/faq.html')
+    return toolkit.render("home/faq.html")
+
 
-page_blueprint.add_url_rule('/faq', 'faq', view_func=faq_controller)
+page_blueprint.add_url_rule("/faq", "faq", view_func=faq_controller)
diff --git a/ckanext/rvr/views/organization.py b/ckanext/rvr/views/organization.py
index 05cc915..997ee33 100644
--- a/ckanext/rvr/views/organization.py
+++ b/ckanext/rvr/views/organization.py
@@ -8,8 +8,15 @@
 import ckan.logic as logic
 import ckan.lib.navl.dictization_functions as dict_fns
 from ckan.common import g, request, _
-from ckan.views.group import EditGroupView, set_org, _action, _force_reindex, CreateGroupView, \
-    _setup_template_variables, _get_group_template
+from ckan.views.group import (
+    EditGroupView,
+    set_org,
+    _action,
+    _force_reindex,
+    CreateGroupView,
+    _setup_template_variables,
+    _get_group_template,
+)
 from ckan.views.home import CACHE_PARAMETERS
 
 from ckanext.rvr.actions import update_dataset_spatial
@@ -26,14 +33,13 @@
 parse_params = logic.parse_params
 
 organization_blueprint = Blueprint(
-    'rvr_organization', __name__,
-    url_prefix=u'/organization',
-    url_defaults={
-        u'group_type': u'organization',
-        u'is_organization': True
-    }
+    "rvr_organization",
+    __name__,
+    url_prefix="/organization",
+    url_defaults={"group_type": "organization", "is_organization": True},
 )
 
+
 class EditOrganizationView(EditGroupView):
     """
     Edit Organization View
@@ -48,90 +54,100 @@ def post(self, group_type, is_organization, id=None):
             # map data for the organization has been updated
 
             data_dict = clean_dict(
-                dict_fns.unflatten(tuplize_dict(parse_params(request.form))))
-            data_dict.update(clean_dict(
-                dict_fns.unflatten(tuplize_dict(parse_params(request.files)))
-            ))
-            context['message'] = data_dict.get(u'log_message', u'')
-            data_dict['id'] = context['id']
-            context['allow_partial_update'] = True
+                dict_fns.unflatten(tuplize_dict(parse_params(request.form)))
+            )
+            data_dict.update(
+                clean_dict(
+                    dict_fns.unflatten(tuplize_dict(parse_params(request.files)))
+                )
+            )
+            context["message"] = data_dict.get("log_message", "")
+            data_dict["id"] = context["id"]
+            context["allow_partial_update"] = True
 
             # Check if the map data has been updated
-            org_spatial = data_dict.get('org_spatial', None)
+            org_spatial = data_dict.get("org_spatial", None)
 
-            old_group_dict = _action(u'organization_show')(context,
-                {u'id': id, u'include_datasets': False}
+            old_group_dict = _action("organization_show")(
+                context, {"id": id, "include_datasets": False}
             )
-            old_org_spatial = ''
-            for extra in old_group_dict.get('extras', []):
-                if extra.get('key') == 'org_spatial':
-                    old_org_spatial = extra.get('value')
+            old_org_spatial = ""
+            for extra in old_group_dict.get("extras", []):
+                if extra.get("key") == "org_spatial":
+                    old_org_spatial = extra.get("value")
 
-            group = _action(u'group_update')(context, data_dict)
+            group = _action("group_update")(context, data_dict)
             if org_spatial != old_org_spatial:
                 update_dataset_spatial(group)
-            elif id != group['name']:
+            elif id != group["name"]:
                 # if the org_spatial has changed, a reindex would be done already
                 _force_reindex(group)
 
         except (NotFound, NotAuthorized) as e:
-            base.abort(404, _(u'Group not found'))
+            base.abort(404, _("Group not found"))
         except dict_fns.DataError:
-            base.abort(400, _(u'Integrity Error'))
+            base.abort(400, _("Integrity Error"))
         except ValidationError as e:
             errors = e.error_dict
             error_summary = e.error_summary
-            return self.get(id, group_type, is_organization,
-                            data_dict, errors, error_summary)
-        return h.redirect_to(group[u'type'] + u'.read', id=group[u'name'])
-
-    def get(self, id, group_type, is_organization,
-            data=None, errors=None, error_summary=None):
+            return self.get(
+                id, group_type, is_organization, data_dict, errors, error_summary
+            )
+        return h.redirect_to(group["type"] + ".read", id=group["name"])
+
+    def get(
+        self,
+        id,
+        group_type,
+        is_organization,
+        data=None,
+        errors=None,
+        error_summary=None,
+    ):
         extra_vars = {}
         set_org(is_organization)
 
         context = self._prepare(id, is_organization)
-        data_dict = {u'id': id, u'include_datasets': False}
+        data_dict = {"id": id, "include_datasets": False}
         try:
-            group_dict = _action(u'group_show')(context, data_dict)
+            group_dict = _action("group_show")(context, data_dict)
         except (NotFound, NotAuthorized):
-            base.abort(404, _(u'Group not found'))
+            base.abort(404, _("Group not found"))
         data = data or group_dict
         errors = errors or {}
 
         # Remove the org_spatial from extra before passing it to the template
-        org_spatial = ''
-        if data.get('extras', None):
-            for extra in data['extras']:
-                if extra.get('key') == 'org_spatial':
-                    org_spatial = extra.get('value')
-                    data['extras'].remove(extra)
+        org_spatial = ""
+        if data.get("extras", None):
+            for extra in data["extras"]:
+                if extra.get("key") == "org_spatial":
+                    org_spatial = extra.get("value")
+                    data["extras"].remove(extra)
 
         extra_vars = {
-            u'data': data,
-            u"group_dict": group_dict,
-            u'errors': errors,
-            u'error_summary': error_summary,
-            u'action': u'edit',
-            u'group_type': group_type,
-            u'org_spatial': org_spatial
+            "data": data,
+            "group_dict": group_dict,
+            "errors": errors,
+            "error_summary": error_summary,
+            "action": "edit",
+            "group_type": group_type,
+            "org_spatial": org_spatial,
         }
 
         _setup_template_variables(context, data, group_type=group_type)
-        form = base.render(
-            _get_group_template(u'group_form', group_type), extra_vars)
+        form = base.render(_get_group_template("group_form", group_type), extra_vars)
 
         # TODO: Remove
         # ckan 2.9: Adding variables that were removed from c object for
         # compatibility with templates in existing extensions
-        g.grouptitle = group_dict.get(u'title')
-        g.groupname = group_dict.get(u'name')
+        g.grouptitle = group_dict.get("title")
+        g.groupname = group_dict.get("name")
         g.data = data
         g.group_dict = group_dict
 
         extra_vars["form"] = form
-        return base.render(
-            _get_group_template(u'edit_template', group_type), extra_vars)
+        return base.render(_get_group_template("edit_template", group_type), extra_vars)
+
 
 class CreateOrganizationView(CreateGroupView):
     def post(self, group_type, is_organization):
@@ -139,65 +155,66 @@ def post(self, group_type, is_organization):
         context = self._prepare()
         try:
             data_dict = clean_dict(
-                dict_fns.unflatten(tuplize_dict(parse_params(request.form))))
-            data_dict.update(clean_dict(
-                dict_fns.unflatten(tuplize_dict(parse_params(request.files)))
-            ))
-            data_dict['type'] = group_type or u'group'
-            context['message'] = data_dict.get(u'log_message', u'')
-            data_dict['users'] = [{u'name': g.user, u'capacity': u'admin'}]
-            group = _action(u'group_create')(context, data_dict)
+                dict_fns.unflatten(tuplize_dict(parse_params(request.form)))
+            )
+            data_dict.update(
+                clean_dict(
+                    dict_fns.unflatten(tuplize_dict(parse_params(request.files)))
+                )
+            )
+            data_dict["type"] = group_type or "group"
+            context["message"] = data_dict.get("log_message", "")
+            data_dict["users"] = [{"name": g.user, "capacity": "admin"}]
+            group = _action("group_create")(context, data_dict)
 
         except (NotFound, NotAuthorized) as e:
-            base.abort(404, _(u'Group not found'))
+            base.abort(404, _("Group not found"))
         except dict_fns.DataError:
-            base.abort(400, _(u'Integrity Error'))
+            base.abort(400, _("Integrity Error"))
         except ValidationError as e:
             errors = e.error_dict
             error_summary = e.error_summary
-            return self.get(group_type, is_organization,
-                            data_dict, errors, error_summary)
+            return self.get(
+                group_type, is_organization, data_dict, errors, error_summary
+            )
 
-        return h.redirect_to(group['type'] + u'.read', id=group['name'])
+        return h.redirect_to(group["type"] + ".read", id=group["name"])
 
-    def get(self, group_type, is_organization,
-            data=None, errors=None, error_summary=None):
+    def get(
+        self, group_type, is_organization, data=None, errors=None, error_summary=None
+    ):
         extra_vars = {}
         set_org(is_organization)
         context = self._prepare()
         data = data or clean_dict(
             dict_fns.unflatten(
-                tuplize_dict(
-                    parse_params(request.args, ignore_keys=CACHE_PARAMETERS)
-                )
+                tuplize_dict(parse_params(request.args, ignore_keys=CACHE_PARAMETERS))
             )
         )
 
-        if not data.get(u'image_url', u'').startswith(u'http'):
-            data.pop(u'image_url', None)
+        if not data.get("image_url", "").startswith("http"):
+            data.pop("image_url", None)
         errors = errors or {}
         error_summary = error_summary or {}
 
         # Remove the org_spatial from extra before passing it to the template
-        org_spatial = ''
-        if data.get('extras', None):
-            for extra in data['extras']:
-                if extra.get('key') == 'org_spatial':
-                    org_spatial = extra.get('value')
-                    data['extras'].remove(extra)
+        org_spatial = ""
+        if data.get("extras", None):
+            for extra in data["extras"]:
+                if extra.get("key") == "org_spatial":
+                    org_spatial = extra.get("value")
+                    data["extras"].remove(extra)
 
         extra_vars = {
-            u'data': data,
-            u'errors': errors,
-            u'error_summary': error_summary,
-            u'action': u'new',
-            u'group_type': group_type,
-            u'org_spatial': org_spatial
+            "data": data,
+            "errors": errors,
+            "error_summary": error_summary,
+            "action": "new",
+            "group_type": group_type,
+            "org_spatial": org_spatial,
         }
-        _setup_template_variables(
-            context, data, group_type=group_type)
-        form = base.render(
-            _get_group_template(u'group_form', group_type), extra_vars)
+        _setup_template_variables(context, data, group_type=group_type)
+        form = base.render(_get_group_template("group_form", group_type), extra_vars)
 
         # TODO: Remove
         # ckan 2.9: Adding variables that were removed from c object for
@@ -205,12 +222,12 @@ def get(self, group_type, is_organization,
         g.form = form
 
         extra_vars["form"] = form
-        return base.render(
-            _get_group_template(u'new_template', group_type), extra_vars)
+        return base.render(_get_group_template("new_template", group_type), extra_vars)
+
 
-organization_blueprint.add_url_rule(u'/edit/<id>', view_func=EditOrganizationView.as_view('edit'))
 organization_blueprint.add_url_rule(
-    u'/new',
-    methods=[u'GET', u'POST'],
-    view_func=CreateGroupView.as_view(str(u'new'))
+    "/edit/<id>", view_func=EditOrganizationView.as_view("edit")
+)
+organization_blueprint.add_url_rule(
+    "/new", methods=["GET", "POST"], view_func=CreateGroupView.as_view(str("new"))
 )

From b246805e796552d5d06aabe8c096415c016d4e37 Mon Sep 17 00:00:00 2001
From: Sagar Ghimire <info@sagarg.com.np>
Date: Wed, 24 Apr 2024 19:49:39 +0545
Subject: [PATCH 2/3] [Fix][m]: latest dataset in home page instead of recently
 modifed

---
 ckanext/rvr/helpers.py                        | 9 ++++++---
 ckanext/rvr/plugin.py                         | 2 +-
 ckanext/rvr/templates/ckanext_pages/page.html | 2 +-
 ckanext/rvr/templates/home/index.html         | 2 +-
 4 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/ckanext/rvr/helpers.py b/ckanext/rvr/helpers.py
index ca9478a..2331e85 100644
--- a/ckanext/rvr/helpers.py
+++ b/ckanext/rvr/helpers.py
@@ -85,9 +85,12 @@ def all_package_list(include_private: bool = True):
     return [r[0] for r in query.execute()]
 
 
-def get_newest_datasets():
-    results = tk.get_action("current_package_list_with_resources")({}, {"limit": 5})
-    return results
+def get_latest_created_datasets():
+    results = tk.get_action("package_search")(
+        context,
+        {"rows": 5, "sort": "metadata_created desc", "fq": "type:dataset", "q": ""},
+    )
+    return results['results']
 
 
 def get_nav_transport():
diff --git a/ckanext/rvr/plugin.py b/ckanext/rvr/plugin.py
index b9dd7a5..ab9f4bd 100644
--- a/ckanext/rvr/plugin.py
+++ b/ckanext/rvr/plugin.py
@@ -55,7 +55,7 @@ def get_helpers(self):
         Register template helper functions.
         """
         return {
-            "get_newest_datasets": rvrHelpers.get_newest_datasets,
+            "get_latest_created_datasets": rvrHelpers.get_latest_created_datasets,
             "build_nav_main": rvrHelpers.build_pages_nav_main,
             "get_specific_page": rvrHelpers.get_specific_page,
             "get_faq_page": rvrHelpers.get_faq_page,
diff --git a/ckanext/rvr/templates/ckanext_pages/page.html b/ckanext/rvr/templates/ckanext_pages/page.html
index b93543d..9064584 100644
--- a/ckanext/rvr/templates/ckanext_pages/page.html
+++ b/ckanext/rvr/templates/ckanext_pages/page.html
@@ -38,7 +38,7 @@ <h1 class="page-heading">{{ c.page.title }}</h1>
         <div class="module-content box dataset">
               <h1 class="page-heading">NEUESTE DATENSÄTZE</h1>
               {% block packages_list %}
-                  {{ h.snippet('snippets/package_list.html', packages=h.get_newest_datasets()) }}
+                  {{ h.snippet('snippets/package_list.html', packages=h.get_latest_created_datasets()) }}
               {% endblock %}
         </div>  
         <div class="module-content box statistic">
diff --git a/ckanext/rvr/templates/home/index.html b/ckanext/rvr/templates/home/index.html
index a259674..28b40e3 100644
--- a/ckanext/rvr/templates/home/index.html
+++ b/ckanext/rvr/templates/home/index.html
@@ -156,7 +156,7 @@ <h3 class="heading">Zu den Verkehrsdaten Metropole Ruhr</h3>
             <h1 class="page-heading">NEUESTE DATENSÄTZE</h1>
             <ul>
               {% block packages_list %}
-              {{ h.snippet('snippets/package_list.html', packages=h.get_newest_datasets()) }}
+              {{ h.snippet('snippets/package_list.html', packages=h.get_latest_created_datasets()) }}
 
               {% endblock %}
 

From 7d601393a29e06045cb6fd67dceef841a563ac92 Mon Sep 17 00:00:00 2001
From: Sagar Ghimire <info@sagarg.com.np>
Date: Thu, 25 Apr 2024 09:37:22 +0545
Subject: [PATCH 3/3] [FAQ][l]: FAQ page template updated

---
 ckanext/rvr/assets/css/rvr.css      | 132 +++++++++++++++++++++
 ckanext/rvr/helpers.py              |   8 +-
 ckanext/rvr/templates/home/faq.html | 177 ++++------------------------
 3 files changed, 161 insertions(+), 156 deletions(-)

diff --git a/ckanext/rvr/assets/css/rvr.css b/ckanext/rvr/assets/css/rvr.css
index ea5d960..24d8307 100644
--- a/ckanext/rvr/assets/css/rvr.css
+++ b/ckanext/rvr/assets/css/rvr.css
@@ -1009,3 +1009,135 @@ div#dataset-map-container.map-draw-field {
   margin-top: 383px;
 }
 
+/* =======================FAQ PAGE STYLE=========================== */
+.faq {
+    background: inherit;
+}
+
+.faq h1 {
+    font-size: 30px;
+    font-weight: bold;
+    margin-top: 20px;
+    margin-bottom: 20px;
+}
+
+.faq-title {
+    font-size: 22px !important;
+    text-decoration: underline;
+}
+
+.faq-question {
+    -webkit-text-size-adjust: 100%;
+    text-align: left;
+    font-size: 18px !important;
+    font-weight: bold !important;
+    position: relative;
+    padding-left: 30px;
+    background: inherit;
+    color: none;
+    font: inherit;
+    overflow: visible;
+    text-transform: none;
+    font-family: inherit;
+    margin-bottom: 0;
+    font-weight: bold;
+    touch-action: manipulation;
+    cursor: pointer;
+    border: none;
+    background-image: none;
+    padding: 5px 15px;
+    line-height: 1.6;
+    border-radius: 0;
+    user-select: none;
+    align-items: baseline;
+    outline: none;
+    white-space: normal;
+    text-align: left;
+    width: 100%;
+    display: inline-block;
+    padding-top: 5px;
+    padding-bottom: 15px;
+    left: 10;
+}
+
+.faq-question span {
+    margin-left: 10px;
+}
+
+.collapse-indicator {
+    position: absolute;
+    top: 25%;
+    left: 0;
+    padding-right: -20px;
+    margin-right: 10px;
+    font-size: 12px !important; /* adjust as needed */
+    color: grey; /* adjust as needed */
+    transition: transform 0.1s !important;
+}
+
+.faq-question.collapsed .collapse-indicator {
+    position: absolute;
+    padding-right: -20px;
+    margin-right: 10px;
+    top: 25% !important;
+    left: 0 !important;
+    transform: rotate(180deg);
+}
+
+.faq .content {
+    padding-left: 26px;
+}
+
+.collapse {
+    display: inline-block;
+    padding-top: 5px;
+    padding-bottom: 15px;
+    width: 100%;
+}
+
+.collapse p {
+    font-family: inherit;
+    font-weight: 300 !important;
+    display: block;
+    text-align: left;
+    font-size: 16px;
+}
+
+.collapsed + .collapse {
+    display: none;
+}
+
+@media screen and (max-width: 768px) {
+    /* Adjust the styles for screens smaller than 768px wide */
+    .faq {
+        margin-left: 5px;
+        margin-right: 5px;
+        background-color: #eee;
+    }
+
+    .faq-question {
+        font-size: 20px !important;
+        margin-left: 5px;
+    }
+
+    .collapse-indicator {
+        font-size: 2px;
+        margin-right: 20px;
+    }
+
+    .collapse p {
+        display: block;
+        padding-top: 5px;
+        padding-bottom: 15px;
+        padding-right: 0px !important;
+        text-align: left;
+        font-size: 20px !important;
+        margin-left: 15px;
+        margin-right: 15px;
+    }
+
+    .faq-question.collapsed .collapse-indicator {
+        margin-right: 0px;
+    }
+}
+  /* =======================END FAQ PAGE STYLE=========================== */
\ No newline at end of file
diff --git a/ckanext/rvr/helpers.py b/ckanext/rvr/helpers.py
index 2331e85..92650b0 100644
--- a/ckanext/rvr/helpers.py
+++ b/ckanext/rvr/helpers.py
@@ -109,7 +109,6 @@ def get_specific_page(name=""):
 
 
 def get_faq_page():
-
     page_list = tk.get_action("ckanext_pages_list")(
         None,
         {
@@ -119,7 +118,6 @@ def get_faq_page():
             "private": True,
         },
     )
-    print(f"OVO JE {page_list}")
     for page in page_list:
         if page["name"] == "faq":
             faq_page = page["content"]
@@ -127,7 +125,6 @@ def get_faq_page():
                 faq_page = faq_page.replace("\r\n", "")
             else:
                 log.warning("Page content is not a string type: {}".format(faq_page))
-    # print(faq_page)
     doc = html.fromstring(faq_page)
     faq_page_dict = []
 
@@ -144,14 +141,15 @@ def get_faq_page():
             tag_is_p = False
         elif tag == "p":
             if not tag_is_p:
-                value = [element.text]
+                value = [html.tostring(element).decode("utf-8")]
+                print(value)
                 tag = "div"
                 faq_page_dict.append({"tag": tag, "value": value})
                 idx += 1
                 tag_is_p = True
             else:
                 last_el = faq_page_dict[idx - 1]
-                last_el["value"].append(element.text)
+                last_el["value"].append(html.tostring(element).decode("utf-8"))
                 faq_page_dict[idx - 1] = last_el
                 tag_is_p = True
     return faq_page_dict
diff --git a/ckanext/rvr/templates/home/faq.html b/ckanext/rvr/templates/home/faq.html
index 914fd49..217e217 100644
--- a/ckanext/rvr/templates/home/faq.html
+++ b/ckanext/rvr/templates/home/faq.html
@@ -2,156 +2,31 @@
 {% set faq_content = h.get_faq_page() %}
 
 {% block primary %}
-<div>
-<h1 id="title" style="text-align: center; font-size: 28px;">FAQ Open Data Portal Metropole Ruhr</h1>
+<div class="module" role="main">
+  <div class="module-content faq">
+    <h1 class="page-heading">FAQ Open Data Portal Metropole Ruhr</h1>
+    {% for item in faq_content %}
+      {% if item.tag == 'h1' %}
+        <h1 class="faq-title">{{ item.value[0] }}</h1>
+      {% endif %}
+    {% if item.tag == 'h2' %}
+      {% set idx = loop.index %}
+        <h2 id="faq_question_{{loop.index}}" data-bs-toggle="collapse" data-bs-target="#faq_answer_{{loop.index}}"
+          aria-expanded="false" aria-controls="faq_answer_{{loop.index}}" data-toggle="collapse"
+          class="faq-question collapsed">
+            <i class="fa fa-chevron-down collapse-indicator" aria-hidden="true"></i>
+            <span>{{ item.value[0] }}</span>
+        </h3>
+    {% endif %}
+    {% if item.tag == 'div' %}
+      <div id="faq_answer_{{loop.index - 1}}" class="collapse content" role="region"
+        aria-labelledby="faq_question_{{loop.index}}" aria-expanded="false">
+        {% for val in item.value %}
+            {{ val | safe}}
+        {% endfor %}
+      </div>
+    {% endif %}
+    {% endfor %}
+  </div>
 </div>
-<div>
-
-<div class="faq">
-{% for item in faq_content %}
-  {% if item.tag == 'h1' %}
-    <h1 id="section_{{loop.index}}" style="text-align: center; font-size: 26px; color: grey;">{{ item.value[0] }}</h1>
-  {% endif %}
-  {% if item.tag == 'h2' %}
-    {% set idx = loop.index %}
-      <button id="faq_question_{{loop.index}}" data-target="#faq_answer_{{loop.index}}" aria-expanded="false" aria-controls="faq_answer_{{loop.index}}" data-toggle="collapse" 
-      class="faq-question collapsed">
-      <i class="fa fa-chevron-down collapse-indicator" aria-hidden="true"></i>
-      <span>{{ item.value[0] }}</span>
-      </button>
-  {% endif %}
-  {% if item.tag == 'div' %}
-    <div id="faq_answer_{{loop.index - 1}}" class="collapse" role="region" aria-labelledby="faq_question_{{loop.index}}" aria-expanded="false" >
-      {% for val in item.value %}
-        <p>{{ val }}</p>
-      {% endfor %}
-    </div>
-  {% endif %}
-{% endfor %}
-</div>
-{% endblock %}
-
-{% block styles %}
-  {{ super() }}
-<style>
-  .faq {
-    margin-left: 180px;
-    margin-right: 180px;
-    background: inherit;
-  }
-  .faq-question {
-    -webkit-text-size-adjust: 100%;
-    text-align: left;
-    font-size: 18px !important;
-    font-weight: bold !important;
-    position: relative;
-    padding-left: 30px;
-    background: inherit;
-    color: none;
-    font: inherit;
-    overflow: visible;
-    text-transform: none;
-    font-family: inherit;
-    margin-bottom: 0;
-    font-weight: bold;
-    touch-action: manipulation;
-    cursor: pointer;
-    border: none;
-    background-image: none;
-    padding: 5px 15px;
-    line-height: 1.6;
-    border-radius: 0;
-    user-select: none;
-    align-items: baseline;
-    outline: none;
-    white-space: normal;
-    text-align: left;
-    width: 100%;
-    display: inline-block;
-    padding-top: 5px;
-    padding-bottom: 15px;
-    left: 10;
-  }
-
-  .faq-question span {
-    margin-left: 10px;
-  }
-
-  .collapse-indicator {
-    position: absolute;
-    top: 25%;
-    left: 0;
-    padding-right: -20px;
-    margin-right: 10px;
-    font-size: 12px !important; /* adjust as needed */
-    color: grey; /* adjust as needed */
-    transition: transform 0.1s !important;
-  }
-  .faq-question.collapsed .collapse-indicator {
-    position: absolute;
-    padding-right: -20px;
-    margin-right: 10px;
-    top: 25% !important;
-    left: 0 !important;
-    transform: rotate(180deg);
-  }
-
-  .collapse {
-    display: inline-block;
-    padding-top: 5px;
-    padding-bottom: 15px;
-    width: 100%;
-  }
-
-  .collapse p {
-    font-family: inherit;
-    font-weight: 300 !important;
-    display: block;
-    text-align: left;
-    font-size: 16px;
-  }
-
-  .collapsed + .collapse {
-    display: none;
-  }
-
-  @media screen and (max-width: 768px) {
-    /* Adjust the styles for screens smaller than 768px wide */
-    .faq {
-      margin-left: 5px;
-      margin-right: 5px;
-      background-color: #eee;
-    }
-    .faq-question {
-      font-size: 20px !important;
-      margin-left: 5px;
-    }
-    .collapse-indicator {
-      font-size: 2px;
-      margin-right: 20px;
-    }
-    .collapse p {
-    display: block;
-    padding-top: 5px;
-    padding-bottom: 15px;
-    padding-right: 0px !important;
-    text-align: left;
-    font-size: 20px !important;
-    margin-left: 15px;
-    margin-right: 15px;
-    }
-    .faq-question.collapsed .collapse-indicator {
-      margin-right: 0px;
-    }
-  }
-</style>
 {% endblock %}
-{% block scripts %}
-  {{ super() }}
-<script>
-  $('.faq-question').click(function() {
-    $(this).toggleClass('collapsed');
-    $(this).find('.collapse-indicator').toggleClass('collapsed');
-  });
-</script>
-{% endblock %}
\ No newline at end of file