").append( jQuery.parseHTML( responseText ) ).find( selector ) :
63 |
64 | // Otherwise use the full result
65 | responseText );
66 |
67 | }).complete( callback && function( jqXHR, status ) {
68 | self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
69 | });
70 | }
71 |
72 | return this;
73 | };
74 |
75 | });
76 |
--------------------------------------------------------------------------------
/flask_editablesite/static/libs/jQuery/src/ajax/parseJSON.js:
--------------------------------------------------------------------------------
1 | define([
2 | "../core"
3 | ], function( jQuery ) {
4 |
5 | // Support: Android 2.3
6 | // Workaround failure to string-cast null input
7 | jQuery.parseJSON = function( data ) {
8 | return JSON.parse( data + "" );
9 | };
10 |
11 | return jQuery.parseJSON;
12 |
13 | });
14 |
--------------------------------------------------------------------------------
/flask_editablesite/static/libs/jQuery/src/ajax/parseXML.js:
--------------------------------------------------------------------------------
1 | define([
2 | "../core"
3 | ], function( jQuery ) {
4 |
5 | // Cross-browser xml parsing
6 | jQuery.parseXML = function( data ) {
7 | var xml, tmp;
8 | if ( !data || typeof data !== "string" ) {
9 | return null;
10 | }
11 |
12 | // Support: IE9
13 | try {
14 | tmp = new DOMParser();
15 | xml = tmp.parseFromString( data, "text/xml" );
16 | } catch ( e ) {
17 | xml = undefined;
18 | }
19 |
20 | if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
21 | jQuery.error( "Invalid XML: " + data );
22 | }
23 | return xml;
24 | };
25 |
26 | return jQuery.parseXML;
27 |
28 | });
29 |
--------------------------------------------------------------------------------
/flask_editablesite/static/libs/jQuery/src/ajax/script.js:
--------------------------------------------------------------------------------
1 | define([
2 | "../core",
3 | "../ajax"
4 | ], function( jQuery ) {
5 |
6 | // Install script dataType
7 | jQuery.ajaxSetup({
8 | accepts: {
9 | script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
10 | },
11 | contents: {
12 | script: /(?:java|ecma)script/
13 | },
14 | converters: {
15 | "text script": function( text ) {
16 | jQuery.globalEval( text );
17 | return text;
18 | }
19 | }
20 | });
21 |
22 | // Handle cache's special case and crossDomain
23 | jQuery.ajaxPrefilter( "script", function( s ) {
24 | if ( s.cache === undefined ) {
25 | s.cache = false;
26 | }
27 | if ( s.crossDomain ) {
28 | s.type = "GET";
29 | }
30 | });
31 |
32 | // Bind script tag hack transport
33 | jQuery.ajaxTransport( "script", function( s ) {
34 | // This transport only deals with cross domain requests
35 | if ( s.crossDomain ) {
36 | var script, callback;
37 | return {
38 | send: function( _, complete ) {
39 | script = jQuery("
4 |
--------------------------------------------------------------------------------
/flask_editablesite/templates/macros/dante.html:
--------------------------------------------------------------------------------
1 | {% macro field(f, field_id='', label_class="control-label hidden") %}
2 |
21 | {% endmacro %}
22 |
--------------------------------------------------------------------------------
/flask_editablesite/templates/macros/date_pick.html:
--------------------------------------------------------------------------------
1 | {% import 'macros/heading.html' as heading %}
2 |
3 | {% macro form(model_name, field_name, model_identifier, form, class='datepicker-enable', placeholder='Pick your date', wrap_element_start='', wrap_element_end='') %}
4 |
5 | {% set model_identifier = model_identifier|string %}
6 |
7 | {% with field_id = (model_name + '-' + field_name + '-' + model_identifier) %}
8 |
9 |
28 |
29 | {% endwith %}
30 |
31 | {% endmacro %}
32 |
--------------------------------------------------------------------------------
/flask_editablesite/templates/macros/heading.html:
--------------------------------------------------------------------------------
1 | {% macro field(field, field_id='', class='h2', placeholder='Type your title', label_class='control-label hidden', wrap_element_start='', wrap_element_end='') %}
2 |
3 | {% if wrap_element_start == '
' %}
4 | {% set wrap_el_type = 'span' %}
5 | {% else %}
6 | {% set wrap_el_type = 'div' %}
7 | {% endif %}
8 |
9 | <{{ wrap_el_type }} class="form-group {% if field.errors %} has-error{% endif %}">
10 |
11 |
12 | {%- if wrap_element_start %}
13 | {{ wrap_element_start|safe }}
14 | {%- endif %}
15 |
16 | {% if field.flags.required and not required in kwargs %}
17 | {% set kwargs = dict(required=True, **kwargs) %}
18 | {% endif %}
19 |
20 | {{field(class=class, id=field_id, placeholder=placeholder, **kwargs)|safe}}
21 |
22 | {%- if wrap_element_end %}
23 | {{ wrap_element_end|safe }}
24 | {%- endif %}
25 |
26 | {%- if field.errors %}
27 | {%- for error in field.errors %}
28 | {{error}}
29 | {%- endfor %}
30 | {%- elif field.description -%}
31 | {{field.description|safe}}
32 | {%- endif %}
33 |
34 | {% endmacro %}
35 |
36 |
--------------------------------------------------------------------------------
/flask_editablesite/templates/macros/hiddenfield.html:
--------------------------------------------------------------------------------
1 | {% macro field(field, label_class='control-label hidden') %}
2 |
3 |
16 | {% endmacro %}
17 |
--------------------------------------------------------------------------------
/flask_editablesite/templates/macros/image.html:
--------------------------------------------------------------------------------
1 | {% import 'macros/heading.html' as heading %}
2 |
3 | {% macro form(model_name, field_name, model_identifier, form, image_url, class='img-responsive', alt='', placeholder='Upload your image') %}
4 |
5 | {% set model_identifier = model_identifier|string %}
6 |
7 | {% with field_id = (model_name + '-' + field_name + '-' + model_identifier) %}
8 |
9 |
26 |
27 | {% endwith %}
28 |
29 | {% endmacro %}
30 |
--------------------------------------------------------------------------------
/flask_editablesite/templates/macros/rich_text.html:
--------------------------------------------------------------------------------
1 | {% import 'macros/dante.html' as dante %}
2 |
3 | {% macro form(model_name, field_name, model_identifier, form, placeholder='Type your content') %}
4 |
5 | {% set model_identifier = model_identifier|string %}
6 |
7 | {% with field_id = (model_name + '-' + field_name + '-' + model_identifier) %}
8 |
9 |
20 |
21 | {% endwith %}
22 |
23 | {% endmacro %}
24 |
--------------------------------------------------------------------------------
/flask_editablesite/templates/macros/short_text.html:
--------------------------------------------------------------------------------
1 | {% import 'macros/heading.html' as heading %}
2 |
3 | {% macro form(model_name, field_name, model_identifier, form, class='h2', placeholder='Type your title', wrap_element_start='', wrap_element_end='') %}
4 |
5 | {% set model_identifier = model_identifier|string %}
6 |
7 | {% with field_id = (model_name + '-' + field_name + '-' + model_identifier) %}
8 |
9 |
28 |
29 | {% endwith %}
30 |
31 | {% endmacro %}
32 |
--------------------------------------------------------------------------------
/flask_editablesite/templates/macros/time_pick.html:
--------------------------------------------------------------------------------
1 | {% import 'macros/heading.html' as heading %}
2 |
3 | {% macro form(model_name, field_name, model_identifier, form, class='timepicker-enable', placeholder='Pick your time', wrap_element_start='', wrap_element_end='') %}
4 |
5 | {% set model_identifier = model_identifier|string %}
6 |
7 | {% with field_id = (model_name + '-' + field_name + '-' + model_identifier) %}
8 |
9 |
28 |
29 | {% endwith %}
30 |
31 | {% endmacro %}
32 |
--------------------------------------------------------------------------------
/flask_editablesite/templates/nav.html:
--------------------------------------------------------------------------------
1 |
2 |
30 |
31 |
--------------------------------------------------------------------------------
/flask_editablesite/user/__init__.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 |
--------------------------------------------------------------------------------
/flask_editablesite/user/commands.py:
--------------------------------------------------------------------------------
1 | from flask import current_app as app
2 | from flask_script import Command, Option, prompt, prompt_pass
3 |
4 |
5 | class CreateUser(Command):
6 | """Creates a user."""
7 |
8 | def get_options(self):
9 | return (
10 | Option('--email',
11 | help='User e-mail'),
12 | Option('--first-name',
13 | help='User first name'),
14 | Option('--last-name',
15 | help='User last name'),
16 | Option('--password',
17 | help='User password')
18 | )
19 |
20 | def create_user(self, email, first_name, last_name, password):
21 | from flask_editablesite.user.models import User
22 |
23 | u = User(email=email, first_name=first_name,
24 | last_name=last_name, active=True)
25 | u.set_password(password)
26 | u.save()
27 |
28 | return u
29 |
30 | def run(self, email=None, first_name=None, last_name=None, password=None):
31 | if not email:
32 | email = prompt("A valid email address")
33 |
34 | if not first_name:
35 | first_name = prompt("First name")
36 |
37 | if not last_name:
38 | last_name = prompt("Last name")
39 |
40 | if not password:
41 | password = prompt_pass("Password")
42 |
43 | user = (
44 | (not app.config.get('USE_SESSIONSTORE_NOT_DB'))
45 | and self.create_user(
46 | email=email,
47 | first_name=first_name,
48 | last_name=last_name,
49 | password=password)
50 | or None)
51 |
52 | if not user:
53 | user = "Can't create the user"
54 |
55 | print(user)
56 |
--------------------------------------------------------------------------------
/flask_editablesite/user/models.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 |
3 | from flask import current_app as app
4 | from flask_login import UserMixin
5 | from sqlalchemy import event
6 |
7 | from flask_editablesite.extensions import bcrypt
8 | from flask_editablesite.database import (
9 | Column,
10 | db,
11 | Model,
12 | SurrogatePK,
13 | TimeStamped,
14 | Confirmable,
15 | update_timestamps_before_insert,
16 | update_timestamps_before_update,
17 | update_confirmedat_before_save,
18 | )
19 |
20 |
21 | class User(UserMixin, SurrogatePK, TimeStamped, Confirmable, Model):
22 | __tablename__ = 'users'
23 |
24 | email = Column(db.String(255), unique=True, nullable=False)
25 | password = Column(db.String(255), nullable=True)
26 | first_name = Column(db.String(255), nullable=True)
27 | last_name = Column(db.String(255), nullable=True)
28 |
29 | def __init__(self, email, password=None, **kwargs):
30 | db.Model.__init__(self, email=email, **kwargs)
31 | if password:
32 | self.set_password(password)
33 | else:
34 | self.password = None
35 |
36 | def set_password(self, password):
37 | self.password = bcrypt.generate_password_hash(password)
38 |
39 | def check_password(self, value):
40 | return bcrypt.check_password_hash(self.password, value)
41 |
42 | @property
43 | def full_name(self):
44 | if self.first_name and self.last_name:
45 | return "{0} {1}".format(self.first_name, self.last_name)
46 |
47 | return ""
48 |
49 | @property
50 | def full_name_or_email(self):
51 | return self.full_name or self.email
52 |
53 | def __repr__(self):
54 | return '{0} <{1}>'.format(self.full_name, self.email)
55 |
56 | @classmethod
57 | def sessionstore_user(cls):
58 | """
59 | A dummy user object to represent the logged-in user when
60 | we're set to 'sessionstore' instead of 'db'.
61 | """
62 |
63 | return cls(
64 | email=app.config['SESSIONSTORE_USER_EMAIL'],
65 | first_name=app.config['SESSIONSTORE_USER_FIRST_NAME'],
66 | last_name=app.config['SESSIONSTORE_USER_LAST_NAME'],
67 | active=True)
68 |
69 |
70 | event.listen(User, 'before_insert', update_timestamps_before_insert)
71 | event.listen(User, 'before_update', update_timestamps_before_update)
72 |
73 | event.listen(User, 'before_insert', update_confirmedat_before_save)
74 | event.listen(User, 'before_update', update_confirmedat_before_save)
75 |
--------------------------------------------------------------------------------
/flask_editablesite/utils.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """Helper utilities and decorators."""
3 | from flask import flash
4 |
5 |
6 | def flash_errors(form, category="warning"):
7 | """Flash all errors for a form."""
8 | for field, errors in form.errors.items():
9 | for error in errors:
10 | flash("{0} - {1}"
11 | .format(getattr(form, field).label.text, error), category)
12 |
--------------------------------------------------------------------------------
/manage.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 | import os
4 | from flask_script import Manager, Shell, Server
5 | from flask_script.commands import Clean, ShowUrls
6 | from flask_migrate import MigrateCommand
7 |
8 | from flask_editablesite.app import create_app
9 | from flask_editablesite.user.commands import CreateUser
10 | from flask_editablesite.editable.commands import DownloadSampleImages
11 | from flask_editablesite.user.models import User
12 | from flask_editablesite.settings import DevConfig, ProdConfig
13 | from flask_editablesite.database import db
14 |
15 | if os.environ.get("FLASK_EDITABLESITE_ENV") == 'prod':
16 | app = create_app(ProdConfig)
17 | else:
18 | app = create_app(DevConfig)
19 |
20 | HERE = os.path.abspath(os.path.dirname(__file__))
21 | TEST_PATH = os.path.join(HERE, 'tests')
22 |
23 | manager = Manager(app)
24 |
25 |
26 | def _make_context():
27 | """Return context dict for a shell session so you can access
28 | app, db, and the User model by default.
29 | """
30 | return {'app': app, 'db': db, 'User': User}
31 |
32 |
33 | @manager.command
34 | def test():
35 | """Run the tests."""
36 | import pytest
37 | exit_code = pytest.main([TEST_PATH, '--verbose'])
38 | return exit_code
39 |
40 |
41 | manager.add_command('server', Server())
42 | manager.add_command('shell', Shell(make_context=_make_context))
43 | manager.add_command('db', MigrateCommand)
44 | manager.add_command("urls", ShowUrls())
45 | manager.add_command("clean", Clean())
46 | manager.add_command("createuser", CreateUser())
47 | manager.add_command("downloadsampleimages", DownloadSampleImages())
48 |
49 | if __name__ == '__main__':
50 | manager.run()
51 |
--------------------------------------------------------------------------------
/migrations/README:
--------------------------------------------------------------------------------
1 | Generic single-database configuration.
--------------------------------------------------------------------------------
/migrations/alembic.ini:
--------------------------------------------------------------------------------
1 | # A generic, single database configuration.
2 |
3 | [alembic]
4 | # template used to generate migration files
5 | # file_template = %%(rev)s_%%(slug)s
6 |
7 | # set to 'true' to run the environment during
8 | # the 'revision' command, regardless of autogenerate
9 | # revision_environment = false
10 |
11 |
12 | # Logging configuration
13 | [loggers]
14 | keys = root,sqlalchemy,alembic
15 |
16 | [handlers]
17 | keys = console
18 |
19 | [formatters]
20 | keys = generic
21 |
22 | [logger_root]
23 | level = WARN
24 | handlers = console
25 | qualname =
26 |
27 | [logger_sqlalchemy]
28 | level = WARN
29 | handlers =
30 | qualname = sqlalchemy.engine
31 |
32 | [logger_alembic]
33 | level = INFO
34 | handlers =
35 | qualname = alembic
36 |
37 | [handler_console]
38 | class = StreamHandler
39 | args = (sys.stderr,)
40 | level = NOTSET
41 | formatter = generic
42 |
43 | [formatter_generic]
44 | format = %(levelname)-5.5s [%(name)s] %(message)s
45 | datefmt = %H:%M:%S
46 |
--------------------------------------------------------------------------------
/migrations/env.py:
--------------------------------------------------------------------------------
1 | from __future__ import with_statement
2 | from alembic import context
3 | from sqlalchemy import engine_from_config, pool
4 | from logging.config import fileConfig
5 |
6 | # this is the Alembic Config object, which provides
7 | # access to the values within the .ini file in use.
8 | config = context.config
9 |
10 | # Interpret the config file for Python logging.
11 | # This line sets up loggers basically.
12 | fileConfig(config.config_file_name)
13 |
14 | # add your model's MetaData object here
15 | # for 'autogenerate' support
16 | # from myapp import mymodel
17 | # target_metadata = mymodel.Base.metadata
18 | from flask import current_app
19 | config.set_main_option('sqlalchemy.url', current_app.config.get('SQLALCHEMY_DATABASE_URI'))
20 | target_metadata = current_app.extensions['migrate'].db.metadata
21 |
22 | # other values from the config, defined by the needs of env.py,
23 | # can be acquired:
24 | # my_important_option = config.get_main_option("my_important_option")
25 | # ... etc.
26 |
27 | def run_migrations_offline():
28 | """Run migrations in 'offline' mode.
29 |
30 | This configures the context with just a URL
31 | and not an Engine, though an Engine is acceptable
32 | here as well. By skipping the Engine creation
33 | we don't even need a DBAPI to be available.
34 |
35 | Calls to context.execute() here emit the given string to the
36 | script output.
37 |
38 | """
39 | url = config.get_main_option("sqlalchemy.url")
40 | context.configure(url=url)
41 |
42 | with context.begin_transaction():
43 | context.run_migrations()
44 |
45 | def run_migrations_online():
46 | """Run migrations in 'online' mode.
47 |
48 | In this scenario we need to create an Engine
49 | and associate a connection with the context.
50 |
51 | """
52 | engine = engine_from_config(
53 | config.get_section(config.config_ini_section),
54 | prefix='sqlalchemy.',
55 | poolclass=pool.NullPool)
56 |
57 | connection = engine.connect()
58 | context.configure(
59 | connection=connection,
60 | target_metadata=target_metadata
61 | )
62 |
63 | try:
64 | with context.begin_transaction():
65 | context.run_migrations()
66 | finally:
67 | connection.close()
68 |
69 | if context.is_offline_mode():
70 | run_migrations_offline()
71 | else:
72 | run_migrations_online()
73 |
74 |
--------------------------------------------------------------------------------
/migrations/script.py.mako:
--------------------------------------------------------------------------------
1 | """${message}
2 |
3 | Revision ID: ${up_revision}
4 | Revises: ${down_revision}
5 | Create Date: ${create_date}
6 |
7 | """
8 |
9 | # revision identifiers, used by Alembic.
10 | revision = ${repr(up_revision)}
11 | down_revision = ${repr(down_revision)}
12 |
13 | from alembic import op
14 | import sqlalchemy as sa
15 | ${imports if imports else ""}
16 |
17 | def upgrade():
18 | ${upgrades if upgrades else "pass"}
19 |
20 |
21 | def downgrade():
22 | ${downgrades if downgrades else "pass"}
23 |
--------------------------------------------------------------------------------
/migrations/versions/10ac6fbf6ec5_.py:
--------------------------------------------------------------------------------
1 | """empty message
2 |
3 | Revision ID: 10ac6fbf6ec5
4 | Revises: None
5 | Create Date: 2015-09-30 10:29:48.039279
6 |
7 | """
8 |
9 | # revision identifiers, used by Alembic.
10 | revision = '10ac6fbf6ec5'
11 | down_revision = None
12 |
13 | from alembic import op
14 | import sqlalchemy as sa
15 |
16 |
17 | def upgrade():
18 | ### commands auto generated by Alembic - please adjust! ###
19 | op.create_table('users',
20 | sa.Column('id', sa.Integer(), nullable=False),
21 | sa.Column('created_at', sa.DateTime(), nullable=True),
22 | sa.Column('updated_at', sa.DateTime(), nullable=True),
23 | sa.Column('active', sa.Boolean(), nullable=True),
24 | sa.Column('confirmed_at', sa.DateTime(), nullable=True),
25 | sa.Column('email', sa.String(length=255), nullable=False),
26 | sa.Column('password', sa.String(length=255), nullable=True),
27 | sa.Column('first_name', sa.String(length=255), nullable=True),
28 | sa.Column('last_name', sa.String(length=255), nullable=True),
29 | sa.PrimaryKeyConstraint('id'),
30 | sa.UniqueConstraint('email')
31 | )
32 | ### end Alembic commands ###
33 |
34 |
35 | def downgrade():
36 | ### commands auto generated by Alembic - please adjust! ###
37 | op.drop_table('users')
38 | ### end Alembic commands ###
39 |
--------------------------------------------------------------------------------
/migrations/versions/213a4ce02333_.py:
--------------------------------------------------------------------------------
1 | """empty message
2 |
3 | Revision ID: 213a4ce02333
4 | Revises: 2829167b2aff
5 | Create Date: 2015-10-16 14:48:47.100041
6 |
7 | """
8 |
9 | # revision identifiers, used by Alembic.
10 | revision = '213a4ce02333'
11 | down_revision = '2829167b2aff'
12 |
13 | from alembic import op
14 | import sqlalchemy as sa
15 |
16 |
17 | def upgrade():
18 | ### commands auto generated by Alembic - please adjust! ###
19 | op.create_table('event',
20 | sa.Column('id', sa.Integer(), nullable=False),
21 | sa.Column('title', sa.String(length=255), nullable=True),
22 | sa.Column('slug', sa.String(length=255), nullable=True),
23 | sa.Column('created_at', sa.DateTime(), nullable=True),
24 | sa.Column('updated_at', sa.DateTime(), nullable=True),
25 | sa.Column('active', sa.Boolean(), nullable=True),
26 | sa.Column('confirmed_at', sa.DateTime(), nullable=True),
27 | sa.Column('start_date', sa.Date(), nullable=False),
28 | sa.Column('end_date', sa.Date(), nullable=True),
29 | sa.Column('start_time', sa.Time(), nullable=True),
30 | sa.Column('end_time', sa.Time(), nullable=True),
31 | sa.Column('event_url', sa.String(length=255), nullable=False),
32 | sa.Column('location_name', sa.String(length=255), nullable=False),
33 | sa.Column('location_url', sa.String(length=255), nullable=False),
34 | sa.PrimaryKeyConstraint('id'),
35 | sa.UniqueConstraint('slug', name='_event_slug_uc')
36 | )
37 | op.create_index('_event_active_startdate_ix', 'event', ['active', 'start_date'], unique=False)
38 | ### end Alembic commands ###
39 |
40 |
41 | def downgrade():
42 | ### commands auto generated by Alembic - please adjust! ###
43 | op.drop_index('_event_active_startdate_ix', table_name='event')
44 | op.drop_table('event')
45 | ### end Alembic commands ###
46 |
--------------------------------------------------------------------------------
/migrations/versions/2829167b2aff_.py:
--------------------------------------------------------------------------------
1 | """empty message
2 |
3 | Revision ID: 2829167b2aff
4 | Revises: 4c98d9952b7e
5 | Create Date: 2015-10-14 11:02:23.553489
6 |
7 | """
8 |
9 | # revision identifiers, used by Alembic.
10 | revision = '2829167b2aff'
11 | down_revision = '4c98d9952b7e'
12 |
13 | from alembic import op
14 | import sqlalchemy as sa
15 |
16 |
17 | def upgrade():
18 | ### commands auto generated by Alembic - please adjust! ###
19 | op.create_table('gallery_item',
20 | sa.Column('id', sa.Integer(), nullable=False),
21 | sa.Column('title', sa.String(length=255), nullable=True),
22 | sa.Column('slug', sa.String(length=255), nullable=True),
23 | sa.Column('created_at', sa.DateTime(), nullable=True),
24 | sa.Column('updated_at', sa.DateTime(), nullable=True),
25 | sa.Column('active', sa.Boolean(), nullable=True),
26 | sa.Column('confirmed_at', sa.DateTime(), nullable=True),
27 | sa.Column('image', sa.String(length=255), nullable=False),
28 | sa.Column('content', sa.Text(), nullable=False),
29 | sa.Column('date_taken', sa.String(length=255), nullable=False),
30 | sa.Column('weight', sa.Integer(), nullable=False),
31 | sa.PrimaryKeyConstraint('id'),
32 | sa.UniqueConstraint('slug', name='_gi_slug_uc')
33 | )
34 | op.create_index('_gi_slug_active_ix', 'gallery_item', ['slug', 'active'], unique=False)
35 | ### end Alembic commands ###
36 |
37 |
38 | def downgrade():
39 | ### commands auto generated by Alembic - please adjust! ###
40 | op.drop_index('_gi_slug_active_ix', table_name='gallery_item')
41 | op.drop_table('gallery_item')
42 | ### end Alembic commands ###
43 |
--------------------------------------------------------------------------------
/migrations/versions/4c98d9952b7e_.py:
--------------------------------------------------------------------------------
1 | """empty message
2 |
3 | Revision ID: 4c98d9952b7e
4 | Revises: 10ac6fbf6ec5
5 | Create Date: 2015-10-01 11:15:15.840234
6 |
7 | """
8 |
9 | # revision identifiers, used by Alembic.
10 | revision = '4c98d9952b7e'
11 | down_revision = '10ac6fbf6ec5'
12 |
13 | from alembic import op
14 | import sqlalchemy as sa
15 |
16 |
17 | def upgrade():
18 | ### commands auto generated by Alembic - please adjust! ###
19 | op.create_table('short_text_content_block',
20 | sa.Column('id', sa.Integer(), nullable=False),
21 | sa.Column('title', sa.String(length=255), nullable=True),
22 | sa.Column('slug', sa.String(length=255), nullable=True),
23 | sa.Column('created_at', sa.DateTime(), nullable=True),
24 | sa.Column('updated_at', sa.DateTime(), nullable=True),
25 | sa.Column('active', sa.Boolean(), nullable=True),
26 | sa.Column('confirmed_at', sa.DateTime(), nullable=True),
27 | sa.Column('content', sa.String(length=255), nullable=False),
28 | sa.PrimaryKeyConstraint('id'),
29 | sa.UniqueConstraint('slug', name='_stcb_slug_uc')
30 | )
31 | op.create_index('_stcb_slug_active_ix', 'short_text_content_block', ['slug', 'active'], unique=False)
32 | op.create_table('rich_text_content_block',
33 | sa.Column('id', sa.Integer(), nullable=False),
34 | sa.Column('title', sa.String(length=255), nullable=True),
35 | sa.Column('slug', sa.String(length=255), nullable=True),
36 | sa.Column('created_at', sa.DateTime(), nullable=True),
37 | sa.Column('updated_at', sa.DateTime(), nullable=True),
38 | sa.Column('active', sa.Boolean(), nullable=True),
39 | sa.Column('confirmed_at', sa.DateTime(), nullable=True),
40 | sa.Column('content', sa.Text(), nullable=False),
41 | sa.PrimaryKeyConstraint('id'),
42 | sa.UniqueConstraint('slug', name='_rtcb_slug_uc')
43 | )
44 | op.create_index('_rtcb_slug_active_ix', 'rich_text_content_block', ['slug', 'active'], unique=False)
45 | op.create_table('image_content_block',
46 | sa.Column('id', sa.Integer(), nullable=False),
47 | sa.Column('title', sa.String(length=255), nullable=True),
48 | sa.Column('slug', sa.String(length=255), nullable=True),
49 | sa.Column('created_at', sa.DateTime(), nullable=True),
50 | sa.Column('updated_at', sa.DateTime(), nullable=True),
51 | sa.Column('active', sa.Boolean(), nullable=True),
52 | sa.Column('confirmed_at', sa.DateTime(), nullable=True),
53 | sa.Column('image', sa.String(length=255), nullable=False),
54 | sa.PrimaryKeyConstraint('id'),
55 | sa.UniqueConstraint('slug', name='_icb_slug_uc')
56 | )
57 | op.create_index('_icb_slug_active_ix', 'image_content_block', ['slug', 'active'], unique=False)
58 | ### end Alembic commands ###
59 |
60 |
61 | def downgrade():
62 | ### commands auto generated by Alembic - please adjust! ###
63 | op.drop_index('_icb_slug_active_ix', table_name='image_content_block')
64 | op.drop_table('image_content_block')
65 | op.drop_index('_rtcb_slug_active_ix', table_name='rich_text_content_block')
66 | op.drop_table('rich_text_content_block')
67 | op.drop_index('_stcb_slug_active_ix', table_name='short_text_content_block')
68 | op.drop_table('short_text_content_block')
69 | ### end Alembic commands ###
70 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | # Included because many Paas's require a requirements.txt file in the project root
2 | # Just installs the production requirements.
3 | -r requirements/prod.txt
--------------------------------------------------------------------------------
/requirements/dev.txt:
--------------------------------------------------------------------------------
1 | # Everything the developer needs in addition to the production requirements
2 | -r prod.txt
3 |
4 | # Testing
5 | pytest>=2.6.3
6 | coverage
7 | coveralls
8 | webtest
9 | flask-webtest
10 | factory-boy==2.5.1
11 | flake8
12 |
13 | # Management script
14 | Flask-Script
15 |
--------------------------------------------------------------------------------
/requirements/prod.txt:
--------------------------------------------------------------------------------
1 | # Everything needed in production
2 |
3 | # Flask
4 | Flask==0.10.1
5 | MarkupSafe==0.23
6 | Werkzeug==0.10.4
7 | Jinja2==2.7.3
8 | itsdangerous==0.24
9 |
10 | # Database
11 | psycopg2cffi-compat
12 | Flask-SQLAlchemy==2.0
13 | SQLAlchemy==0.9.8
14 | SQLAlchemy-Utils==0.30.16
15 |
16 | # Migrations
17 | Flask-Migrate==1.3.1
18 |
19 | # Forms
20 | Flask-WTF==0.11
21 | WTForms==2.0.2
22 | WTForms-Alchemy==0.13.3
23 |
24 | # Mail
25 | Flask-Mail==0.9.1
26 |
27 | # Deployment
28 | gunicorn>=19.1.1
29 |
30 | # Assets
31 | Flask-Assets==0.10
32 | cssmin>=0.2.0
33 | jsmin>=2.0.11
34 |
35 | # Auth
36 | Flask-Login==0.2.11
37 | Flask-Bcrypt==0.6.2
38 |
39 | # Caching
40 | pymemcache
41 | Flask-Cache>=0.13.1
42 |
43 | # Debug toolbar
44 | Flask-DebugToolbar==0.9.2
45 |
46 | # Sessions
47 | Flask-Session==0.2.2
48 |
49 | # Slugs
50 | awesome-slugify==1.6.5
51 |
52 | # Thumbnails
53 | Flask-thumbnails==0.2.1
54 |
55 | # Uploads
56 | -e git+http://github.com/justanr/Flask-Transfer@47a6cf7#egg=flask_transfer
57 |
58 | # Scraping
59 | lxml
60 | beautifulsoup4==4.4.1
61 | requests
62 | clint==0.5.1
63 |
64 | # Dummy text
65 | Unidecode
66 | markovify==0.2.4
67 |
--------------------------------------------------------------------------------
/tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Jaza/flask-editablesite/a6f22d301516f09ccf79f99c1e10d051871e6d53/tests/__init__.py
--------------------------------------------------------------------------------
/tests/conftest.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """Defines fixtures available to all tests."""
3 |
4 | import pytest
5 | from flask_webtest import TestApp
6 |
7 | from flask_editablesite.settings import TestConfig
8 | from flask_editablesite.app import create_app
9 | from flask_editablesite.database import db as _db
10 |
11 | from .factories import UserFactory
12 |
13 |
14 | @pytest.yield_fixture(scope='session')
15 | def app():
16 | _app = create_app(TestConfig)
17 | ctx = _app.test_request_context()
18 | ctx.push()
19 |
20 | yield _app
21 |
22 | ctx.pop()
23 |
24 |
25 | class SessionStoreTestConfig(TestConfig):
26 | USE_SESSIONSTORE_NOT_DB = True
27 |
28 |
29 | @pytest.fixture(scope='session')
30 | def app_sessionstore():
31 | return create_app(SessionStoreTestConfig)
32 |
33 |
34 | @pytest.fixture(scope='session')
35 | def testapp(app):
36 | """A Webtest app."""
37 | return TestApp(app)
38 |
39 |
40 | @pytest.yield_fixture(scope='session')
41 | def db(app):
42 | _db.app = app
43 | with app.app_context():
44 | _db.session.remove()
45 | _db.drop_all()
46 | _db.create_all()
47 |
48 | yield _db
49 |
50 | _db.session.remove()
51 | _db.drop_all()
52 |
53 | # This dispose() call is needed to avoid the DB locking
54 | # between tests.
55 | # Thanks to:
56 | # http://stackoverflow.com/a/18293157/2066849
57 | _db.get_engine(_db.app).dispose()
58 |
59 |
60 | @pytest.fixture(scope='session')
61 | def user(db):
62 | user = UserFactory(password='myprecious')
63 | db.session.commit()
64 | return user
65 |
--------------------------------------------------------------------------------
/tests/factories.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from factory import Sequence, PostGenerationMethodCall
3 | from factory.alchemy import SQLAlchemyModelFactory
4 |
5 | from flask_editablesite.user.models import User
6 | from flask_editablesite.extensions import db
7 |
8 |
9 | class BaseFactory(SQLAlchemyModelFactory):
10 |
11 | class Meta:
12 | abstract = True
13 | sqlalchemy_session = db.session
14 |
15 |
16 | class UserFactory(BaseFactory):
17 | email = Sequence(lambda n: "user{0}@example.com".format(n))
18 | password = PostGenerationMethodCall('set_password', 'example')
19 | active = True
20 |
21 | class Meta:
22 | model = User
23 |
--------------------------------------------------------------------------------
/tests/test_config.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from flask_editablesite.app import create_app
3 | from flask_editablesite.settings import ProdConfig, DevConfig
4 |
5 |
6 | def test_production_config():
7 | app = create_app(ProdConfig)
8 | assert app.config['ENV'] == 'prod'
9 | assert app.config['DEBUG'] is False
10 | assert app.config['DEBUG_TB_ENABLED'] is False
11 | assert app.config['ASSETS_DEBUG'] is False
12 |
13 |
14 | def test_dev_config():
15 | app = create_app(DevConfig)
16 | assert app.config['ENV'] == 'dev'
17 | assert app.config['DEBUG'] is True
18 | assert app.config['ASSETS_DEBUG'] is True
19 |
--------------------------------------------------------------------------------
/tests/test_contact_views.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """Test using the contact form."""
3 |
4 |
5 | def test_contactform_alert_visible(db, testapp):
6 | # Goes to homepage
7 | res = testapp.get("/")
8 | # Fills out contact form
9 | form = res.forms['contactForm']
10 | form['name'] = 'John Smith'
11 | form['email'] = 'john@smith.com'
12 | form['phone'] = '0404123456'
13 | form['message'] = 'Hi there! How are you?'
14 | # Submits
15 | res = form.submit().follow()
16 | assert res.status_code == 200
17 | assert 'Your message has been sent.' in res
18 |
--------------------------------------------------------------------------------
/tests/test_contentblock_views.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """Test that content blocks show as expected."""
3 |
4 | from flask import url_for
5 |
6 | from flask_editablesite.extensions import thumb
7 | from flask_editablesite.contentblock.models import (
8 | ShortTextContentBlock, RichTextContentBlock)
9 |
10 |
11 | def test_home_textcontentblock_default_content_visible(db, testapp):
12 | default_content = ShortTextContentBlock.default_content()
13 | default_content.update(
14 | RichTextContentBlock.default_content())
15 |
16 | res = testapp.get("/")
17 |
18 | for o in default_content.values():
19 | assert o.content in res.text
20 |
21 |
22 | def test_home_imagecontentblock_default_site_logo_visible(app, db,
23 | testapp):
24 | res = testapp.get("/")
25 |
26 | assert (
27 | (
28 | '![{1}]()
').format(
30 | url_for('static', filename=thumb.thumbnail(
31 | app.config[
32 | 'EDITABLE_PLACEHOLDER_IMAGE_RELATIVE_PATH'],
33 | size='256x256',
34 | crop='fit')),
35 | app.config['SITE_NAME'])
36 | in res.text)
37 |
--------------------------------------------------------------------------------
/tests/test_sample_images.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """Test the sample image selection."""
3 |
4 | import os
5 |
6 | from flask_editablesite.app import create_app
7 | from flask_editablesite.settings import TestConfig
8 |
9 |
10 | from flask_editablesite.editable.sample_images import (
11 | placeholder_or_random_sample_image,)
12 |
13 |
14 | def test_placeholder_when_no_sample_images_configured(app):
15 | sample_image = placeholder_or_random_sample_image()
16 | assert sample_image == app.config[
17 | 'EDITABLE_PLACEHOLDER_IMAGE_RELATIVE_PATH']
18 |
19 |
20 | class ImageScrapeTestConfig(TestConfig):
21 | EDITABLE_SAMPLE_IMAGES_SCRAPE_URL = (
22 | 'http://www.psych.usyd.edu.au/pdp-11/Images/Images.html')
23 | EDITABLE_SAMPLE_IMAGES_SCRAPE_PARENTELNAME = 'li'
24 | EDITABLE_SAMPLE_IMAGES_RELATIVE_PATH = 'pdp11/'
25 |
26 |
27 | def test_sample_image_when_scrape_configured():
28 | app = create_app(ImageScrapeTestConfig)
29 |
30 | with app.app_context():
31 | sample_image = placeholder_or_random_sample_image()
32 |
33 | assert sample_image is not None
34 | assert len(sample_image)
35 | assert sample_image != app.config[
36 | 'EDITABLE_PLACEHOLDER_IMAGE_RELATIVE_PATH']
37 |
38 | sample_image_filepath = os.path.abspath(os.path.join(
39 | app.config['MEDIA_FOLDER'],
40 | sample_image))
41 |
42 | assert os.path.exists(sample_image_filepath)
43 | os.remove(sample_image_filepath)
44 |
--------------------------------------------------------------------------------
/tests/test_sample_text.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """Test the sample text generation."""
3 |
4 | from flask_editablesite.app import create_app
5 | from flask_editablesite.settings import TestConfig
6 |
7 |
8 | from flask_editablesite.editable.sample_text import (
9 | placeholder_or_random_sample_text,)
10 |
11 |
12 | def test_placeholder_when_no_scrape_configured(app):
13 | sample_text = placeholder_or_random_sample_text()
14 | assert sample_text == app.config['EDITABLE_PLACEHOLDER_TEXT']
15 |
16 |
17 | class TextScrapeTestConfig(TestConfig):
18 | EDITABLE_SAMPLE_TEXT_SCRAPE_URLS = [
19 | (
20 | 'https://raw.githubusercontent.com'
21 | '/Jaza/flask-editablesite'
22 | '/master/tests/sample-text-great-expectations.txt'), ]
23 |
24 |
25 | def test_markovify_when_scrape_configured():
26 | app = create_app(TextScrapeTestConfig)
27 |
28 | with app.app_context():
29 | sample_text = placeholder_or_random_sample_text()
30 |
31 | # Give markovify a few more tries, if it fails to generate
32 | # text the first time.
33 | i = 0
34 | while i < 3 and (not sample_text):
35 | sample_text = placeholder_or_random_sample_text()
36 | i += 1
37 |
38 | assert sample_text is not None
39 | assert len(sample_text)
40 | assert sample_text != app.config['EDITABLE_PLACEHOLDER_TEXT']
41 |
42 | assert (
43 | ('and' in sample_text)
44 | or ('the' in sample_text)
45 | or ('that' in sample_text)
46 | or ('you' in sample_text)
47 | or ('man' in sample_text)
48 | or ('was' in sample_text)
49 | or ('with' in sample_text)
50 | or ('said' in sample_text)
51 | or ('him' in sample_text)
52 | or ('were' in sample_text))
53 |
--------------------------------------------------------------------------------
/tests/test_user_forms.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 |
3 | from flask_editablesite.public.forms import LoginForm
4 |
5 |
6 | def test_login_success(user):
7 | user.set_password('example')
8 | user.save()
9 | form = LoginForm(email=user.email, password='example')
10 | assert form.validate() is True
11 | assert form.user == user
12 |
13 |
14 | def test_login_unknown_email(db):
15 | form = LoginForm(email='unknown', password='example')
16 | assert form.validate() is False
17 | assert 'Unknown email' in form.email.errors
18 | assert form.user is None
19 |
20 |
21 | def test_login_invalid_password(user):
22 | user.set_password('example')
23 | user.save()
24 | form = LoginForm(email=user.email, password='wrongpassword')
25 | assert form.validate() is False
26 | assert 'Invalid password' in form.password.errors
27 |
28 |
29 | def test_login_inactive_user(user):
30 | user.active = False
31 | user.confirmed_at = None
32 | user.set_password('example')
33 | user.save()
34 | # Correct email and password, but user is not activated
35 | form = LoginForm(email=user.email, password='example')
36 | assert form.validate() is False
37 | assert (
38 | 'User {0} not activated'.format(user.full_name_or_email)
39 | in form.email.errors)
40 |
--------------------------------------------------------------------------------
/tests/test_user_models.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """Model unit tests."""
3 |
4 | import datetime as dt
5 |
6 | from flask_editablesite.user.models import User
7 | from .factories import UserFactory
8 |
9 |
10 | def test_user_get_by_id():
11 | user = User('foo', 'foo@bar.com')
12 | user.save()
13 |
14 | retrieved = User.get_by_id(user.id)
15 | assert retrieved == user
16 |
17 | user.delete()
18 |
19 |
20 | def test_user_created_at_defaults_to_datetime():
21 | user = User(email='foo@bar.com')
22 | user.save()
23 | assert bool(user.created_at)
24 | assert isinstance(user.created_at, dt.datetime)
25 |
26 | user.delete()
27 |
28 |
29 | def test_user_password_is_nullable():
30 | user = User(email='foo@bar.com')
31 | user.save()
32 | assert user.password is None
33 |
34 | user.delete()
35 |
36 |
37 | def test_user_factory(db):
38 | user = UserFactory(password="myprecious")
39 | db.session.commit()
40 | assert bool(user.email)
41 | assert bool(user.created_at)
42 | assert user.active is True
43 | assert user.check_password('myprecious')
44 |
45 |
46 | def test_user_check_password():
47 | user = User.create(email="foo@bar.com",
48 | password="foobarbaz123")
49 | assert user.check_password('foobarbaz123') is True
50 | assert user.check_password("barfoobaz") is False
51 |
52 | user.delete()
53 |
54 |
55 | def test_user_full_name():
56 | user = UserFactory(first_name="Foo", last_name="Bar")
57 | assert user.full_name == "Foo Bar"
58 |
--------------------------------------------------------------------------------
/tests/test_user_views.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """Testing of user views."""
3 |
4 | from flask_webtest import TestApp
5 |
6 | from flask import url_for
7 |
8 | from flask_editablesite.user.models import User
9 |
10 |
11 | def test_login_returns_200(user, testapp):
12 | # Goes to homepage
13 | res = testapp.get("/")
14 | # Fills out login form
15 | form = res.forms['loginForm']
16 | form['email'] = user.email
17 | form['password'] = 'myprecious'
18 | # Submits
19 | res = form.submit().follow()
20 | assert res.status_code == 200
21 |
22 |
23 | def test_login_returns_200_sessionstore(app_sessionstore):
24 | app = app_sessionstore
25 | with app.test_request_context():
26 | testapp = TestApp(app_sessionstore)
27 |
28 | # Goes to homepage
29 | res = testapp.get("/")
30 | # Fills out login form
31 | form = res.forms['loginForm']
32 |
33 | user = User.sessionstore_user()
34 |
35 | form['email'] = user.email
36 | form['password'] = app.config['SESSIONSTORE_USER_PASSWORD']
37 | # Submits
38 | res = form.submit().follow()
39 | assert res.status_code == 200
40 |
41 |
42 | def test_logout_alert_visible(user, testapp):
43 | res = testapp.get("/")
44 | # Fills out login form
45 | form = res.forms['loginForm']
46 | form['email'] = user.email
47 | form['password'] = 'myprecious'
48 | # Submits
49 | res = form.submit().follow()
50 | res = testapp.get(url_for('public.logout')).follow()
51 | # sees alert
52 | assert 'You are logged out.' in res
53 |
54 |
55 | def test_login_errormsg_if_pw_wrong(user, testapp):
56 | # Goes to homepage
57 | res = testapp.get("/")
58 | # Fills out login form, password incorrect
59 | form = res.forms['loginForm']
60 | form['email'] = user.email
61 | form['password'] = 'wrong'
62 | # Submits
63 | res = form.submit()
64 | # Redirects home
65 | res = res.follow()
66 | # sees error
67 | assert "Invalid password" in res
68 |
69 |
70 | def test_login_errormsg_if_email_unknown(user, testapp):
71 | # Goes to homepage
72 | res = testapp.get("/")
73 | # Fills out login form, password incorrect
74 | form = res.forms['loginForm']
75 | form['email'] = 'email'
76 | form['password'] = 'myprecious'
77 | # Submits
78 | res = form.submit()
79 | # Redirects home
80 | res = res.follow()
81 | # sees error
82 | assert "Unknown email" in res
83 |
--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
1 | [tox]
2 | envlist = py26, py27, pypy, py33, py34
3 | skipsdist = True
4 |
5 | [testenv]
6 | deps = py26: importlib
7 | -r{toxinidir}/requirements/dev.txt
8 | commands = coverage erase
9 | coverage run manage.py test
10 | coverage report --include=*flask_editablesite*
11 | passenv = FLASK_EDITABLESITE_SECRET
12 | FLASK_EDITABLESITE_DATABASE_URI
13 |
--------------------------------------------------------------------------------