17 |
49 |
50 |
18 | }})
19 |
20 |
21 |
47 |
48 |
19 |
51 |
52 |
53 |
54 |
19 | 
2 |
3 | cemetery-map
4 | ============
5 | The cemetery-map Web application is a responsive Python+Flask+SQLAlchemy+Google
6 | Maps app that allows people to search for loved ones in a cemetery. This
7 | application is a Flask rewrite of a previous Node.js app written by
8 | [jbshep](http://github.com/jbshep) and his students, which was designed
9 | specifically for the cemetery in Storm Lake, Iowa, U.S.A.
10 |
11 | ## Installation
12 |
13 | Those interested in contributing code are encouraged to use virtualenv to
14 | manage their Python version, site-packages, and environment variables. After
15 | downloading and installing virtualenv, developers can create a virtual
16 | environment in a directory named `env` by typing something like
17 | `pyvenv-3.5 env`. To activate new virtual environment, developers should
18 | create their own `.env` file that can be sourced (i.e., the command to be typed would be `source .env`)
19 | to populate the shell with important environment variables that contain
20 | API keys, database URL's, and other configuration values that are defined
21 | in `config.py`. A sample `.env` file can be found in the repository root; it
22 | is named sample.env.
23 |
24 | To begin installation of the app, you must first install PostgreSQL and add
25 | PostgreSQL's bin directory to your path. Run psql and type the command `create
26 | database cemdb;` You can then build and run the app as follows:
27 | ```console
28 | pip3 install -r requirements.txt
29 | python3 manage.py db upgrade
30 | python3 manage.py runserver
31 | ```
32 |
33 | You can now browse to [http://localhost:5000/](http://localhost:5000/) to view the running app.
34 |
35 | If you did not add PostgreSQL's bin directory to your PATH prior to executing
36 | the above commands, you will likely see the error `Error: pg_config executable
37 | not found.`
38 |
39 | ## Deploying on Heroku
40 |
41 | New developers can develop locally on their own computers. However, at some point you may wish to deploy to the cloud. This section describes how to deploy cemetery-map to Heroku. You only need to complete the instructions in this section if you want to deploy to Heroku.
42 |
43 | First, obtain a Heroku user ID and install the Heroku toolbelt by visiting [Heroku.com](http://www.heroku.com/). When you are logged in to the Heroku Web site and the developer dashboard, create a new Python app named cemetery-map. If that name is currently in use, you may choose a slightly different name. Then, in your shell in your local repository directory, type the following commands; these assume your app is named cemetery-map.
44 |
45 | First, give the Heroku toolbelt your Heroku developer credentials by typing:
46 | ```console
47 | heroku login
48 | ```
49 |
50 | Then, add a new git remote for Heroku so that we can push code to it.
51 | ```console
52 | heroku git:remote -a cemetery-map
53 | git push heroku master
54 | ```
55 |
56 | Our Heroku instance has environment variables that contain configuration information the same way we store info in environment variables within our virtual environment. We can see what variables have been defined by executing:
57 | ```console
58 | heroku config --app cemetery-map
59 | ```
60 |
61 | Initially the above command will return nothing. To add config variables for our Heroku app, use the `config:set` command, like this:
62 | ```console
63 | heroku config:set APP_SETTINGS=config.ProductionConfig --remote heroku
64 | ```
65 |
66 | Consult `config.py` to see which environment variables will need to be defined.
67 |
68 | Finally, run the DB migrations remotely to create the necessary database tables.
69 |
70 | ```console
71 | heroku run python manage.py db upgrade --app cemetery-map
72 | ```
73 |
74 | ## Contributing
75 |
76 | BVU students interested in contributing should write code that conforms to the
77 | [PEP8](https://www.python.org/dev/peps/pep-0008/) coding standards. Individual files should be checked by typing `pep8 filename`. Developers are encouraged to use GitHub's fork/pull request mechanism for contributing to this repository.
78 |
--------------------------------------------------------------------------------
/admin.py:
--------------------------------------------------------------------------------
1 | from models import Burial, BurialImage
2 | from flask_admin import Admin, form
3 | from flask_admin.contrib.sqla import ModelView
4 | from flask_admin.form.upload import FileUploadField
5 | from jinja2 import Markup
6 | from wtforms import ValidationError, fields
7 | # from wtforms.validators import required
8 | from wtforms.widgets import HTMLString, html_params, FileInput
9 |
10 |
11 | # LargeBinary upload code lifted from
12 | # http://stackoverflow.com/questions/33722132/storing-a-pdf-file-in-db-with-flask-admin
13 | class BlobUploadField(fields.StringField):
14 |
15 | widget = FileInput()
16 |
17 | def __init__(self, label=None, allowed_extensions=None, size_field=None,
18 | filename_field=None, mimetype_field=None, **kwargs):
19 |
20 | self.allowed_extensions = allowed_extensions
21 | self.size_field = size_field
22 | self.filename_field = filename_field
23 | self.mimetype_field = mimetype_field
24 | # validators = [required()]
25 | validators = []
26 |
27 | super(BlobUploadField, self).__init__(label, validators, **kwargs)
28 |
29 | def is_file_allowed(self, filename):
30 | """
31 | Check if file extension is allowed.
32 |
33 | :param filename:
34 | File name to check
35 | """
36 | if not self.allowed_extensions:
37 | return True
38 |
39 | return ('.' in filename and
40 | filename.rsplit('.', 1)[1].lower() in
41 | map(lambda x: x.lower(), self.allowed_extensions))
42 |
43 | def _is_uploaded_file(self, data):
44 | return data and data.filename
45 |
46 | def pre_validate(self, form):
47 | super(BlobUploadField, self).pre_validate(form)
48 | if (self._is_uploaded_file(self.data) and
49 | not self.is_file_allowed(self.data.filename)):
50 | raise ValidationError(gettext('Invalid file extension'))
51 |
52 | def process_formdata(self, valuelist):
53 | if valuelist:
54 | data = valuelist[0]
55 | self.data = data
56 |
57 | def populate_obj(self, obj, name):
58 |
59 | if self._is_uploaded_file(self.data):
60 |
61 | _blob = self.data.read()
62 |
63 | setattr(obj, name, _blob)
64 |
65 | if self.size_field:
66 | setattr(obj, self.size_field, len(_blob))
67 |
68 | '''
69 | if self.filename_field:
70 | setattr(obj, self.filename_field, self.data.filename)
71 | '''
72 |
73 | if self.mimetype_field:
74 | setattr(obj, self.mimetype_field, self.data.content_type)
75 |
76 |
77 | class BurialModelView(ModelView):
78 | column_searchable_list = (Burial.last_name, Burial.first_name,
79 | Burial.lot_owner, Burial.sd_type,
80 | Burial.sd, Burial.lot, Burial.space)
81 |
82 |
83 | class BurialImageModelView(ModelView):
84 | form_extra_fields = {'data': BlobUploadField(
85 | label='File',
86 | allowed_extensions=['png', 'jpg', 'jpeg', 'gif'],
87 | size_field='size',
88 | filename_field='filename',
89 | mimetype_field='mimetype'
90 | )}
91 |
92 | def _photo_formatter(view, context, burialimage, attr_name):
93 | ''' This formatter displays the first ten bytes.
94 | '''
95 | attr_val = getattr(burialimage, attr_name)
96 | return 'NULL' if (attr_val is None or
97 | len(attr_val) == 0) else str(attr_val[0:10]) + '...'
98 |
99 | def _download_formatter(self, context, burialimage, attr_name):
100 | ''' This formatter displays a download link that can be used to
101 | download the image for viewing.
102 | '''
103 | attr_val = getattr(burialimage, attr_name)
104 |
105 | if attr_val is None or len(attr_val) == 0:
106 | return 'NULL'
107 |
108 | return Markup("Download"
109 | .format(url=self.get_url('download_image',
110 | burial_id=burialimage.burial_id,
111 | image_id=burialimage.id)))
112 |
113 | column_formatters = {
114 | 'data': _download_formatter,
115 | }
116 |
--------------------------------------------------------------------------------
/models.py:
--------------------------------------------------------------------------------
1 | from app import db
2 | from json import JSONEncoder
3 |
4 |
5 | class Burial(db.Model):
6 | __tablename__ = 'burials'
7 |
8 | # Most columns are strings--even dates--because a city's data
9 | # is often free-form in cases where dates are fuzzy,
10 | # e.g., '1960?' (note the question mark).
11 | id = db.Column(db.Integer, primary_key=True)
12 | sd_type = db.Column(db.String())
13 | sd = db.Column(db.String())
14 | lot = db.Column(db.String())
15 | space = db.Column(db.String())
16 | lot_owner = db.Column(db.String())
17 | year_purch = db.Column(db.String())
18 | last_name = db.Column(db.String())
19 | first_name = db.Column(db.String())
20 | sex = db.Column(db.String())
21 | birth_date = db.Column(db.String())
22 | birth_place = db.Column(db.String())
23 | death_date = db.Column(db.String())
24 | age = db.Column(db.String())
25 | death_place = db.Column(db.String())
26 | death_cause = db.Column(db.String())
27 | burial_date = db.Column(db.String())
28 | notes = db.Column(db.String())
29 | more_notes = db.Column(db.String())
30 | hidden_notes = db.Column(db.String())
31 | lat = db.Column(db.Float())
32 | lng = db.Column(db.Float())
33 |
34 | def __repr__(self):
35 | return '