Giter Club home page Giter Club logo

scms-oca's Introduction

Template SCMS

Project that contains a generic template for content management SciELO context.

Black code style

License: GPLv3

Startup the development environment and operations

You can use docker commands for the following if you wish, just check our makefile

What about commands in the makefile?

Type inside de project make help:

    Usage: make [target] [argument] ...

    Argument:
        compose = {compose_file_name}

        targets:

        help                                           show this help
        app_version                                    Show version of webapp
        vcs_ref                                        Show last commit ref
        build_date                                     Show build date
        build                              Build app using $(COMPOSE_FILE_DEV)
        up                                 Start app using $(COMPOSE_FILE_DEV)
        logs                               See all app logs using $(COMPOSE_FILE_DEV)
        stop                               Stop all app using $(COMPOSE_FILE_DEV)
        ps                                 See all containers using $(COMPOSE_FILE_DEV)
        rm                                 Remove all containers using $(COMPOSE_FILE_DEV)
        django_shell                       Open python terminal from django $(COMPOSE_FILE_DEV)
        wagtail_sync                       Wagtail sync Page fields (repeat every time you add a new language and to update the wagtailcore_page translations) $(COMPOSE_FILE_DEV)
        wagtail_update_translation_field   Wagtail update translation fields, user this command first $(COMPOSE_FILE_DEV)
        django_createsuperuser             Create a super user from django $(COMPOSE_FILE_DEV)
        django_bash                        Open a bash terminar from django container using $(COMPOSE_FILE_DEV)
        django_test                        Run tests from django container using $(COMPOSE_FILE_DEV)
        django_fast                        Run tests fast from django container using $(COMPOSE_FILE_DEV)
        django_makemigrations              Run makemigrations from django container using $(COMPOSE_FILE_DEV)
        django_migrate                     Run migrate from django container using $(COMPOSE_FILE_DEV)
        django_makemessages                Run ./manage.py makemessages $(COMPOSE_FILE_DEV)
        django_compilemessages             Run ./manage.py compilemessages $(COMPOSE_FILE_DEV)
        django_dump_auth                   Run manage.py dumpdata auth --indent=2 $(COMPOSE_FILE_DEV)
        django_load_auth                   Run manage.py dumpdata auth --indent=2 $(COMPOSE_FILE_DEV)
        dump_data                          Dump database into .sql $(COMPOSE_FILE_DEV)
        restore_data                       Restore database into from latest.sql file $(COMPOSE_FILE_DEV)

To build the stack for development enviroment you can use the following command:

    make build compose=local.yml

is the same of type:

    make

To run the project type:

    make up

To stop the project type:

    make stop

If you want to build, run, wherever with other params on .yml or from production or duplicate a subfolder in .envs and a subfolder on compose and "listo" you can user the make command with argument compose.

Note that the stack is configured with 2 files docker-compose environment development=local.yml and production=production.yml.

Below are some actions you must follow for properly running applications.

Clean migrations

Stop the project
make stop
Find and delete migrations scripts
find . -path "*/migrations/*.py" -not -name "__init__.py" -not -path "./core/*" -delete
find . -path "*/migrations/*.pyc"  -delete
Drop database - remove in this case the postgres files
cd ..
rm -rf scms_data
cd -
Restart the project
make up
Run migrations
make django_makemigrations
make django_migrate

Instant backup

docker exec -t oca_local_postgres pg_dumpall -c -U GVRFlLmcCNfGLhsFvSnCioYOPJPYpyfj > oca.sql

Instant restore

cat oca.sql | docker exec -i oca_local_postgres psql -U GVRFlLmcCNfGLhsFvSnCioYOPJPYpyfj core

Settings

Moved to settings.

Basic Commands

Setting Up Your Users

  • To create a normal user account, just go to Sign Up and fill out the form. Once you submit it, you'll see a "Verify Your E-mail Address" page. Go to your console to see a simulated email verification message. Copy the link into your browser. Now the user's email should be verified and ready to go.

  • To create a superuser account, use this command:

    $ python manage.py createsuperuser
    

For convenience, you can keep your normal user logged in on Chrome and your superuser logged in on Firefox (or similar), so that you can see how the site behaves for both kinds of users.

Type checks

Running type checks with mypy:

$ mypy core

Test coverage

To run the tests, check your test coverage, and generate an HTML coverage report:

$ coverage run -m pytest
$ coverage html
$ open htmlcov/index.html

Running tests with pytest

$ pytest

Live reloading and Sass CSS compilation

Moved to Live reloading and SASS compilation.

Celery

This app comes with Celery.

To run a celery worker:

cd core
celery -A config.celery_app worker -l info

Please note: For Celery's import magic to work, it is important where the celery commands are run. If you are in the same folder with manage.py, you should be right.

Email Server

In development, it is often nice to be able to see emails that are being sent from your application. For that reason local SMTP server MailHog with a web interface is available as docker container.

Container mailhog will start automatically when you will run all docker containers. Please check cookiecutter-django Docker documentation for more details how to start all containers.

With MailHog running, to view messages that are sent by your application, open your browser and go to http://127.0.0.1:8025

Sentry

Sentry is an error logging aggregator service. You can sign up for a free account at https://sentry.io/signup/?code=cookiecutter or download and host it yourself. The system is set up with reasonable defaults, including 404 logging and integration with the WSGI application.

You must set the DSN url in production.

Deployment

The following details how to deploy this application.

Docker

See detailed cookiecutter-django Docker documentation.

scms-oca's People

Contributors

rossi-luciano avatar gitnnolabs avatar robertatakenaka avatar ednilson avatar

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.