4 |
11 | {% endfor %}
12 |
--------------------------------------------------------------------------------
/powerapp/core/templates/login.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 |
3 | {% block main %}
4 |
5 | {{ bound_field }}
6 | {{ bound_field.label_tag }}
7 | {% if bound_field.help_text %}{{ bound_field.help_text }}{% endif %}
8 | {% if bound_field.errors %}
10 | {{ bound_field.errors }}
{% endif %}
9 |
5 |
14 |
15 | {% endblock %}
16 |
--------------------------------------------------------------------------------
/powerapp/core/templatetags/materializecss.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | Template tags to render forms with Materialize CSS: http://materializecss.com/forms.html
4 | """
5 | from django import template
6 |
7 | register = template.Library()
8 |
9 |
10 | @register.inclusion_tag('materialize/form.html')
11 | def materialize_form(form):
12 | """
13 | Take the form object and return its "materialized representation"
14 | """
15 | return {'form': form}
16 |
--------------------------------------------------------------------------------
/powerapp/wsgi.py:
--------------------------------------------------------------------------------
1 | """
2 | WSGI config for powerapp project.
3 |
4 | It exposes the WSGI callable as a module-level variable named ``application``.
5 |
6 | For more information on this file, see
7 | https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/
8 | """
9 |
10 | import os
11 |
12 | from django.core.wsgi import get_wsgi_application
13 |
14 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "powerapp.settings")
15 |
16 | application = get_wsgi_application()
17 |
--------------------------------------------------------------------------------
/powerapp/contrib/catcomments/apps.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | An extremely useful service to boost your morale. It adds notes with kittens
4 | to every task you create. Works only for premium accounts.
5 | """
6 | from powerapp.core.apps import ServiceAppConfig
7 |
8 |
9 | class AppConfig(ServiceAppConfig):
10 | name = 'powerapp.contrib.catcomments'
11 | verbose_name = 'Cat comments'
12 | url = 'http://thecatapi.com/'
13 | description = __doc__
14 | models_module = None
15 |
--------------------------------------------------------------------------------
/powerapp/contrib/github/models.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.db import models
3 |
4 |
5 | class GithubDataMap(models.Model):
6 | id = models.AutoField(verbose_name='ID', auto_created=True, serialize=False, primary_key=True)
7 | integration = models.ForeignKey(to='core.Integration')
8 | github_data_id = models.IntegerField(db_index=True, auto_created=False)
9 | github_data_type = models.TextField(auto_created=False)
10 | github_data_url = models.TextField(auto_created=False)
11 | todoist_task_id = models.IntegerField(db_index=True, auto_created=False)
12 |
--------------------------------------------------------------------------------
/powerapp/contrib/gcal_sync/apps.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | Synchronizes your Todoist tasks with your Google Calendar
4 | """
5 | import environ
6 | from powerapp.core.apps import ServiceAppConfig
7 |
8 |
9 | env = environ.Env()
10 |
11 |
12 | class AppConfig(ServiceAppConfig):
13 | name = 'powerapp.contrib.gcal_sync'
14 | verbose_name = 'Google Calendar Sync'
15 | url = 'https://calendar.google.com'
16 | description = __doc__
17 |
18 | GOOGLE_CLIENT_ID = env('GOOGLE_CLIENT_ID', default=None)
19 | GOOGLE_CLIENT_SECRET = env('GOOGLE_CLIENT_SECRET', default=None)
20 |
--------------------------------------------------------------------------------
/powerapp/contrib/evernote_sync/migrations/0002_evernoteaccountcache_evernote_user_id.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from __future__ import unicode_literals
3 |
4 | from django.db import models, migrations
5 |
6 |
7 | class Migration(migrations.Migration):
8 |
9 | dependencies = [
10 | ('evernote_sync', '0001_initial'),
11 | ]
12 |
13 | operations = [
14 | migrations.AddField(
15 | model_name='evernoteaccountcache',
16 | name='evernote_user_id',
17 | field=models.PositiveIntegerField(null=True, db_index=True),
18 | ),
19 | ]
20 |
--------------------------------------------------------------------------------
/powerapp/contrib/github/apps.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | Synchronizes your Github issues and pull requests with Todoist
4 | """
5 | import environ
6 | from powerapp.core.apps import ServiceAppConfig
7 |
8 | env = environ.Env()
9 |
10 | class AppConfig(ServiceAppConfig):
11 | name = 'powerapp.contrib.github'
12 | verbose_name = 'Github Integration'
13 | url = 'http://todoist.com'
14 | description = __doc__
15 | models_module = None
16 |
17 | GITHUB_CLIENT_ID = env('GITHUB_CLIENT_ID', default=None)
18 | GITHUB_CLIENT_SECRET = env('GITHUB_CLIENT_SECRET', default=None)
19 |
--------------------------------------------------------------------------------
/powerapp/contrib/github/urls.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.conf.urls import url
3 | from . import views
4 |
5 |
6 | urlpatterns = [
7 | url(r'^integrations/add/$', views.EditIntegrationView.as_view(), name='add_integration'),
8 | url(r'^integrations/(?P
6 |
20 | {% endfor %}
21 |
22 | {% endblock %}
23 |
--------------------------------------------------------------------------------
/powerapp/core/exceptions.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import logging
3 |
4 |
5 | logger = logging.getLogger(__name__)
6 |
7 |
8 | def return_or_raise(result):
9 | """
10 | Take the result of sync operation and pass it through if everything is
11 | okay, or raise PowerAppError, if there is an error
12 | """
13 | if result is None:
14 | return result
15 |
16 | if not isinstance(result, dict):
17 | raise PowerAppError(result)
18 |
19 | if 'error' in result:
20 | err = result['error']
21 | logger.error(err)
22 | raise PowerAppError(err)
23 | return result
24 |
25 |
26 | class PowerAppError(Exception):
27 | """
28 | Base class for all "managed exceptions" we raise
29 | """
30 | pass
31 |
32 |
33 | class PowerAppInvalidTokenError(PowerAppError):
34 | """
35 | The exception is raised when we found that the OAuth token is invalid or
36 | non-existent
37 | """
38 | pass
39 |
--------------------------------------------------------------------------------
/powerapp/core/migrations/0002_service_enabled_flag.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from __future__ import unicode_literals
3 |
4 | from django.db import models, migrations
5 |
6 |
7 | class Migration(migrations.Migration):
8 |
9 | dependencies = [
10 | ('core', '0001_initial'),
11 | ]
12 |
13 | operations = [
14 | migrations.AddField(
15 | model_name='integration',
16 | name='service_enabled',
17 | field=models.BooleanField(editable=False, default=True),
18 | ),
19 | migrations.AddField(
20 | model_name='service',
21 | name='enabled',
22 | field=models.BooleanField(verbose_name='Service enabled', default=True),
23 | ),
24 | migrations.AlterIndexTogether(
25 | name='integration',
26 | index_together=set([('service_enabled', 'user', 'service'), ('service_enabled', 'stateless', 'api_next_sync')]),
27 | ),
28 | ]
29 |
--------------------------------------------------------------------------------
/powerapp/contrib/evernote_sync/urls.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.conf.urls import url
3 | from .views import EditIntegrationView, authorize_evernote, authorize_evernote_done, sync_now, accept_webhook
4 |
5 | # URL patterns have to contain at least two records: one to add integration,
6 | # and another one to edit it, as provided below. You are welcome to add more
7 | # endpoints if you need it.
8 |
9 | urlpatterns = [
10 | url(r'^integrations/add/$', EditIntegrationView.as_view(), name='add_integration'),
11 | url(r'^integrations/(?P
7 | 
9 |
10 |
11 |
12 |
16 | 17 | Add 18 |
19 | {{ service.app_config.verbose_name }}
13 | 14 |{{ service.app_config.description }}
15 |16 | 17 | Add 18 |
Github Integration Setup
10 |11 | To complete the Github integration setup, you need to configure 12 | your github repository webhook setting. 13 |
14 | 15 |-
16 |
- 17 | In your Github repository setting, go to the "Webhooks & Services" section, and create a new webhook. 18 | 19 |
-
20 | Fill in the "Payload URL" field with the following URL:
21 |
22 | {{ extra_context.webhook_url }} 23 |
24 | - 25 | Fill in the "Secret" field with the same secret string configured below. 26 | 27 |
- 28 | For the webhook event setting, select "Issues" and "Pull Request" options (or choose one that you which 29 | would like to synchronize) and saving the setting to complete the setup. 30 | 31 |
16 |
17 |
29 | {% endblock %}
30 |
--------------------------------------------------------------------------------
/powerapp/core/attrdict.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from pprint import pformat
3 |
4 |
5 | class AttrDict(dict):
6 | """
7 | Dict allowing to get access to its keys as attributes
8 | """
9 |
10 | def __getattr__(self, name):
11 | if name in self:
12 | return self[name]
13 | raise AttributeError('%s not found' % name)
14 |
15 | def __setattr__(self, name, value):
16 | self[name] = value
17 |
18 | def __repr__(self):
19 | formatted_dict = pformat(dict(self))
20 | classname = self.__class__.__name__
21 | return '%s(%s)' % (classname, formatted_dict)
22 |
23 | @property
24 | def __members__(self):
25 | return self.keys()
26 |
27 |
28 | def recursive_attrdict(obj):
29 | """
30 | Recursively find all dicts in a stricture, and convert them to attr dict
31 | """
32 | if isinstance(obj, (dict, AttrDict)):
33 | return AttrDict({k: recursive_attrdict(v) for k, v in obj.items()})
34 |
35 | if isinstance(obj, (list, tuple, set)):
36 | return obj.__class__([recursive_attrdict(item) for item in obj])
37 |
38 | return obj
39 |
--------------------------------------------------------------------------------
/powerapp/core/signals.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.db.models.signals import post_save, post_delete
3 | from django.dispatch import receiver
4 |
5 | from django_statsd.clients import statsd
6 |
7 | from .models import Integration, Service
8 | from . import periodic_tasks
9 |
10 |
11 | @receiver(post_save, sender=Integration)
12 | def on_integration_create(sender, instance=None, created=None, **kwargs):
13 | if created:
14 | # create periodic tasks
15 | periodic_tasks.add(instance)
16 |
17 |
18 | @receiver(post_save, sender=Service)
19 | def change_enabled_status_on_service_update(sender, instance=None, created=None, **kwargs):
20 | Integration.objects.filter(service=instance).update(service_enabled=instance.enabled)
21 |
22 |
23 | @receiver(post_save, sender=Integration)
24 | def integration_cnt_incr(sender, instance=None, created=None, **kwargs):
25 | if created:
26 | statsd.incr('integration_cnt')
27 | statsd.incr('integration_cnt.%s' % instance.service_id)
28 |
29 |
30 | @receiver(post_delete, sender=Integration)
31 | def integration_cnt_decr(sender, instance=None, **kwargs):
32 | statsd.decr('integration_cnt')
33 | statsd.decr('integration_cnt.%s' % instance.service_id)
34 |
--------------------------------------------------------------------------------
/powerapp/core/templates/base.html:
--------------------------------------------------------------------------------
1 | {% load staticfiles core %}
2 |
3 |
4 |
5 |
18 |
22 |
23 |
24 |
25 | {% block content %}{% endblock %}
26 |
27 |
28 |
19 |
29 |
30 | {% block main %}
31 | {% endblock %}
32 | {% block extra_js %}
33 | {% endblock %}
34 |
35 |
36 |
37 |
--------------------------------------------------------------------------------
/powerapp/core/statsd_middleware.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import inspect
3 | import time
4 | from django_statsd.clients import statsd
5 |
6 |
7 | class GrafanaRequestTimingMiddleware(object):
8 | """statsd's timing data per view stored as gauges"""
9 |
10 | def process_view(self, request, view_func, view_args, view_kwargs):
11 | view = view_func
12 | if not inspect.isfunction(view_func):
13 | view = view.__class__
14 | try:
15 | request._view_module = view.__module__
16 | request._view_name = view.__name__
17 | request._start_time = time.time()
18 | except AttributeError:
19 | pass
20 |
21 | def process_response(self, request, response):
22 | self._record_time(request)
23 | return response
24 |
25 | def process_exception(self, request, exception):
26 | self._record_time(request)
27 |
28 | def _record_time(self, request):
29 | if hasattr(request, '_start_time'):
30 | ms = int((time.time() - request._start_time) * 1000)
31 | data = dict(module=request._view_module, name=request._view_name,
32 | method=request.method)
33 | statsd.gauge('view.response_ms.{module}.{name}.{method}'.format(**data), ms)
34 |
--------------------------------------------------------------------------------
/powerapp/core/templates/dashboard.html:
--------------------------------------------------------------------------------
1 | {% extends "loggedin.html" %}
2 | {% load staticfiles %}
3 |
4 | {% block content %}
5 |
20 |
21 | 
22 | PowerApp
23 |
24 |
25 | {% block usermenu %}
26 | {% endblock %}
27 |
28 |
22 | PowerApp
23 |
24 |
25 | {% block usermenu %}
26 | {% endblock %}
27 |
6 |
12 |
13 | {% for integration in integrations %}
14 |
18 |
19 |
29 | {% endfor %}
30 |
31 | {% endblock %}
32 |
--------------------------------------------------------------------------------
/powerapp/contrib/evernote_sync/templates/evernote_sync/edit_integration.html:
--------------------------------------------------------------------------------
1 | {% extends "edit_integration_base.html" %}
2 |
3 | {% block extra_actions %}
4 | {% if form.integration %}
5 |
6 | sync now
7 | {% endif %}
8 | {% endblock %}
9 |
10 | {% block extra_js %}
11 |
19 | {% endblock %}
20 |
21 | {% block form %}
22 | {% csrf_token %}
23 |
24 | Your Services
7 |
8 |
9 | Add Service
10 |
11 |
25 |
32 |
33 |
26 | {{ form.name }}
27 | {{ form.name.label_tag }}
28 | {% if form.name.errors %}
31 | {{ form.name.errors }}
{% endif %}
29 |
30 |
34 |
40 |
41 | {% endblock %}
42 |
--------------------------------------------------------------------------------
/powerapp/core/templates/utils.mako:
--------------------------------------------------------------------------------
1 | <%def name="form(form_obj, button_text, button_icon)">
2 |
23 |
24 |
25 | <%def name="submit_button(text, type='success', icon=None)">
26 |
32 |
33 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | import sys
3 | from setuptools import setup, find_packages
4 |
5 | PY3 = sys.version_info.major == 3
6 |
7 |
8 | def read(filename):
9 | try:
10 | return open(filename).read()
11 | except IOError:
12 | pass
13 |
14 |
15 | install_requires = [
16 | 'todoist-python',
17 | 'celery[redis]',
18 | 'Django>=1.8.2',
19 | 'django-celery',
20 | 'django-environ',
21 | 'django-picklefield',
22 | 'django-statsd-mozilla',
23 | 'django-redis-cache',
24 | 'graypy',
25 | 'colorlog',
26 | 'requests',
27 | 'feedparser',
28 | 'pytz',
29 | 'raven',
30 | 'requests-oauthlib',
31 | 'pyRFC3339',
32 | ]
33 |
34 |
35 | # We cannot install evernote on Python3, because the version supporting it
36 | # is not on PyPI yet. Use the requirement from requirements.txt to set it up
37 | if not PY3:
38 | install_requires.append('evernote')
39 |
40 |
41 | setup(name='powerapp',
42 | version='0.2',
43 | url='https://github.com/Doist/powerapp',
44 | license='BSD',
45 | zip_safe=False,
46 | description='The app to integrate Todoist with third-party service',
47 | long_description=read('README.rst'),
48 | packages=find_packages(),
49 | install_requires=install_requires,
50 | entry_points={},
51 | classifiers=[
52 | 'Development Status :: 3 - Alpha',
53 | 'License :: OSI Approved :: BSD License',
54 | 'Programming Language :: Python',
55 | 'Programming Language :: Python :: 3',
56 | ])
57 |
--------------------------------------------------------------------------------
/tests/integration/README.rst:
--------------------------------------------------------------------------------
1 | Integration tests require a bit of preliminary actions to work.
2 |
3 | Set up webhooks
4 | ---------------
5 |
6 | First, we have to make tests accept webhooks from the "real world Todoist".
7 | For that purpose the test suite runs a django live server listening for
8 | a local host and port, and additionally, we start a ngrok server to create a
9 | tunnel so that your local address could be available from the Internet.
10 |
11 | Visit the `Todoist app_console
35 |
36 | {{ form.evernote_notebooks }}
37 | {% if form.evernote_notebooks.errors %}
39 | {{ form.evernote_notebooks.errors }}
{% endif %}
38 |
6 |
49 |
50 | {% endblock %}
51 |
--------------------------------------------------------------------------------
/powerapp/contrib/gcal_sync/tasks.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from . import utils
3 | from celery.exceptions import SoftTimeLimitExceeded
4 | from requests import HTTPError
5 | from powerapp.celery_local import app
6 | from powerapp.contrib.gcal_sync.utils import get_authorized_client, json_post
7 | from powerapp.core.models.integration import Integration
8 | from powerapp.core.models.user import User
9 | from powerapp.core.logging_utils import ctx
10 | from logging import getLogger
11 |
12 |
13 | logger = getLogger(__name__)
14 |
15 |
16 | @app.task(ignore_result=True)
17 | def create_calendar(integration_id):
18 | try:
19 | integration = Integration.objects.get(id=integration_id)
20 | except Integration.DoesNotExist:
21 | return
22 | with ctx(user=integration.user, integration=integration):
23 | calendar = utils.get_or_create_todoist_calendar(integration)
24 | utils.subscribe_to_todoist_calendar(integration, calendar)
25 |
26 |
27 | @app.task(ignore_result=True)
28 | def sync_gcal(integration_id):
29 | try:
30 | integration = Integration.objects.select_related('user').get(id=integration_id)
31 | except Integration.DoesNotExist:
32 | return
33 | with ctx(user=integration.user, integration=integration):
34 | try:
35 | utils.sync_gcal(integration)
36 | except SoftTimeLimitExceeded:
37 | logger.error('Synchronization with GCal took too long and was aborted')
38 |
39 |
40 | @app.task(ignore_result=True)
41 | def stop_channel(user_id, channel_id, resource_id):
42 | """
43 | Stop channel if integration does not exist
44 | """
45 | try:
46 | user = User.objects.get(id=user_id)
47 | except User.DoesNotExist:
48 | return
49 |
50 | with ctx(user=user):
51 | client = get_authorized_client(user)
52 | try:
53 | json_post(client, '/channels/stop', id=channel_id, resouceId=resource_id)
54 | except HTTPError:
55 | # FIXME: it doesn't work :/
56 | pass
57 |
--------------------------------------------------------------------------------
/powerapp/devops_utils.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | Utility functions to simplify the deployment process
4 | """
5 | import os
6 | import re
7 | from logging import getLogger
8 | import subprocess
9 |
10 |
11 | def extend_requirements_txt():
12 | """
13 | Extend requirements.txt with extra requirements from POWERAPP_SERVICES
14 | """
15 | requirements = [r.strip() for r in open('requirements.txt').readlines()]
16 | for req in get_extra_requirements():
17 | req_str = ' '.join(req)
18 | if req_str not in requirements:
19 | requirements.append(req_str)
20 | with open('requirements.txt', 'w') as fd:
21 | fd.write('\n'.join(requirements) + '\n')
22 |
23 |
24 | def install_requirements():
25 | """
26 | Install extra requirements from POWERAPP_SERVICES
27 | """
28 | for req in get_extra_requirements():
29 | subprocess.call(['pip', 'install'] + req)
30 |
31 |
32 | def get_extra_requirements():
33 | """
34 | Read POWERAPP_SERVICES environment variable, and return the list
35 | of extra packages to install.
36 |
37 | Every package in the list is a list of one (["powerapp-foo"]) or two
38 | (["-e", "git+git@github.com:Doist/powerapp-foo.git"]) elements
39 | """
40 | services = os.environ.get('POWERAPP_SERVICES')
41 | for service in re.split(r'[\s,;]+', services or ''):
42 | if not service:
43 | continue
44 | if service.startswith('http') and '/' in service:
45 | # it's a git URL, extend it with extra fields
46 | app_name = re.search(r'([^/]+)(.git)?$', service).group(1)
47 | url = 'git+%s#egg=%s' % (service, app_name)
48 | yield ['-e', url]
49 | else:
50 | # return as is
51 | yield [service]
52 |
53 |
54 | def run_bootstrap_management_commands():
55 | """
56 | Run "bootstap management commands"
57 | """
58 | # it's inside function to make sure we can use the rest of devops_utils
59 | # without setting up all the Django machinery
60 | from django.core.management import call_command
61 | call_command('migrate')
62 | call_command('collectstatic', interactive=False)
63 | call_command('collect_services')
64 |
--------------------------------------------------------------------------------
/powerapp/core/django_widgets.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from itertools import chain
3 | from django.forms.widgets import Select, Widget
4 | from django.utils.encoding import force_text
5 | from django.utils.html import format_html
6 | from django.utils.safestring import mark_safe
7 |
8 |
9 | class ProjectsSelect(Select):
10 |
11 | def render_options(self, choices, selected_choices):
12 | selected_choices = set(force_text(v) for v in selected_choices)
13 | output = []
14 |
15 | filter_func = lambda p: isinstance(p['id'], int)
16 | sort_key = lambda p: (p['item_order'], p['id'])
17 |
18 | projects = chain(self.choices, choices)
19 | projects = filter(filter_func, projects)
20 | projects = sorted(projects, key=sort_key)
21 |
22 | for project in projects:
23 | option_value = force_text(project['id'])
24 | indent = max(project['indent'] - 1, 0)
25 | option_label = '..' * indent + ' ' + project['name']
26 | output.append(self.render_option(selected_choices, option_value, option_label))
27 | return '\n'.join(output)
28 |
29 |
30 | class SwitchWidget(Widget):
31 |
32 | choices = []
33 |
34 | def value_from_datadict(self, data, files, name):
35 | return data.getlist(name, None)
36 |
37 | def render(self, name, value, attrs=None):
38 | checked_options = set(value or [])
39 | ret = []
40 | for value, label in self.choices:
41 | ret.append(self.render_checkbox(name, value, label,
42 | value in checked_options))
43 | return mark_safe('\n'.join(ret))
44 |
45 | @staticmethod
46 | def render_checkbox(name, value, label, checked):
47 | checked_str = mark_safe(' checked') if checked else ''
48 | return format_html(u''
49 | u'
7 | 
9 |
10 | {% block extra_actions %} 11 | {% endblock %} 12 |
13 |
14 | 10 | {% block extra_actions %} 11 | {% endblock %} 12 |
15 |
48 | {{ form.service.app_config.verbose_name }}
16 |{{ form.service.app_config.url }}
17 |{{ form.service.app_config.description }}
18 | 19 | {% block form_wrapper %} 20 | {# edit integration form #} 21 | 22 | {% block before_form %}{% endblock %} 23 | 24 | 27 | 28 | {# delete integration form #} 29 | {% if form.integration %} 30 | 34 | {% endif %} 35 | 36 | {# submit buttons #} 37 | 40 | {% if form.integration %} 41 | 44 | {% endif %} 45 | 46 | {% endblock %} 47 |'
50 | u' '
55 | u'
', name, value, checked_str, label)
56 |
--------------------------------------------------------------------------------
/powerapp/core/cron.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | A module containing Celery tasks for all periodic tasks we perform.
4 |
5 | Basically, we run two types of tasks.
6 |
7 | - For every "stateful integraion" we perform a periodic sync and generate a
8 | bunch of signals (item_added, item_deleted, etc...)
9 | - If the service defines some cron job (like, polling external service), we
10 | perform these periodic tasks as well (PeriodicTask instances)
11 | """
12 | from logging import getLogger
13 | from powerapp.celery_local import app
14 | from powerapp.core.models import Integration, PeriodicTask
15 | from django.utils.timezone import now
16 |
17 |
18 | logger = getLogger(__name__)
19 |
20 |
21 | @app.task(ignore_result=True)
22 | def schedule_sync_tasks():
23 | """
24 | A celery beat task which by itself does nothing but schedule a buch of
25 | sync tasks for execution
26 |
27 | For every integration object we acquire a lock, and pass this lock object
28 | to the worker. If lock is unable to acquire then probably another task is
29 | performing the sync operation right now. Don't do anything at all.
30 | """
31 | for integration in Integration.objects.filter(stateless=False,
32 | api_next_sync__lte=now()):
33 | integration.api_last_sync = now()
34 | integration.save(update_fields=['api_last_sync'])
35 | run_sync_task.delay(integration.id)
36 |
37 |
38 | @app.task(ignore_result=True)
39 | def run_sync_task(integration_id):
40 | """
41 | Perform sync operation for "stateful integrations"
42 | """
43 | try:
44 | integration = Integration.objects.get(id=integration_id)
45 | except Integration.DoesNotExist:
46 | return
47 | integration.api.sync(resource_types=['projects', 'items', 'notes'])
48 |
49 |
50 | @app.task(ignore_result=True)
51 | def schedule_cron_tasks():
52 | """
53 | A celery beat task schedules cron tasks for execution
54 | """
55 | for ptask in PeriodicTask.objects.filter(next_run__lt=now()):
56 | ptask.schedule_forward()
57 | run_cron_task.delay(ptask.id)
58 |
59 |
60 | @app.task(ignore_result=True)
61 | def run_cron_task(periodic_task_id):
62 | """
63 | Run one periodic cron job for one integration
64 | """
65 | try:
66 | task = PeriodicTask.objects.get(id=periodic_task_id)
67 | except PeriodicTask.DoesNotExist:
68 | return
69 | task.run()
70 |
--------------------------------------------------------------------------------
/powerapp/core/views/web.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.contrib import auth, messages
3 | from django.contrib.auth.decorators import login_required
4 | from django.shortcuts import redirect, render, get_object_or_404
5 | from django.core.urlresolvers import reverse
6 | from django.views.decorators.http import require_POST
7 | from powerapp.core.exceptions import PowerAppError
8 |
9 | from powerapp.core.models import Service, Integration
10 | from powerapp.core import oauth
11 |
12 |
13 | @login_required
14 | def dashboard(request):
15 | integrations = Integration.objects.filter(user=request.user,
16 | service_enabled=True)
17 | if not integrations:
18 | return redirect('web_services')
19 | return render(request, 'dashboard.html', {
20 | 'active': 'dashboard',
21 | 'integrations': integrations
22 | })
23 |
24 |
25 | @login_required
26 | def services(request):
27 | return render(request, 'services.html', {
28 | 'active': 'services',
29 | 'services': Service.objects.filter(enabled=True)
30 | })
31 |
32 |
33 | def login(request):
34 | if request.user.is_authenticated():
35 | return redirect('web_index')
36 |
37 | client = oauth.get_client_by_name('todoist')
38 | authorize_url = client.get_authorize_url()
39 | client.set_state(request)
40 | return render(request, 'login.html', {'authorize_url': authorize_url})
41 |
42 |
43 | def logout(request):
44 | auth.logout(request)
45 | return redirect('web_index')
46 |
47 |
48 | def oauth2cb(request):
49 | try:
50 | client = oauth.get_client_by_state(request)
51 | code = request.GET['code']
52 | token = client.exchange_code_for_token(code)
53 | except PowerAppError as e:
54 | return render(request, 'oauth2cb.html', {'error': str(e)})
55 |
56 | client.callback_fn(client=client,
57 | token=token,
58 | request=request)
59 |
60 | return redirect(client.oauth2cb_redirect_uri)
61 |
62 |
63 | @require_POST
64 | @login_required
65 | def delete_integration(request, service_id, integration_id):
66 | user = request.user
67 | integration = get_object_or_404(Integration, id=integration_id, user=user)
68 | integration.delete()
69 | messages.info(request, "Integration '%s' deleted" % integration.name)
70 | return redirect(reverse('web_index'))
71 |
72 |
73 | @login_required
74 | def edit_integration(request, service_id, integration_id):
75 | return redirect('%s:edit_integration' % service_id, integration_id)
76 |
--------------------------------------------------------------------------------
/gulpfile.js:
--------------------------------------------------------------------------------
1 | var path = require('path');
2 | var gulp = require('gulp');
3 | var changed = require('gulp-changed');
4 | var gulpif = require('gulp-if');
5 | var concat = require('gulp-concat');
6 | var uglify = require('gulp-uglify');
7 | var uglifycss = require('gulp-uglifycss');
8 | var beautify = require('gulp-beautify');
9 | var autoprefixer = require('gulp-autoprefixer');
10 | var sourcemaps = require('gulp-sourcemaps');
11 | var less = require('gulp-less');
12 | var rename = require('gulp-rename');
13 |
14 |
15 | var config = {
16 | release: process.env.RELEASE !== undefined,
17 | materialize_path: 'node_modules/materialize-css/bin',
18 | less_path: 'powerapp/project_static/less',
19 |
20 | js_files: [
21 | "node_modules/jquery/dist/jquery.js",
22 | "node_modules/materialize-css/bin/materialize.js",
23 | "powerapp/project_static/js_src/*.js"
24 | ],
25 | less_files: [
26 | "powerapp/project_static/less/*.less"
27 | ],
28 | font_files: [
29 | "node_modules/materialize-css/font/**/*"
30 | ]
31 | };
32 |
33 |
34 | // Take css file from materialize, rename it to less and add to "our library"
35 | gulp.task('lessify-materialize', function() {
36 | var target = path.join(config.less_path, "lib");
37 | return gulp.src(path.join(config.materialize_path, "*.css"))
38 | .pipe(changed(target, {extension: ".less"}))
39 | .pipe(rename({extname: ".less"}))
40 | .pipe(gulp.dest(target))
41 | });
42 |
43 |
44 | // Compile all less files to one big CSS
45 | gulp.task('styles', ['lessify-materialize'], function() {
46 | gulp.src(path.join(config.less_path, "*.less"))
47 | .pipe(less({paths: [config.less_path]}))
48 | .pipe(gulpif(config.release, uglifycss()))
49 | .pipe(autoprefixer())
50 | .pipe(concat("style.css"))
51 | .pipe(gulp.dest("powerapp/project_static/css"));
52 | });
53 |
54 |
55 | gulp.task('scripts', function() {
56 | gulp.src(config.js_files)
57 | .pipe(gulpif(config.release, sourcemaps.init()))
58 | .pipe(gulpif(config.release, uglify(), beautify()))
59 | .pipe(concat("script.js"))
60 | .pipe(gulpif(config.release, sourcemaps.write()))
61 | .pipe(gulp.dest("powerapp/project_static/js"));
62 | });
63 |
64 |
65 | gulp.task('fonts', function() {
66 | gulp.src(config.font_files)
67 | .pipe(gulp.dest("powerapp/project_static/font"));
68 | });
69 |
70 | gulp.task('default', ['scripts', 'styles', 'fonts']);
71 |
72 | gulp.task('watch', ['default'], function() {
73 | gulp.watch([
74 | config.js_files, config.less_files, config.font_files
75 | ], ['default']);
76 | });
77 |
--------------------------------------------------------------------------------
/powerapp/contrib/evernote_sync/models.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import datetime
3 | from django.conf import settings
4 | from django.db import models
5 | from django.utils.timezone import make_aware, now
6 | from picklefield.fields import PickledObjectField
7 |
8 |
9 | class EvernoteAccountCache(models.Model):
10 | """
11 | Account cache, common for all integrations of the same user
12 |
13 | Contains the information about the user itself (to build correct links)
14 | and about their notebooks
15 | """
16 | UPDATE_THRESHOLD = datetime.timedelta(seconds=30) if settings.DEBUG else datetime.timedelta(minutes=15)
17 | MILLENIUM = make_aware(datetime.datetime(2000, 1, 1))
18 |
19 | user = models.OneToOneField('core.User')
20 | last_update_count = models.IntegerField(default=0)
21 | last_update_time = models.DateTimeField(default=MILLENIUM)
22 | user_data = PickledObjectField(null=True)
23 | notebooks = PickledObjectField(null=True)
24 | evernote_user_id = models.PositiveIntegerField(null=True, db_index=True)
25 |
26 | def refresh(self):
27 | """
28 | Refresh the evernote cache if required
29 | """
30 | from .utils import get_evernote_client
31 | if self.last_update_time > now() - self.UPDATE_THRESHOLD:
32 | # no need to update yet
33 | return
34 |
35 | client = get_evernote_client(self.user)
36 |
37 | # update user_data
38 | self.user_data = client.get_user_store().getUser()
39 | self.evernote_user_id = self.user_data.id
40 |
41 | # let's see if there are some updates in the note store
42 | note_store = client.get_note_store()
43 | update_count = note_store.getSyncState().updateCount
44 | if update_count <= self.last_update_count:
45 | # no updates yet
46 | self.last_update_time = now()
47 | self.save()
48 | return
49 |
50 | # it's time for update
51 | self.notebooks = note_store.listNotebooks()
52 | self.last_update_time = now()
53 | self.last_update_count = update_count
54 | self.save()
55 |
56 |
57 |
58 | class EvernoteSyncState(models.Model):
59 | """
60 | Evernote sync state
61 | """
62 | integration = models.OneToOneField('core.Integration')
63 | last_update_count = models.IntegerField(default=0)
64 | last_sync_time = models.BigIntegerField(default=0)
65 |
66 | def get_last_sync(self):
67 | return datetime.datetime.fromtimestamp(self.last_sync_time / 1000)
68 |
69 | def __str__(self):
70 | return '%s (%s)' % (self.last_update_count,
71 | self.get_last_sync().strftime('%Y-%m-%d %T'))
72 |
--------------------------------------------------------------------------------
/powerapp/core/integration_utils.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import time
3 | from django.db import transaction
4 | from powerapp.core.models import Integration
5 |
6 |
7 | @transaction.atomic
8 | def schedule_with_rate_limit(integration_id, last_op_settings_key,
9 | task, timeout=60):
10 | """
11 | Schedule an idempotent task (such as "sync with the upstream") to Celery,
12 | and make sure the task isn't executed more often than once in "timeout"
13 | seconds.
14 |
15 | The logic is following:
16 |
17 | - If for the last time we executed the task more than `timeout`
18 | seconds ago, we schedule it to start right now and keep current time
19 | in the `last_op_settings_key`
20 |
21 | - If we executed the task quite recently (less than `timeout` ago), but
22 | still in the past, we schedule the next task to be started in a minute
23 | after the last launch.
24 |
25 | - If the task is scheduled for the future (the value in
26 | `last_op_settings_key` more than current time), skip scheduling a new task
27 |
28 | Misc considerations:
29 |
30 | - `task` has to be a "half-baked Celery task object" (so called
31 | "signature"), made with Celery API like ``task_func.s(params)`` or
32 | a task object
33 |
34 | - Return the time (always in future) on which the task is scheduled, or
35 | None, if integration is not found
36 |
37 | - The task doesn't have to be executed more that `timeout` seconds. We
38 | enforce this by setting up the time_limit and soft_time_limit (timeout - 10s).
39 | If worker wants to react on soft time limit, it has to catch the
40 | SoftTimeLimitExceeded exception
41 | """
42 | try:
43 | integration = Integration.objects.get(id=integration_id)
44 | except Integration.DoesNotExist:
45 | return
46 |
47 | last_op = integration.settings.get(last_op_settings_key)
48 | now = int(time.time())
49 |
50 | apply_async_kwargs = {'time_limit': timeout,
51 | 'soft_time_limit': timeout if timeout < 20 else timeout - 10}
52 |
53 | if not last_op or last_op < now - timeout:
54 | integration.update_settings(**{last_op_settings_key: now})
55 | task.apply_async(**apply_async_kwargs)
56 | return now
57 |
58 | if last_op < now:
59 | next_schedule = last_op + timeout
60 | countdown = next_schedule - now
61 | integration.update_settings(**{last_op_settings_key: next_schedule})
62 | task.apply_async(countdown=countdown, **apply_async_kwargs)
63 | return next_schedule
64 |
65 | # otherwise last op is in future, just return the value
66 | return last_op
67 |
--------------------------------------------------------------------------------
/powerapp/core/periodic_tasks.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.utils.timezone import now
3 | from powerapp.core.models import Service, Integration, PeriodicTask
4 | from logging import getLogger
5 |
6 |
7 | logger = getLogger(__name__)
8 |
9 |
10 | def add(integration):
11 | """
12 | Add all periodic tasks for the given integration
13 | """
14 | to_add = []
15 | for task_name in integration.service.app_config.periodic_tasks.keys():
16 | to_add.append(PeriodicTask(integration=integration,
17 | name=task_name, next_run=now()))
18 | logger.info('Task %s:%s scheduled for adding',
19 | integration.service_id, task_name)
20 | if to_add:
21 | PeriodicTask.objects.bulk_create(to_add)
22 |
23 |
24 | def sync():
25 | """
26 | Make sure every integration has a periodic task. We add new periodic tasks
27 | if we find something new, we delete outdated periodic tasks, if integration
28 | doesn't have such tasks anymore
29 | """
30 | serice_periodic_tasks = {}
31 |
32 | for service in Service.objects.all():
33 | serice_periodic_tasks[service.label] = service.app_config.periodic_tasks.keys()
34 |
35 | to_delete = []
36 | to_add = []
37 |
38 | for integration in Integration.objects.prefetch_related('periodictask_set').filter(service_enabled=True):
39 | expected_tasks = serice_periodic_tasks[integration.service_id]
40 | actual_tasks = {t.name: t.id for t in integration.periodictask_set.all()}
41 |
42 | for actual_task_name, actual_task_id in actual_tasks.items():
43 | if actual_task_name not in expected_tasks:
44 | to_delete.append(actual_task_id)
45 | logger.info('Task %s:%s scheduled for removal',
46 | integration.service_id, actual_task_name)
47 |
48 | for expected_task in expected_tasks:
49 | if expected_task not in actual_tasks.keys():
50 | to_add.append(PeriodicTask(integration=integration,
51 | name=expected_task,
52 | next_run=now()))
53 | logger.info('Task %s:%s scheduled for adding',
54 | integration.service_id, expected_task)
55 |
56 | if to_add:
57 | PeriodicTask.objects.bulk_create(to_add)
58 |
59 | if to_delete:
60 | PeriodicTask.objects.filter(id__in=to_delete).delete()
61 |
62 |
63 | def get_pending():
64 | """ Iterator returning periodic tasks to be executed
65 |
66 | :rtype: Iterator[PeriodicTask]
67 | """
68 | for task in PeriodicTask.objects.filter(next_run__lt=now()):
69 | yield task
70 |
--------------------------------------------------------------------------------
/powerapp/core/models/oauth.py:
--------------------------------------------------------------------------------
1 | import logging
2 | import datetime
3 | from django.db import models
4 | from django.conf import settings
5 | from django.utils.timezone import now
6 |
7 | # token, returned by most services, is a dict containing the access
8 | # token at least, and may or may not contain some extra fields
9 | #
10 | # {
11 | # 'token_type': 'Bearer',
12 | # 'refresh_token': 'xxxxxxxxxxxxxxxxx',
13 | # 'expires_in': 3600,
14 | # 'access_token': 'xxxxxxxxxxxxxxxxx'
15 | # }
16 |
17 | logger = logging.getLogger(__name__)
18 |
19 |
20 | class OAuthToken(models.Model):
21 | user = models.ForeignKey(settings.AUTH_USER_MODEL)
22 | client = models.CharField('OAuth client name', max_length=128)
23 | access_token = models.CharField('OAuth access token', max_length=1024)
24 | refresh_token = models.CharField('OAuth refresh token', max_length=1024, null=True)
25 | token_type = models.CharField('Token type', max_length=64, default='Bearer')
26 | access_token_expires = models.DateTimeField('Access token expiration date',
27 | null=True, default=None)
28 |
29 | class Meta:
30 | app_label = 'core'
31 | unique_together = [
32 | ('user', 'client'),
33 | ]
34 |
35 | def __str__(self):
36 | return '%s:%s' % (self.client, self.token_type)
37 |
38 | @classmethod
39 | def register(cls, user, client,
40 | access_token, expires_in=None,
41 | refresh_token=None,
42 | token_type='Bearer'):
43 | """
44 | Register new access token.
45 | """
46 | if expires_in is not None:
47 | # we want to update the token at least one min before it expires
48 | access_token_expires = now() + datetime.timedelta(seconds=expires_in - 60)
49 | else:
50 | access_token_expires = None
51 |
52 | default_values = {
53 | 'access_token': access_token,
54 | 'access_token_expires': access_token_expires,
55 | 'refresh_token': refresh_token,
56 | 'token_type': token_type,
57 | }
58 | obj, _ = cls.objects.update_or_create(client=client, user=user,
59 | defaults=default_values)
60 | return obj
61 |
62 | def get_expires_in(self):
63 | if self.access_token_expires is None:
64 | return 3600 # always return some positive value
65 | return int((self.access_token_expires - now()).total_seconds())
66 |
67 | def refresh(self, token):
68 | self.access_token = token['access_token']
69 | self.access_token_expires = now() + datetime.timedelta(seconds=token['expires_in'] - 60)
70 | self.save()
71 |
--------------------------------------------------------------------------------
/env.sample:
--------------------------------------------------------------------------------
1 | # Hi! This file contains custom settings for your local development
2 | # installation. It can also be used to setup the production environment if you
3 | # want to host the service yourself.
4 | #
5 | # Copy this file from "env.sample" to ".env" (mind the leading dot) and perform
6 | # your modification in this new file
7 |
8 | # Values are read in settings.py. Every configuration option has to be written
9 | # in a separate line in KEY=value format, without any spaces around "=" or
10 | # before KEY.
11 |
12 | # REQUIRED.
13 | # Your website base URL (with http/https prefix). Used to construct absolute URLs
14 | # when the request object is not available
15 | # SITE_URL=https://powerapp.todoist.com
16 |
17 | # Turn on Django debug mode
18 | # See https://docs.djangoproject.com/en/dev/ref/settings/#debug for more details
19 | DEBUG=on
20 |
21 | # A Django secret key to crypto sign your messages, sessions, etc. Can be any
22 | # random string and has to be kept in secret.
23 | # See https://docs.djangoproject.com/en/dev/ref/settings/#std:setting-SECRET_KEY
24 | # for more details
25 | SECRET_KEY=arandomsecretstring
26 |
27 | # URL to connect to your database. You can use SQLite in dev environment
28 | # Postgres example:
29 | # DATABASE_URL=postgres://username:password@localhost/databasename
30 | # SQLite example:
31 | DATABASE_URL=sqlite:///powerapp.sqlite
32 |
33 | # Todoist Application settings. Create your own set of settings in
34 | # https://todoist.com/app_console/ and copy "Client ID" and "Client Secret" here
35 | TODOIST_CLIENT_ID=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
36 | TODOIST_CLIENT_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxx
37 |
38 | # Redis settings. Required for Celery
39 | # REDIS_URL=redis://user:password@host:port
40 |
41 | # Statsd settings. Useful if you want to collect performance statistics for
42 | # your application
43 | # STATSD_CLIENT='django_statsd.clients.normal'
44 | # STATSD_MODEL_SIGNALS=on
45 | # STATSD_CELERY_SIGNALS=on
46 | # STATSD_HOST=localhost
47 | # STATSD_PORT=8025
48 | # STATSD_PREFIX=powerapp
49 |
50 | # Settings for integration testing. Optional. Even if you're a developer :)
51 | TEST_NGROK_SUBDOMAIN=
52 | TEST_NGROK_AUTH_TOKEN=
53 | TEST_PREMIUM_EMAIL=premium@example.com
54 | TEST_PREMIUM_PASSWORD=password
55 |
56 | # Settings to receive webhooks from Google: https://www.google.com/webmasters/verification/
57 | # GOOGLE_SITE_VERIFICATION=....
58 |
59 | # Optional settings for Sentry logging
60 | # SENTRY_DSN=...
61 |
62 | # Graylog2 settings
63 | # GRAYLOG2_HOST=192.168.1.1
64 | # GRAYLOG2_PORT=12201
65 |
66 | # Other optional setting for all sorts of third-party integrations.
67 | # GOOGLE_CLIENT_ID=xxxxxxxxxxxxxxxxxxxxxxxxxxx
68 | # GOOGLE_CLIENT_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxx
69 | # POCKET_CONSUMER_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxx
70 |
--------------------------------------------------------------------------------
/powerapp/sync_bridge/todoist_sync_adapter.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from powerapp.core.exceptions import return_or_raise
3 | from powerapp.sync_bridge.bridge import SyncAdapter, TASK_FIELDS, task, defined, \
4 | undefined
5 |
6 | TODOIST_ESSENTIAL_FIELDS = TASK_FIELDS[::]
7 | TODOIST_ESSENTIAL_FIELDS.remove('tags')
8 |
9 |
10 | class TodoistSyncAdapter(SyncAdapter):
11 | """
12 | Sync Adapter for Todoist. Used to sync data between the chosen project in
13 | Todoist, and a third-party library.
14 |
15 | Does not support syncing of tags yet
16 | """
17 | DEFAULT_NAME = 'todoist'
18 | ESSENTIAL_FIELDS = TODOIST_ESSENTIAL_FIELDS
19 |
20 | def __init__(self, project_id):
21 | name = '%s-%s' % (self.DEFAULT_NAME, project_id)
22 | super(TodoistSyncAdapter, self).__init__(name=name)
23 | self.project_id = project_id
24 |
25 | def push_task(self, task_id, task, extra):
26 | todoist_task_fields = ['checked', 'in_history', 'indent', 'item_order',
27 | 'priority', 'due_date', 'date_string', 'content']
28 | task_dict = task._asdict()
29 | kwargs = {}
30 | for field_name in todoist_task_fields:
31 | value = task_dict[field_name]
32 | if value is not undefined:
33 | kwargs[field_name] = value
34 |
35 | if task_id:
36 | self.api.item_update(task_id, **kwargs)
37 | return_or_raise(self.api.commit())
38 | return task_id, {} # return task_id and extra
39 |
40 | else:
41 | content = defined(kwargs.pop('content', 'New Task'), 'New Task')
42 | obj = self.api.items.add(content, self.project_id, **kwargs)
43 | return_or_raise(self.api.commit())
44 | return obj['id'], {} # return task_id and extra
45 |
46 | def complete_task(self, task_id, extra):
47 | self.api.item_update(task_id, checked=True, in_history=True)
48 | return_or_raise(self.api.commit())
49 |
50 | def delete_task(self, task_id, extra):
51 | with self.api.autocommit():
52 | self.api.item_delete(task_id)
53 |
54 | def task_from_data(self, data, extra):
55 | """
56 | Take a Todoist item (as data) and return a new generic task. "Extra"
57 | is not used.
58 | """
59 | return task(checked=data['checked'],
60 | content=data['content'],
61 | date_string=data['date_string'],
62 | due_date=data['due_date'],
63 | in_history=data['in_history'],
64 | indent=data['indent'],
65 | item_order=data['item_order'],
66 | priority=data['priority'],
67 | tags=None)
68 |
--------------------------------------------------------------------------------
/powerapp/core/logging_utils.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from threading import local
3 | import datetime
4 | from contextlib import contextmanager
5 | from django.utils.encoding import force_text
6 |
7 |
8 | # local context to be used in logging
9 | _local_ctx = local()
10 |
11 |
12 | @contextmanager
13 | def ctx(**kwargs):
14 | """
15 | context manager used to set up extra logging variables
16 | """
17 | _ensure_local_has_ctx()
18 | old_ctx = _local_ctx.ctx.copy()
19 | try:
20 | update_ctx(**kwargs)
21 | yield
22 | finally:
23 | _local_ctx.ctx = old_ctx
24 |
25 |
26 | def update_ctx(**kwargs):
27 | """
28 | A helper function to update the context. Data will be available until
29 | the end of the thread, unless overwritten
30 | """
31 | _ensure_local_has_ctx()
32 | _local_ctx.ctx.update(**kwargs)
33 |
34 |
35 | def get_ctx():
36 | """ get the dict with thread local context """
37 | _ensure_local_has_ctx()
38 | return _local_ctx.ctx
39 |
40 |
41 | def _ensure_local_has_ctx():
42 | if not hasattr(_local_ctx, 'ctx'):
43 | _local_ctx.ctx = {}
44 |
45 |
46 | class ContextFilter(object):
47 | """
48 | A filter which simply adds log data to the context
49 | """
50 | def __init__(self, fields=None):
51 | self.fields = fields or {}
52 |
53 | def filter(self, record):
54 | effective_ctx = dict(self.fields, **get_ctx())
55 | for k, v in effective_ctx.items():
56 | for processed_key, processed_value in self.process(k, v).items():
57 | setattr(record, processed_key, processed_value)
58 | return True
59 |
60 | def process(self, key, value):
61 | """ helper function to convert whatever value to dict """
62 | if isinstance(value, datetime.datetime):
63 | return {key: value.isoformat()}
64 |
65 | if hasattr(value, '__log__') and callable(value.__log__):
66 | return {'%s_%s' % (key, k): v for k, v in value.__log__().items()}
67 |
68 | return {key: force_text(value)}
69 |
70 |
71 | class RequestContextMiddleware(object):
72 |
73 | def process_request(self, request):
74 | """
75 | Populate context with useful information.
76 | """
77 | # we're safe here, as long as this function is called on every request,
78 | # and all fields are populated
79 | fields = {
80 | # user field
81 | 'user': request.user,
82 | # request-related fields
83 | 'request_url': request.get_full_path(),
84 | 'request_method': request.method,
85 | 'user_agent': request.META['HTTP_USER_AGENT'],
86 | 'remote_addr': request.META['REMOTE_ADDR'],
87 | }
88 | update_ctx(**fields)
89 |
--------------------------------------------------------------------------------
/powerapp/core/models/integration.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import datetime
3 | from django.db import models
4 | from django.utils.timezone import now, make_aware
5 | from django.conf import settings
6 | from django.apps import apps
7 | from django.utils.functional import cached_property
8 | from picklefield import PickledObjectField
9 | from powerapp.core.sync import TodoistAPI
10 |
11 |
12 | SYNC_PERIOD = datetime.timedelta(minutes=1 if settings.DEBUG else 30)
13 |
14 |
15 | class Integration(models.Model):
16 |
17 | # Woohoo! Millenium!
18 | MILLENIUM = make_aware(datetime.datetime(2000, 1, 1))
19 |
20 | name = models.CharField(max_length=1024)
21 | service = models.ForeignKey('Service', max_length=1024)
22 | user = models.ForeignKey(settings.AUTH_USER_MODEL)
23 | settings = PickledObjectField(default={})
24 |
25 | # API client fields
26 | stateless = models.BooleanField(default=True)
27 | api_state = PickledObjectField()
28 | api_last_sync = models.DateTimeField(default=MILLENIUM)
29 | api_next_sync = models.DateTimeField(default=MILLENIUM)
30 |
31 | # enabled status (cache value from the "service" field)
32 | service_enabled = models.BooleanField(default=True, editable=False)
33 |
34 | def __str__(self):
35 | return self.name
36 |
37 | def __log__(self):
38 | return {
39 | 'id': self.id,
40 | 'service': self.service_id,
41 | 'uid': self.user_id,
42 | }
43 |
44 | class Meta:
45 | app_label = 'core'
46 | index_together = [
47 | ['service_enabled', 'user', 'service'],
48 | ['service_enabled', 'stateless', 'api_next_sync']
49 | ]
50 |
51 | def update_settings(self, **kwargs):
52 | self.settings = dict(self.settings or {}, **kwargs)
53 | self.save(update_fields=['settings'])
54 |
55 | def reset_api(self):
56 | if not self.stateless:
57 | self.api_state = None
58 | self.api_last_sync = self.MILLENIUM
59 | self.api_next_sync = self.MILLENIUM
60 | self.api = TodoistAPI.create(self)
61 | self.api.user.sync()
62 |
63 | @cached_property
64 | def api(self):
65 | return TodoistAPI.create(self)
66 |
67 | @property
68 | def app_config(self):
69 | """
70 | Return the initialized Application Config instance, connected to
71 | this instance's service. It's here to avoid extra database query
72 | for requests like `instance.service.app_config`
73 |
74 | :rtype: powerapp.core.apps.ServiceAppConfig
75 | """
76 | return apps.get_app_config(self.service_id)
77 |
78 | def save(self, **kwargs):
79 | # move next_sync forward if needed
80 | threshold = self.api_last_sync or now()
81 | if not self.stateless and (not self.api_next_sync
82 | or self.api_next_sync < threshold):
83 | self.api_next_sync = threshold + SYNC_PERIOD
84 | super(Integration, self).save(**kwargs)
85 |
--------------------------------------------------------------------------------
/powerapp/contrib/evernote_sync/signals.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import datetime
3 | from logging import getLogger
4 | from django.conf import settings
5 | from django.dispatch.dispatcher import receiver
6 | from .apps import AppConfig
7 | from powerapp.contrib.evernote_sync.sync_adapter import EvernoteSyncAdapter, \
8 | get_bridge_by_guid, build_bridge
9 | from powerapp.core.exceptions import PowerAppInvalidTokenError
10 | from powerapp.sync_bridge.bridge import SyncBridge
11 | from powerapp.sync_bridge.todoist_sync_adapter import TodoistSyncAdapter
12 | from . import utils
13 |
14 |
15 | logger = getLogger(__name__)
16 |
17 |
18 | @receiver(AppConfig.signals.todoist_task_added)
19 | @receiver(AppConfig.signals.todoist_task_updated)
20 | def on_task_changed(sender, user=None, service=None, integration=None, obj=None, **kwargs):
21 | # let's see if we have to keep track of this
22 | guid = integration.settings.get('projects_notebooks', {}).get(obj['project_id'])
23 | if guid is None:
24 | return
25 |
26 | td = TodoistSyncAdapter(obj['project_id'])
27 | ev = EvernoteSyncAdapter(guid)
28 | bridge = SyncBridge(integration, td, ev)
29 | bridge.push_task(td, obj['id'], obj)
30 |
31 |
32 | @receiver(AppConfig.signals.todoist_task_deleted)
33 | def on_task_deleted(sender, user=None, service=None, integration=None, obj=None, **kwargs):
34 | # let's see if we have to keep track of this
35 | guid = integration.settings.get('projects_notebooks', {}).get(obj['project_id'])
36 | if guid is None:
37 | return
38 |
39 | td = TodoistSyncAdapter(obj['project_id'])
40 | ev = EvernoteSyncAdapter(guid)
41 | bridge = SyncBridge(integration, td, ev)
42 | bridge.delete_task(td, obj['id'])
43 |
44 |
45 | @receiver(utils.evernote_note_changed)
46 | def on_note_changed(sender, integration, note, **kwargs):
47 | # we don't care about this note
48 | if note.notebookGuid not in integration.settings.get('evernote_notebooks', []):
49 | return
50 | # this note doesn't have a reminder, skip it as well
51 | if not note.attributes.reminderOrder:
52 | return
53 | projects_notebooks = integration.settings.get('projects_notebooks') or {}
54 | notebooks_projects = {v: k for k, v in projects_notebooks.items()}
55 | project_id = notebooks_projects.get(note.notebookGuid)
56 | bridge = build_bridge(integration, project_id, note.notebookGuid)
57 | bridge.push_task(bridge.right, note.guid, note)
58 |
59 |
60 | @receiver(utils.evernote_note_deleted)
61 | def on_note_deleted(sender, integration, guid, **kwargs):
62 | bridge = get_bridge_by_guid(integration, guid)
63 | if bridge:
64 | bridge.delete_task(bridge.right, guid)
65 |
66 |
67 | if settings.EVERNOTE_USE_POLLING:
68 | @AppConfig.periodic_task(datetime.timedelta(minutes=1 if settings.DEBUG else 15))
69 | def sync_evernote(integration):
70 | try:
71 | utils.sync_evernote(integration)
72 | except PowerAppInvalidTokenError:
73 | logger.warning("Evernote access token for %s not found. "
74 | "Skip synchronization", integration.user)
75 |
--------------------------------------------------------------------------------
/powerapp/core/app_signals.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.dispatch import Signal
3 | from logging import getLogger
4 | from powerapp.core.logging_utils import ctx
5 | from todoist import models
6 |
7 | logger = getLogger(__name__)
8 |
9 |
10 | class TodoistSyncSignal(Signal):
11 |
12 | SYNC_SIGNAL_ARGS = ['integration', 'obj']
13 |
14 | def __init__(self, name, model):
15 | super(TodoistSyncSignal, self).__init__(providing_args=self.SYNC_SIGNAL_ARGS)
16 | self.name = name
17 | self.model = model
18 |
19 | def fire(self, integration, obj):
20 | """
21 | A wrapper around `send_robust` with logging and type conversion
22 | """
23 | if self.has_listeners():
24 | # type conversion: we don't want plain dict as an obj
25 | if not isinstance(obj, self.model):
26 | obj = self.model(obj, integration.api)
27 |
28 | # note: we use "select_related('user')" to make sure we don't
29 | # have a separate query for integration.user over here
30 | with ctx(integration=integration, user=integration.user):
31 | extra = {'signal_name': self.name, 'obj': obj}
32 | logger.debug('Send Todoist event', extra=extra)
33 | resp = self.send_robust(None, integration=integration, obj=obj)
34 | for func, item in resp:
35 | # log exceptions
36 | if isinstance(item, Exception):
37 | exc_info = (item.__class__, item, item.__traceback__)
38 | logger.error('Todoist event handler %s() raises %r',
39 | func.__name__, item,
40 | exc_info=exc_info,
41 | extra=dict(extra, func_name=func.__name__))
42 |
43 |
44 | class ServiceAppSignals(object):
45 | """
46 | The registry of all signals which the service app can emit.
47 | """
48 |
49 | def __init__(self):
50 | self.todoist_project_added = TodoistSyncSignal('todoist_project_added', models.Project)
51 | self.todoist_project_updated = TodoistSyncSignal('todoist_project_updated', models.Project)
52 | self.todoist_project_deleted = TodoistSyncSignal('todoist_project_deleted', models.Project)
53 |
54 | self.todoist_task_added = TodoistSyncSignal('todoist_task_added', models.Item)
55 | self.todoist_task_updated = TodoistSyncSignal('todoist_task_updated', models.Item)
56 | self.todoist_task_deleted = TodoistSyncSignal('todoist_task_deleted', models.Item)
57 |
58 | self.todoist_note_added = TodoistSyncSignal('todoist_note_added', models.Note)
59 | self.todoist_note_updated = TodoistSyncSignal('todoist_note_updated', models.Note)
60 | self.todoist_note_deleted = TodoistSyncSignal('todoist_note_deleted', models.Note)
61 |
62 | def __getitem__(self, item):
63 | """
64 | :rtype: Signal
65 | """
66 | try:
67 | return getattr(self, item)
68 | except AttributeError:
69 | raise KeyError('Signal %r not found' % item)
70 |
--------------------------------------------------------------------------------
/powerapp/core/todoist_utils.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | Todoist-related utils
4 | """
5 | import re
6 | from collections import namedtuple
7 | from powerapp.core.exceptions import return_or_raise
8 | from powerapp.core.sync import UserTodoistAPI
9 | from logging import getLogger
10 |
11 |
12 | logger = getLogger(__name__)
13 |
14 |
15 | def get_personal_project(integration, project_name, pid_field='project_id'):
16 | """
17 | It's a common thing for integrations to have personal projects, which they
18 | operate in.
19 |
20 | This helper function searches for a "personal project id" saved in the
21 | integration. If project is found and exist, it returns it. Otherwise
22 | it creates a new project with a given name, saves its id in the integration
23 | settings, and returns the object
24 | """
25 | # we're using the "shared API", because in a stateless mode we don't
26 | # have access to all user projects
27 | api = integration.user.api
28 | assert isinstance(api, UserTodoistAPI) # IDE hint
29 |
30 | settings = integration.settings or {}
31 |
32 | # Try to find a project by id
33 | project_id = settings.get(pid_field)
34 |
35 | # it's a broken project, ignore it
36 | if str(project_id).startswith('$'):
37 | project_id = None
38 |
39 | if project_id:
40 | project = api.projects.get_by_id(project_id)
41 | if project:
42 | return project
43 |
44 | # Project is not found. Search by project name, or create a new one
45 | projects = api.projects.all(filt=lambda p: p['name'] == project_name and not str(p['id']).startswith('$'))
46 |
47 | project = projects[0] if projects else api.projects.add(project_name)
48 |
49 | # commit all changes and update settings
50 | return_or_raise(api.commit())
51 | integration.update_settings(**{pid_field: project['id']})
52 | return project
53 |
54 |
55 | url = namedtuple('url', ['link', 'title'])
56 | re_url = re.compile(r'''
57 | (?Phttps?://[^ \(\)]+) # URL itself
58 | \s* # optional space
59 | (?:\((?P