Changes

The main focus of a Gramps-based webapp is collaboration. The Gramps webapp will allow users to easily move their genealogy data to the web to be seen, and possibly editedwith proper login and permissions, in a live, collaborative environment.

# Create a fullscale GRAMPS Gramps web framework

# Build on GRAMPS Gramps codebase and wealth of resources

## VisualizationVisualizations## Date and calendar functions## Translations## Manual and documentation

== Overview =FAQ === 1. ''Aren't there already many fine, web-based genealogy programs? Why don't you just use one of those? Aren't you re-inventing the wheel?''

The Gramps webapp is written in Django. Django is a sophisticatedThere are indeed many fine, modern web development framework-based genealogy programs, and some are even free software/open source. It is written in PythonHowever, albeit in there are a few good reasons to develop a very different style from Gramps. However, part of the motivation of Django is that it breaks up web development into very clearly defined parts following the Model-View-Controller paradigm. based webapp:

The # Gramps has hundreds of thousands of lines of code, some of which could be re-used directly in a webapp uses pre. For example, the reports could be run and downloaded directly from the webapp.# Gramps has a very well-defined set of tables and relationships that could be re-existing CSS created implemented for on-line use. # Users have grown to appreciate the design of Gramps, and we want to continue to build on this design.# Many users want to collaborate. Currently, they would either have to move their data in and out of Gramps, or give up Gramps completely.# We want to keep the developers and users that we have, and so not splinter our groups. By building the webapp on top of core gramps code, we continue to refine and make better our current code, and keep our current developers working on the "Narrated Web" reportparts that they know and love.

Here is 2. ''Why do you need a screen shot from web framework like Django? Can't you just use the main page of same Python code, and same database that Gramps in Django:already uses?''

[[Image:Gramps_in_djangoWe can't use the same database (what is called a "backend") directly. Currently Gramps uses BSDDB, and it is not configured for use in a multiuser, client/server environment. But even if we could use the same backend, we would still want some type of web development framework. Django is one of the best in any language, and it just happens to be in Python.gif]]

=== We have designed it to be as easy as it can be, given that we are using Python. Many web sites allow Python programs, and Django ===allows many different variations in running. We picked the protocol with the most availability (WSGI). Don't worry if you haven't heard of it. Your webserver can probably run it.

A prototype of a GRAMPS Django webapp 4. ''When is in branches/geps/gep-013-server. To run it, do the following:this going to be available?''

# Download Django. I'm running version 1.0.3# Checkout the branches/geps/gep-013-server from SVN# cd gep-013-server/src/gen/web/# Edit settings.py## Edit the path to the Sqlite DB (or use another if you wish, including Oracle, MySQL, Postgresql, etc.)# Create the tables, and fill with core data:## make# Run the test webserver:## make run# Point your webbrowser We are hoping to:## http://127.0.0have a fully functioning webapp ready for testing July 2010.1:8000/

At this point, you 5. ''How can now export your Gramps data to Django (and back). In another terminal window:I help?''

# Build You can start by reading the rest of this version of page and sending ideas and comments to the Gramps:## cd gep-013-server/## developers mailing list, and running the code if you can./autogen.sh# Start up this version of Gramps## python src/gramps.py# Run the Django Exporter## Select Family Tree -> Export## Select Django

To import data back The Gramps webapp is written in Django. Django is a sophisticated, modern web development framework. Django is written in Python, albeit in a very different style from Gramps. However, part of the motivation of using Django's SQL table back is that it breaks up web development into Gramps from very clearly defined parts following the website[http://en.wikipedia.org/wiki/Model_view_controller Model-View-Controller] paradigm. Two of these parts require no special programming knowledge, and thus will allow more people to be able to possibly customize and participate in the Gramps project.

# Create a file named "import.django" somewhere The Gramps webapp (needs to end and Django in ".django"general).# Start up this version of Gramps## python src/gramps.py# Run the Django Importer## Select Family Tree is broken into three well-> Import## Select the "import.django" (from above) as the file to importdefined parts:

The Gramps webapp (and Django in general) is broken into three well-defined parts: models/views, templates, and CSS. The models define the tables and relationships, but this is done in Python (not SQL). The models also define the API to read/writing/editing the data. The views are also written in Python, and are closely tied to the models. The templates are written in HTML and a template language that is very easy for non-programmers to use and understand. Finally, CSS is just Cascading Style Sheets, where all of the graphical definitions are made. The webapp uses pre-existing CSS created for the "Narrated Web" report of Gramps which was used for created static web pages. Let's take a look at specific examples of each of these parts.

Here is the model that defines the Person table from src[{{Code Base}}gramps/genwebapp/webgrampsdb/models.py gramps/webapp/grampsdb/models.py]:

Here, you can see that Person only has 4 parts: gender_type, families, parent_families, and references. There are are additional properties, but they are defined in the PrimaryObject class which is shared with other PrimaryObjectstables. Here is PrimaryObject: <pre>class PrimaryObject(models.Model): class Meta: abstract = True id = models.AutoField(primary_key=True) handle = models.CharField(max_length=19, unique=True) gramps_id = models.CharField('gramps id', max_length=25, blank=True) last_saved = models.DateTimeField('last changed', auto_now=True) last_changed = models.DateTimeField('last changed', null=True, blank=True) # user edits private = models.BooleanField('private') marker_type = models.ForeignKey('MarkerType')</pre> The big difference here between typical Python programming is that the Person class defines the Person table, and the interface to it. Most Python code would probably have Person be an instance of a class, but Django uses classes to represent many things.

The big difference here is that Here are three examples using the Person class defines the Person table, and the interface to it. Most Python code would probably have Person be an instance of a class, but Django uses classes to represent many things.:

Here is a template <pre> % cd trunk % PYTHONPATH=src DJANGO_SETTINGS_MODEL=webapp.settings python >>> from srcwebapp.grampsdb.models import Person >>> Person.objects.all() [<Person>, <Person>, ...] >>> Person.objects.get(id=1) <Person> >>> Person.objects.get(handle='gh71234dhf3746347734') <Person></datapre> The first retrieves all of the rows for the Person table; the second retrieves just the one record that has the unique, primary key 1, and the third retrieves the single record that has the unique handle of 'gh71234dhf3746347734'. Note that we never connected onto a database... Django is (currently) define to connect on to one database, and it does it on import. The database is set in gramps/templateswebapp/person_listsettings.py. An alternative method of interactively talking to the database is to use ''manage.htmlpy'':

{ % load my_tags %}<table cellspacing="0"><thead> <tr>{% table_header headers %} <cd master/tr><gramps/thead><tbody>webapp { % for person in personsPYTHONPATH=.object_list %}<tr class="{% cycle odd,even %}"> <td>{{ person.gender|escape }}</td> <td>{{ person.first_name|escape }}</td> <td>{{ person.last_name|escape }}</td> <td>{{ persongramps python manage.email|escape }}</td>py shell </tr > {% endfor %}</tbody></table>{% paginator %}

Templates define '''what''' to displayThat will give you an ipython shell, if you have it installed.Very nice environment!

You can also use the Person interface to select a subset of people: <pre> >>> from webapp.grampsdb.models import * Tutorial >>> Person.objects.filter(gender_type=1) [<Person>, <Person>, ...]</pre> or even more clearly: <pre> >>> Person.objects.filter(gender_type__name="Male") [<Person>, <Person>, ...]</pre> The double-underscore in the keyword "gender_type__name" of the filter method is a Django convention. It means "replace with the correct syntax". If Python allowed it, it would be written as '''Person.objects.filter(gender_type.name="Male")''' but that is not legal syntax. ==== Model overview ====Here is an overview of all of the models and how they are related: http [[Image:all-tables.gif]] {{out of date}}{{man tip| 1=To update this (Gramps 3.x and earlier) |2=To see more graphical representations of the data, run "make docs" in the src/webapp/ directory, and then look in src/webapp/docs/.djangoproject}} * [https://gramps-project.comorg/endocs/devgen/gen_db.html#dbdjango Gramps DbDjango] === Templates === Templates are used to describe ''what'' to display. Here is a template from [{{Code Base}}data/introtemplates/tutorial01main_page.html data/#intro-tutorial01templates/main_page.html]:

Concurrent access for write and read imply several problems when people by accident change the same objects at the same time. {% block title %}GRAMPS itself has an elaborate signal handling for cases when dialogs are open with no longer current information. In a web environment, this becomes more difficult however. This is not built into Django.Connect - main page {% endblock %}{% block heading %}GRAMPS - main page {% endblock %}

* [http://groups.google.com/group/django<p id="description">Welcome to GRAMPS Connect, a new web-users/browse_thread/thread/c138ec11c6ad282e?hl=en# Django User Question] ** [http://groupsbased collaboration tool.google.com/group/django-developers/browse_thread/thread/fd5d45fc6cd6a760 Developer discussion on topic]

== Example GMS Web Sites = CSS ===

Genealogy Management Systems on Finally, here is a screen shot of the webmain_page.html (above) showing some initial testing of Gramps in Django using the Mainz CSS from the NarrWeb report:

* http://www.dertinger.de/Dertinger_database/en/en_index.htm* http://registry.phpgedview.net/index.php for example: [http[Image://wwwGramps_in_django.admiraal.org/gif]]. : Note here: the intro page is a collection of gadgets/controls, which then link into the real data.

=== Getting Started with Gramps in Django ===

A prototype of a GRAMPS Gramps Django webapp is now in branches/geps/gep-013-servertrunk and gramps32. To run it, do the following:

# Download Django. I'm running version 1.0.3or greater## On yum-based systems, try "yum install Django"# Checkout # On apt-based systems, try "sudo apt-get install python-django"## Other systems: get the branchessources from http:/geps/gep-013-server from SVNwww.djangoproject.com/download/# clone the Git repository and checkout either the gramps32 or master branch # cd gep-013-server/src/gen/web/# Edit settings.pyBuild the database, and load with default data:## Edit the path to the Sqlite DBmake clean## make## This will ask for an id, email, and password for a superuser. You can add one later if you don't do it now.# Run the test webserver:## make run

Concurrent access for write and read imply several problems when people by accident change the same objects at the same time. GRAMPS Gramps itself has an elaborate signal handling for cases when dialogs are open with no longer current information. In a web environment, this becomes more difficult however. This is not built into Django.

== Example GMS Web Sites == We now have a example gramps webapp on the web: * http://gramps-connect.org/ Genealogy Management Systems on the web: * http://www.dertinger.de/Dertinger_database/en/en_index.htm (Oxy-gen)* http://www.admiraal.org (PhpGedView): Note here: the intro page is a collection of gadgets/controls, which then link into the real data.* http://webtrees.net/demo/next (webtrees)* http://beck.org.il/humogen/ (HuMogen)* http://genealogies.geneamania.net/servin/ (Généamania)* http://www.geneotree.com/geneotree/index.php (Geneotree)* http://ancestorsnow.com/ancestors* http://www.phpmyfamily.net/demo/* http://www.frog.za.net/family/surname-list.php ([[Other_genealogy_tools#Gramps-php-exporter|gramps-php-exporter]]) Collaborative database (user/wizard/password): * http://roglo.eu/roglo?lang=en (GeneWeb)* http://gennus.org ([http://beta.gennus.org/en/page/about.html beta][http://beta.gennus.org/en/page/releasenotes.html])* http://brozer.fr (alpha[http://www.innovup.com/evenement/124/89-actualites-agenda.htm]) Source oriented: * http://solumslekt.org/forays/yggdrasil.php [http://code.google.com/p/yggdrasil-genealogy/][http://solumslekt.org/blog/] ==See also==*[[Gramps-Connect: Introduction|gramps-connect]] [[Category:GEPS|SG]]