How to use the geonode.geoserver.helpers.ogc_server_settings function in GeoNode

def setUp(self):

        if not os.path.exists(os.path.join(os.path.split(__file__)[0], 'test_ogr')):
            self.skipTest('Skipping test due to missing test data.')

        # These tests require geonode to be running on :80!
        self.postgis = db.connections['datastore']
        self.postgis_settings = self.postgis.settings_dict

        self.username, self.password = self.create_user('admin', 'admin', is_superuser=True)
        self.non_admin_username, self.non_admin_password = self.create_user('non_admin', 'non_admin')
        self.cat = Catalog(ogc_server_settings.internal_rest, *ogc_server_settings.credentials)
        self.workspace = 'geonode'
        self.datastore = self.create_datastore(self.postgis, self.cat)

@csrf_exempt
def proxy(request):
    PROXY_ALLOWED_HOSTS = getattr(settings, 'PROXY_ALLOWED_HOSTS', ())

    host = None

    if 'geonode.geoserver' in settings.INSTALLED_APPS:
        from geonode.geoserver.helpers import ogc_server_settings
        hostname = (ogc_server_settings.hostname,) if ogc_server_settings else ()
        PROXY_ALLOWED_HOSTS += hostname
        host = ogc_server_settings.netloc

    if 'url' not in request.GET:
        return HttpResponse("The proxy service requires a URL-encoded URL as a parameter.",
                            status=400,
                            content_type="text/plain"
                            )

    raw_url = request.GET['url']
    url = urlsplit(raw_url)
    locator = str(url.path)
    if url.query != "":
        locator += '?' + url.query
    if url.fragment != "":
        locator += '#' + url.fragment

def handle(self, *args, **options):

        rest_url = ogc_server_settings.rest
        rest_user = ogc_server_settings.credentials.username
        rest_pass = ogc_server_settings.credentials.password
        dry_run = options['dry-run']
        gs = Catalog(rest_url, rest_user, rest_pass)
        layers = gs.get_layers()

        if options['layer_list'] is not None:
            layers = options['layer_list'].split(',')

        unfixable = []
        valid = []

        def add_unfixable(layer_name, reason):
            layer = {'name': layer_name,
                     'error': reason}
            unfixable.append(layer)

if (Link.objects.filter(resource=instance.resourcebase_ptr,
                                        url=wfs_url,
                                        name=name).count() < 2):
                    Link.objects.update_or_create(
                        resource=instance.resourcebase_ptr,
                        url=wfs_url,
                        name=name,
                        link_type='data',
                        defaults=dict(
                            extension=ext,
                            mime=mime,
                        )
                    )

        elif instance.storeType == 'coverageStore':
            links = wcs_links(ogc_server_settings.public_url + 'wcs?',
                              instance.alternate.encode('utf-8'),
                              bbox,
                              srid)

        for ext, name, mime, wcs_url in links:
            if (Link.objects.filter(resource=instance.resourcebase_ptr,
                                    url=wcs_url,
                                    name=name).count() < 2):
                Link.objects.update_or_create(
                    resource=instance.resourcebase_ptr,
                    url=wcs_url,
                    name=name,
                    link_type='data',
                    defaults=dict(
                        extension=ext,
                        mime=mime,

from django.conf import settings
from django.contrib.gis.utils import LayerMapping
from django.contrib.gis.db import models
from django.contrib.gis import admin
from django.core.exceptions import ValidationError
from django import db

from geonode.layers.models import Layer
from geonode.geoserver.helpers import ogc_server_settings

from .postgis import file2pgtable

datastore_name = settings.OGC_SERVER['default']['DATASTORE']
DYNAMIC_DATASTORE = datastore_name if datastore_name != '' else 'datastore'

has_datastore = True if len(ogc_server_settings.datastore_db.keys()) > 0 else False


class ModelDescription(models.Model):
    name = models.CharField(max_length=255)
    layer = models.ForeignKey(Layer, null=True, blank=True)

    def get_django_model(self, with_admin=False):
        "Returns a functional Django model based on current data"
        # Get all associated fields into a list ready for dict()
        fields = [(f.name, f.get_django_field()) for f in self.fields.all()]

        # Use the create_model function defined above
        return create_model(self.name, dict(fields),
                            app_label='dynamic',
                            module='geonode.contrib.dynamic',
                            options={'db_table': self.name,

def validate_uploaded_files(cleaned, uploaded_files, field_spatial_types):
    logger.info("uploaded_files: {}".format(uploaded_files))
    requires_datastore = () if ogc_server_settings.DATASTORE else (
        'csv',
        'kml')
    types = [t for t in files.types if t.code not in requires_datastore]
    base_ext = os.path.splitext(cleaned["base_file"].name)[-1].lower()[1:]
    if not _supported_type(base_ext, types) and base_ext.lower() != "zip":
        raise forms.ValidationError(
            "%(supported)s files are supported. You uploaded a "
            "%(uploaded)s file",
            params={
                "supported": " , ".join([t.name for t in types]),
                "uploaded": base_ext
            }
        )
    elif base_ext.lower() == "zip":
        if not zipfile.is_zipfile(cleaned["base_file"]):
            raise forms.ValidationError(_("Invalid zip file detected"))

xml = (""
           "{name}"
           "{native_name}"
           "<title>{title}</title>"
           "EPSG:4326"
           "{minx}{maxx}{miny}{maxy}"
           "EPSG:4326"
           "{attributes}"
           "").format(
        name=name.encode('UTF-8', 'strict'), native_name=native_name.encode('UTF-8', 'strict'),
        title=title.encode('UTF-8', 'strict'),
        minx=BBOX[0], maxx=BBOX[1], miny=BBOX[2], maxy=BBOX[3],
        attributes=attributes_block)

    url = ('%s/workspaces/%s/datastores/%s/featuretypes'
           % (ogc_server_settings.rest, workspace.name, datastore.name))
    headers = {'Content-Type': 'application/xml'}
    _user, _password = ogc_server_settings.credentials
    req = requests.post(url, data=xml, headers=headers, auth=(_user, _password))
    if req.status_code != 201:
        logger.error('Request status code was: %s' % req.status_code)
        logger.error('Response was: %s' % req.text)
        raise GeoNodeException("Layer could not be created in GeoServer")

    return workspace, datastore

#
# Opencarto is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with Opencarto.  If not, see .
#
from django import db
from django.contrib.gis.gdal import DataSource, SpatialReference, OGRGeometry
from django.utils.text import slugify

from geonode.geoserver.helpers import ogc_server_settings

has_datastore = True if len(ogc_server_settings.datastore_db.keys()) > 0 else False


def get_model_field_name(field):
    """Get the field name usable without quotes.
    """
    # Remove spaces and strange characters.
    field = slugify(field)

    # Use underscores instead of dashes.
    field = field.replace('-', '_')

    # Use underscores instead of semicolons.
    field = field.replace(':', '_')

    # Do not let it be called id
    if field in ('id',):

request,
                'layers/layer_style_manage.html',
                context={
                    "layer": layer,
                    "gs_styles": gs_styles,
                    "layer_styles": layer_styles,
                    "layer_style_names": [s[0] for s in layer_styles],
                    "default_style": default_style
                }
            )
        except (FailedRequestError, EnvironmentError):
            tb = traceback.format_exc()
            logger.debug(tb)
            msg = ('Could not connect to geoserver at "%s"'
                   'to manage style information for layer "%s"' % (
                       ogc_server_settings.LOCATION, layer.name)
                   )
            logger.debug(msg)
            # If geoserver is not online, return an error
            return render(
                request,
                'layers/layer_style_manage.html',
                context={
                    "layer": layer,
                    "error": msg
                }
            )
    elif request.method in ('POST', 'PUT', 'DELETE'):
        try:
            selected_styles = request.POST.getlist('style-select')

            default_style = request.POST['default_style']

def layer_append_minimal(source, target, request_cookies):
    """
    The main layer_append logic that can run outside of a request.
    """
    source = 'geonode:' + source

    def chunk_list(list, chunk_size):
        """Yield successive chunk_size chunks from list."""
        for i in xrange(0, len(list), chunk_size):
            yield list[i:i+chunk_size]

    # TODO: use the provided column to decide which features should be updated and which should be created
    # join_on_attribute = json.loads(request.POST.get(u'joinOnAttributeName', 'false'))

    get_features_request = requests.post(
        '{}/wfs?service=wfs&version=2.0.0&request=GetFeature&typeNames={}'.format(ogc_server_settings.public_url,
                                                                                  source),
        auth=ogc_server_settings.credentials
    )

    if has_exception(get_features_request.content):
        raise AssertionError(
            'Failed to get features from source layer: {0}'.format(source))

    # the response to getfeatures will look like the following. We want everything between first  and last 
    # 
    #     
    #         
    #             
    #                 
    #                     14.101186235070415 -87.19960869178765
    #