Talleres¶
La documentación de los talleres muestra algunos ejemplos sobre cómo utilizar GeoNode-Project para ampliar/personalizar las funcionalidades de GeoNode según su negocio.Los temas cubiertos incluyen los siguientes:
1- Personaliza tu GeoNode con el proyecto geonode
2- Personaliza la apariencia y comportamiento
3- Crea tus metadatos de ResourceBase
4- Crea tu propia aplicación Django
5- Añade un modelo personalizado
6- Permisos y API
7- Implementa tu GeoNode
1- Personaliza tu GeoNode con el proyecto geonode¶
En este ejemplo, se clona GeoNode-Project para crear una instancia de plantilla en la que el resto de los ejemplos se construirán sobre ella.
1- Suponiendo que ya instaló GeoNode-Core, primero necesitamos crear una plantilla de GeoNode-Project y esto se puede lograr con el siguiente comando:
$ django-admin.py startproject my_geonode --template=https://github.com/GeoNode/geonode-project/archive/master.zip -e py,rst,json,yml,ini,env,sample -n Dockerfile
Aquí, django-admin se usa con la opción startproject para crear el proyecto my_geonode copiando la plantilla que se pasa como repositorio Github de GeoNode-project.También incluye extensiones «py,rst,json,yml,ini,env,sample»
2- Una vez finalizada la clonación, el siguiente paso es instalar el GeoNode-Project que acabamos de descargar de la siguiente manera:
$ pip install -e my_geonode
3- Instale el geoserver usando la pavimentadora de la siguiente manera
$ cd /home/geonode/my_geonode/src
$ paver setup
4- Tenga en cuenta los parámetros de conexión de la base de datos GeoNode mencionados en el archivo .env.sample.py.Cambie el nombre a .env y luego use psql para crear el usuario requerido y otorgar los privilegios requeridos de la siguiente manera:
$ su postgres
$ createdb geonode
$ psql
postgres=# CREATE USER geonode WITH PASSWORD 'geonode';
CREATE ROLE
postgres=# GRANT ALL PRIVILEGES ON DATABASE "geonode" to geonode;
GRANT
postgres=# \q
Advertencia
No olvide salir del usuario de postgres antes de ejecutar los siguientes comandos
5- Ejecute GeoNode usando la pavimentadora
$ cd /home/geonode/my_geonode/src
$ paver start
Nota
Es posible que encuentre este mensaje de advertencia: Tiene 132 migraciones no aplicadas.Es posible que su proyecto no funcione correctamente hasta que aplique las migraciones para las aplicaciones: cuenta, actstream, admin, agon_ratings, anuncios, autenticación, avatar, base, tipos de contenido, diálogos, documentos, favoritos, geonode_client, geonode_themes, grupos, guardián, invitaciones, capas, mapas, mapstore2_adapter, monitoreo, oauth2_provider, personas, pinax_notifications, servicios, sesiones, sitios, cuenta social,taggit, sabrosopie, subir, mensajes_de_usuario.Lo que significa que aún no se han ejecutado algunas declaraciones SQL y primero debe ejecutar «migrar» para sincronizar su base de datos y luego «iniciar pavimentadora» nuevamente de la siguiente manera:
$ python manage.py migrate
$ paver start
Advertencia
Si encuentra este mensaje: (Encabezado HTTP_HOST no válido: '0.0.0.0:8000'. Es posible que deba agregar u'0.0.0.0' a ALLOWED_HOSTS) Se puede solucionar en el archivo settings.py.Deberá agregar: ALLOWED_HOSTS = ['0.0.0.0'] en settings.py
6- Una vez realizado el paso anterior, puedes visitar 0.0.0.0:8000 para ver la GUI de GeoNode.Sin embargo, todavía no tenemos una cuenta para poder iniciar sesión desde la GUI.Esto se puede hacer usando «paver sync».El comando creará una sincronización con los dispositivos más recientes y también creará un superusuario «admin» con la contraseña predeterminada «admin».
7- Utilice la cuenta creada para iniciar sesión desde la GUI a través de localhost:8000 o 0.0.0.0:8000
2- Personaliza la apariencia y comportamiento¶
En esta sección cambiaremos la apariencia y comportamiento de GeoNode, en particular haremos algunas personalizaciones para ayudar a comprender cómo funciona la herencia de plantillas y cómo agregar cosas nuevas a su GeoNode.Los cambios incluirán la página de inicio, el menú superior, el pie de página y una página genérica de GeoNode.
Página principal:
El proyecto geonode proporciona algunas plantillas predefinidas para cambiar la página de inicio y el contenido general del sitio.
In the «my_geonode/src/my_geonode/templates/geonode-mapstore-client/snippets» directory we can files with similar names as the geonode-mapstore-client. This way we can override the different parts of the site eg the header, menu, body content and the footer.
Create a file name hero.html and add the following.
El tema:
Para cambiar el tema de nuestro proyecto geonode, podemos actuar en el archivo site_base.css disponible en la carpeta «my_geonode/my_geonode/static/css».
El archivo está vacío, por lo que podemos inspeccionar elementos de la página de inicio con las herramientas de desarrollo del navegador y definir reglas CSS allí.
Por ejemplo, si queremos cambiar el fondo del jumbotron, en este archivo podemos agregar
.msgapi .gn-hero .jumbotron { background: red }
Luego, una vez que actualicemos el navegador, deberíamos ver el cambio de la siguiente manera:
El menú superior:
Ahora podemos realizar algunos cambios que se aplicarán a todo el sitio.Podemos agregar un elemento tanto en el lado izquierdo como en el derecho de la barra de menú superior.
Esto se puede hacer creando un get_menu_json.py en la carpeta templatetags para anular el menú predeterminado de GeoNodes.
@register.simple_tag(takes_context=True)
def get_base_right_topbar_menu(context):
is_mobile = _is_mobile_device(context)
if is_mobile:
return []
return [
{
"type": "link",
"href": "/",
"label": "Custom 3"
},
{
"type": "link",
"href": "/",
"label": "Custom 4"
},
]
@register.simple_tag(takes_context=True)
def get_base_left_topbar_menu(context):
is_mobile = _is_mobile_device(context)
return [
{
"type": "link",
"href": "/",
"label": "Custom 1"
},
{
"type": "link",
"href": "/",
"label": "Custom 2"
},
]
Al actualizar el navegador, verá una nueva entrada en la barra de navegación que es persistente en todo el sitio.
Modificar funcionalidad
En esta sección, parchearemos la base de recursos de GeoNode y actualizaremos las plantillas para agregar un campo más al esquema de metadatos.
Agregaremos un campo DOI al modelo ResourceBase y modificaremos las plantillas para mostrar el nuevo campo en la página del Asistente de metadatos.
Nota
Asegúrese de estar dentro del directorio «my_geonode» para ejecutar los siguientes comandos
La personalización de metadatos se puede lograr desde el modelo que se define en el núcleo en «geonode/geonode/base/models.py» de la siguiente manera:
# internal fields
uuid = models.CharField(max_length=36)
owner = models.ForeignKey(
settings.AUTH_USER_MODEL,
blank=True,
null=True,
related_name='owned_resource',
verbose_name=_("Owner"))
contacts = models.ManyToManyField(
settings.AUTH_USER_MODEL,
through='ContactRole')
title = models.CharField(_('title'), max_length=255, help_text=_(
'name by which the cited resource is known'))
alternate = models.CharField(max_length=128, null=True, blank=True)
date = models.DateTimeField(
_('date'),
default=now,
help_text=date_help_text)
date_type = models.CharField(
_('date type'),
max_length=255,
choices=VALID_DATE_TYPES,
default='publication',
help_text=date_type_help_text)
edition = models.CharField(
_('edition'),
max_length=255,
blank=True,
null=True,
help_text=edition_help_text)
abstract = models.TextField(
_('abstract'),
max_length=2000,
blank=True,
help_text=abstract_help_text)
purpose = models.TextField(
_('purpose'),
max_length=500,
null=True,
blank=True,
help_text=purpose_help_text)
maintenance_frequency = models.CharField(
_('maintenance frequency'),
max_length=255,
choices=UPDATE_FREQUENCIES,
blank=True,
null=True,
help_text=maintenance_frequency_help_text)
Para agregar campos directamente a la clase ResourceBase sin modificarla, esto se puede hacer desde el archivo «my_geonode/src/my_geonode/apps.py».
El método «listo» se invoca en el momento de la inicialización y actualmente se puede utilizar para modificar su aplicación de varias maneras.
class AppConfig(BaseAppConfig):
name = "my_geonode"
label = "my_geonode"
def ready(self):
super(AppConfig, self).ready()
run_setup_hooks()
Ahora agregaremos el método «patch_resource_base» a AppConfig y lo ejecutaremos desde el método listo de la siguiente manera:
from django.db import models
from django.utils.translation import ugettext_lazy as _
class AppConfig(BaseAppConfig):
name = "my_geonode"
label = "my_geonode"
def _get_logger(self):
import logging
return logging.getLogger(self.__class__.__module__)
def patch_resource_base(self, cls):
self._get_logger().info("Patching Resource Base")
doi_help_text = _('a DOI will be added by Admin before publication.')
doi = models.TextField(
_('DOI'),
blank=True,
null=True,
help_text=doi_help_text)
cls.add_to_class('doi', doi)
def ready(self):
super(AppConfig, self).ready()
run_setup_hooks()
from geonode.base.models import ResourceBase
self.patch_resource_base(ResourceBase)
Nota
deberá realizar las migraciones de la siguiente manera: - Agregar el campo doi a la base de recursos
Una vez que ejecute python enable.py migre:
Running migrations:
Applying announcements.0002_auto_20200119_1257... OK
Applying base.0031_resourcebase_doi... OK
Applying people.0027_auto_20200119_1257... OK
Till now, we have patched the DB. however, it is not yet sufficient as we still need to display the added field.
Extendamos las plantillas predeterminadas para que podamos mostrar el campo recién agregado.
3- Crea tu propia aplicación Django¶
En esta sección, demostraremos cómo crear y configurar el esqueleto de una aplicación personalizada utilizando las funciones de Django.La aplicación agregará una funcionalidad de geocolecciones a nuestro GeoNode.
La aplicación Geocollections permite presentar en una sola página recursos y usuarios agrupados por un Grupo GeoNode.Podemos asignar recursos arbitrarios a una Geocolección, un Grupo y un nombre que también se utilizará para construir una URL dedicada.
Nota
Asegúrese de estar dentro del directorio «my_geonode» para ejecutar los siguientes comandos
Crea la aplicación Django
Django nos brinda un comando útil para crear aplicaciones.Ya usamos startproject para crear nuestro proyecto de geonode, ahora podemos usar startapp para crear la aplicación.
python manage.py startapp geocollections
Esto creará una carpeta llamada geocolecciones que contiene modelos y vistas vacíos.
Necesitamos agregar la nueva aplicación a INSTALLED_APPS de nuestro proyecto.dentro de «my_geonode/src/my_geonode/settings.py»:
INSTALLED_APPS += (PROJECT_NAME,) to be: INSTALLED_APPS += (PROJECT_NAME, 'geocollections',)
Agregar un modelo personalizado
En esta sección, agregaremos un modelo personalizado y la lógica relacionada de la siguiente manera:
Agregar un nuevo modelo
Agregar URL y vistas
Agregar panel de administración
Añade la plantilla
vim geocollections/models.py
from django.db import models
from geonode.base.models import ResourceBase
from geonode.groups.models import GroupProfile
class Geocollection(models.Model):
"""
A collection is a set of resources linked to a GeoNode group
"""
group = models.ForeignKey(GroupProfile, related_name='group_collections')
resources = models.ManyToManyField(ResourceBase, related_name='resource_collections')
name = models.CharField(max_length=128, unique=True)
slug = models.SlugField(max_length=128, unique=True)
def __unicode__(self):
return self.name
En este punto necesitamos pedirle a Django que cree la tabla de la base de datos.Django desde la versión 1.8 tiene un mecanismo de migraciones incorporado y necesitamos usarlos para cambiar el estado de la base de datos.
Nota
Asegúrese de estar dentro del directorio «my_geonode» para ejecutar los siguientes comandos
python manage.py makemigrations
# the above command informs you with the migrations to be executed on the database
python manage.py migrate
A continuación usaremos la vista genérica de Django para mostrar los detalles de las colecciones.Agregue el siguiente código en el archivo views.py:
vim geocollections/views.py
from django.views.generic import DetailView
from .models import Geocollection
class GeocollectionDetail(DetailView):
model = Geocollection
Agregar configuración de URL
Para acceder a la vista creada también necesitamos el mapeo de URL.Podemos crear un archivo urls.py que contenga una asignación de URL a nuestra vista genérica:
vim geocollections/urls.py
from django.conf.urls import url
from .views import GeocollectionDetail
urlpatterns = [
url(r'^(?P<slug>[-\w]+)/$',
GeocollectionDetail.as_view(),
name='geocollection-detail'),
]
También necesitamos registrar las URL de la aplicación en las URL del proyecto.Entonces, modifiquemos el archivo urls.py «my_geonode» agregando lo siguiente:
vim my_geonode/src/my_geonode/urls.py
...
urlpatterns += [
## include your urls here
url(r'^geocollections/', include('geocollections.urls')),
]
...
Habilitar el panel de administración
Necesitamos una interfaz de usuario donde podamos crear geocolecciones.Django hace esto muy fácil, sólo necesitamos el archivo admin.py de la siguiente manera:
vim geocollections/admin.py
from django.contrib import admin
from .models import Geocollection
class GeocollectionAdmin(admin.ModelAdmin):
prepopulated_fields = {"slug": ("name",)}
filter_horizontal = ('resources',)
admin.site.register(Geocollection, GeocollectionAdmin)
Ahora podemos visitar la página de administración y crear una geocolección desde allí de la siguiente manera:
Agregando la plantilla
Ahora necesitamos la plantilla donde se representará el detalle de la geocolección.Creemos un directorio de geocolecciones dentro del directorio «my_geonode/templates» con un archivo llamado geocollection_detail.html:
mkdir -p my_geonode/templates/geocollections/
vim my_geonode/templates/geocollections/geocollection_detail.html
{% extends "geonode_base.html" %}
{% block body %}
<h2>Geocollection {{ object.name }}</h2>
<p>Group: {{ object.group.title }}</p>
<p>Resources:</p>
<ul>
{% for resource in object.resources.all %}
<li>{{ resource.title }}</li>
{% endfor %}
</ul>
{% endblock %}
Para verificar los resultados, cree un grupo en la interfaz de usuario del geonode y cargue una o más capas/documentos
inicie sesión en el panel de administración -> geocolecciones y cree una geocolecciones
Visite http://localhost:8000/geocollections/<the-name-of-the-created-geocollection> y vea los resultados.
Ahora que sabes cómo personalizar una plantilla html, puedes ajustar la página como prefieras.
Permisos y API
En esta sección agregaremos lógica más avanzada como permisos y API.Los permisos en GeoNode se administran con django-guardian, una biblioteca que permite establecer permisos a nivel de objeto (django tiene autorización a nivel de tabla).
Las API se implementan a través de django-tastypie.
Los temas a tratar incluyen:
Permisos sobre quién puede ver la geocolección
Cómo agregar plantillas y js para incrustar una interfaz de usuario de permiso en nuestra página de detalles de geocolección
API para servir punto final de búsqueda serializado json
Lógica de permisos (objetos de permisos)
Necesitamos agregar el objeto de permisos a la base de datos.Podemos hacer esto agregando la siguiente metaclase a nuestro modelo Geocollection, guardian se encargará de crear los objetos por nosotros.
vim geocollections/models.py
class Meta:
permissions = (
('view_geocollection', 'Can view geocollection'),
)
Luego ejecute «python Manage.py makemigrations» y «python enable.py migraciones» para instalarlos.
Lógica de permisos (set_default)
Agreguemos un método que se utilizará para configurar los permisos predeterminados en las Geocolecciones.Podemos agregar esta lógica al modelo Geocollection, pero también podría ser un Mix-in genérico similar a cómo se implementa en GeoNode.
vim geocollections/models.py
from django.contrib.auth.models import Group
from django.contrib.auth import get_user_model
from django.contrib.contenttypes.models import ContentType
from django.conf import settings
from guardian.shortcuts import assign_perm
def set_default_permissions(self):
"""
Set default permissions.
"""
self.remove_object_permissions()
# default permissions for anonymous users
anonymous_group, created = Group.objects.get_or_create(name='anonymous')
if settings.DEFAULT_ANONYMOUS_VIEW_PERMISSION:
assign_perm('view_geocollection', anonymous_group, self)
# default permissions for group members
assign_perm('view_geocollection', self.group, self)
Lógica de permisos (métodos)
Ahora necesitamos un método para agregar permisos genéricos, queremos poder asignar permisos de visualización a grupos y usuarios individuales.Podemos agregar esto a nuestro modelo Geocollection.
vim geocollections/models.py
def set_permissions(self, perm_spec):
anonymous_group = Group.objects.get(name='anonymous')
self.remove_object_permissions()
if 'users' in perm_spec and "AnonymousUser" in perm_spec['users']:
assign_perm('view_geocollection', anonymous_group, self)
if 'users' in perm_spec:
for user, perms in perm_spec['users'].items():
user = get_user_model().objects.get(username=user)
assign_perm('view_geocollection', user, self)
if 'groups' in perm_spec:
for group, perms in perm_spec['groups'].items():
group = Group.objects.get(name=group)
assign_perm('view_geocollection', group, self)
def remove_object_permissions(self):
from guardian.models import UserObjectPermission, GroupObjectPermission
UserObjectPermission.objects.filter(content_type=ContentType.objects.get_for_model(self),
object_pk=self.id).delete()
GroupObjectPermission.objects.filter(content_type=ContentType.objects.get_for_model(self),
object_pk=self.id).delete()
Lógica de permisos (views.py)
Ahora podemos agregar una vista para recibir y configurar nuestros permisos, en views.py:
vim geocollections/views.py
import json
from django.core.exceptions import PermissionDenied
from django.http import HttpResponse
from django.contrib.auth import get_user_model
User = get_user_model()
def geocollection_permissions(request, collection_id):
collection = Geocollection.objects.get(id=collection_id)
user = User.objects.get(id=request.user.id)
if user.has_perm('view_geocollection', collection):
return HttpResponse(
'You have the permission to view. please customize a template for this view'',
content_type='text/plain')
if request.method == 'POST':
success = True
message = "Permissions successfully updated!"
try:
permission_spec = json.loads(request.body)
collection.set_permissions(permission_spec)
return HttpResponse(
json.dumps({'success': success, 'message': message}),
status=200,
content_type='text/plain'
)
except:
success = False
message = "Error updating permissions :("
return HttpResponse(
json.dumps({'success': success, 'message': message}),
status=500,
content_type='text/plain'
)
Lógica de permisos (url)
Por último, necesitamos una URL para asignar nuestro cliente a nuestra vista, en urls.py
vim geocollections/urls.py
from django.conf.urls import url
from .views import GeocollectionDetail, geocollection_permissions
urlpatterns = [
url(r'^(?P<slug>[-\w]+)/$',
GeocollectionDetail.as_view(),
name='geocollection-detail'),
url(r'^permissions/(?P<collection_id>\d+)$',
geocollection_permissions,
name='geocollection_permissions'),
]
Esta URL se llamará con la identificación de la geocolección, la identificación se pasará a la vista para obtener los permisos.
Advertencia
Una nota sobre la parte del cliente, la lógica del lado del servidor es solo una parte necesaria para implementar permisos.
Una lista de verificación de lo que es necesario:
Un fragmento de plantilla que se puede incrustar en geocollection_detail.html, puede copiarlo y simplificarlo: _permissions_form.html y _permissions.html (en geonode/templates)
Un archivo javascript que recopilará la configuración de permisos y los enviará al servidor. Puede copiarlo y simplificarlo: _permissions_form_js.html (en geonode/templates)
API
El sistema API GeoNode permite conectar fácilmente nuevas API.Esta sección demuestra los pasos necesarios:
Primero debemos crear un archivo api.py en nuestra aplicación de geocolección.
vim geocollections/api.py
import json
from tastypie.resources import ModelResource
from tastypie import fields
from tastypie.constants import ALL_WITH_RELATIONS, ALL
from geonode.api.api import ProfileResource, GroupResource
from geonode.api.resourcebase_api import ResourceBaseResource
from .models import Geocollection
class GeocollectionResource(ModelResource):
users = fields.ToManyField(ProfileResource, attribute=lambda bundle: bundle.obj.group.group.user_set.all(), full=True)
group = fields.ToOneField(GroupResource, 'group', full=True)
resources = fields.ToManyField(ResourceBaseResource, 'resources', full=True)
class Meta:
queryset = Geocollection.objects.all().order_by('-group')
ordering = ['group']
allowed_methods = ['get']
resource_name = 'geocollections'
filtering = {
'group': ALL_WITH_RELATIONS,
'id': ALL
}
Autorización API
Queremos que la API respete nuestros permisos personalizados, podemos lograrlo fácilmente agregando lo siguiente al comienzo de api.py:
vim geocollections/api.py
from tastypie.authorization import DjangoAuthorization
from guardian.shortcuts import get_objects_for_user
class GeocollectionAuth(DjangoAuthorization):
def read_list(self, object_list, bundle):
permitted_ids = get_objects_for_user(
bundle.request.user,
'geocollections.view_geocollection').values('id')
return object_list.filter(id__in=permitted_ids)
def read_detail(self, object_list, bundle):
return bundle.request.user.has_perm(
'view_geocollection',
bundle.obj)
Y esto para la clase GeocollectionResource Meta:
authorization = GeocollectionAuth()
Agregue una URL para nuestra API
Para publicar nuestra API necesitamos una URL y queremos que esa URL aparezca en el dominio /api del GeoNode.
La URL final de nuestra API debe ser /api/geocollections.
Podemos inyectar la URL en la API de GeoNode agregando las siguientes líneas al archivo «my_geonode/urls.py»:
vim my_geonode/urls.py
from geonode.api.urls import api
from geocollections.api import GeocollectionResource
api.register(GeocollectionResource())
Y agregue lo siguiente en los patrones de URL:
url(r'', include(api.urls)),
El resultado final será:
from django.conf.urls import url, include
from django.views.generic import TemplateView
from geonode.urls import urlpatterns
from geonode.api.urls import api
from geocollections.api import GeocollectionResource
api.register(GeocollectionResource())
urlpatterns += [
## include your urls here
url(r'', include(api.urls)),
url(r'^geocollections/', include('geocollections.urls')),
]
Probemos los permisos en API
Podemos probar los permisos en la API configurando manualmente un permiso desde la línea de comando y verificando que la API lo respete.
Al ejecutar python enable.py shell desde dentro de nuestra carpeta «my_geonode», se abre un shell de geonode.
Una especificación permanente podría verse así:
perms = {
'users': {
'AnonymousUser': ['view_geocollection'],
'alessio': ['view_geocollection']}
}
y podemos asignar los permisos con:
from geocollections.models import Geocollection
Geocollection.objects.first().set_permissions(perms)
nuestro http://localhost:8000/api/geocollections ahora debería enumerar la geocolección.
Si elimina la línea “AnonymousUser” de los permisos y asigna nuevamente los permisos, desaparecerá.
perms = {
'users': {
'alessio': ['view_geocollection']
}
Implemente su GeoNode
Hasta ahora hemos demostrado cómo modificar, ampliar y diseñar nuestro GeoNode en modo de desarrollo, pero ahora es el momento de pasar a producción.En esta sección aclararemos cómo:
confirma tu trabajo en GitHub
configura tu servidor
configure su GeoNode para producción
Push to GitHub Siempre es una buena práctica mantener tu código en un repositorio remoto, GithHub es una de las opciones y de hecho es la más utilizada.
Se supone que ya tienes una cuenta de GitHub y que tienes git instalado y configurado con tu nombre y correo electrónico.
Enviaremos solo la carpeta my_geonode a GitHub y, como sabíamos anteriormente, GeoNode para nosotros es una dependencia y simplemente lo reinstalaremos tal como está en el servidor.
Pasos para enviar su código a GitHub:
Crea un repositorio vacío en GitHub y copia su dirección
En my_geonode, ejecuta git init para inicializar un repositorio vacío
Agregue la dirección de su repositorio remoto con
git remoto agregue su nombre su dirección remotaeditar .gitignore agregando todos los archivos *.pyc
git add *para agregar todo el contenido de my_geonodegit commit -m 'initial import'para realizar el compromiso inicialgit push yourname masterpara enviar el código al repositorio de GitHub
Configurar el servidor
Hay varias opciones para implementar proyectos de GeoNode en servidores.En esta sección, explicamos cómo implementarlo en el servidor Ubuntu 18.04 mediante la instalación en todo el sistema.
Nota
Para una instalación rápida, siga la documentación de INSTALACIÓN en http://docs.geonode.org/en/master/install/core/index.html
Setup our my_geonode
Ahora necesitamos instalar el proyecto «my_geonode» desarrollado siguiendo estos pasos:
git clone desde tu repositorio (en la carpeta de tu preferencia)
sudo pip install -e my_geonodeeditar la configuración cuando sea necesario
edite
/etc/apache2/sites-enabled/geonode.confreemplazando la ruta wsgi al archivomy_geonode/my_geonode/wsgi.pyagregue los derechos de Apache a la carpeta «my_geonode» con un directorio como
<Directory "/path/to/my_geonode/">
Order allow,deny
Require all granted
</Directory>
Pruebe su servidor.