def configure_logging(self, options):
"Configure a standardized logging setup based on the verbosity option."
self._verbosity = int(options['verbosity'])
if not 0 <= self._verbosity <= 3:
raise ValueError("Verbosity must be between 0 and 3")
# Level 3 also sets the root logger to DEBUG.
if self._verbosity == 3:
getLogger().setLevel(logging.DEBUG)
def process_view(self, request, view_func, view_args, view_kwargs):
"""
Called for every view, and catches database connection issues to serve the proper maintenance page.
"""
try:
return view_func(request, *view_args, **view_kwargs)
except mongoengine.connection.ConnectionError as err:
getLogger('app').error('Database access error: %s' % err)
return response_service_unavailable()
def process_view(self, request, view_func, view_args, view_kwargs):
"""
Called for every view, and catches database connection issues to serve the proper maintenance page.
"""
try:
return view_func(request, *view_args, **view_kwargs)
except (mongoengine.connection.ConnectionError, DatabaseWriteDenied) as err:
# TODO: Raise a DatabaseWriteDenied exception when trying to write to the database when in readonly mode.
# Currently we rely on the developer checking settings.SITE_READ_ONLY in GET views.
getLogger('app').error('Database access error: %s' % err)
return response_service_unavailable()
def new(request):
'''
Create a new short url based on the POST parameters
'''
if 'login' in request.REQUEST and 'api_key' in request.REQUEST:
login = request.REQUEST['login']
api_key = request.REQUEST['api_key']
user = User.objects(login=login, api_key=api_key).first()
else:
user = None
if user is None:
return response(status=HTTP_UNAUTHORIZED, message="Invalid credentials.")
params = {}
if 'long_url' in request.REQUEST:
params['long_url'] = request.REQUEST['long_url']
(is_valid, error_message) = validate_url(params['long_url'])
else:
(is_valid, error_message) = (False, "Missing parameter: 'long_url'")
if not is_valid:
return response(status=HTTP_BAD_REQUEST, message=error_message)
allow_slashes_in_prefix = 'allow_slashes_in_prefix' in request.REQUEST
for key in ['short_path', 'prefix']:
if key in request.REQUEST:
params[key] = request.REQUEST[key]
if '/' in params[key] and not (key == 'prefix' and allow_slashes_in_prefix):
return response(
status=HTTP_BAD_REQUEST,
message="%s may not contain a '/' character." % key)
try:
link = Link.shorten(**params)
getLogger('app').info('Successfully shortened %s into %s for user %s', link.long_url, link.hash, login)
except ShortPathConflict, err:
del params['short_path'], params['long_url']
if 'prefix' in params:
del params['prefix']
params['hash'] = err.link.hash
return response(status=HTTP_CONFLICT, message=str(err), **params)
def test_newsletter(request, newsletter_id):
newsletter = get_object_or_404(Newsletter, id=newsletter_id)
if not request.user.has_perm('can_edit_newsletter', newsletter):
raise PermissionDenied
dests = settings.COOP_CMS_TEST_EMAILS
if request.method == "POST":
try:
nb_sent = send_newsletter(newsletter, dests)
messages.success(request,
_(u"The test email has been sent to {0} addresses: {1}").format(nb_sent, u', '.join(dests)))
return HttpResponseRedirect(newsletter.get_edit_url())
except Exception, msg:
messages.error(request, _(u"An error has occured.") + u'<br>' + unicode(msg))
logger = getLogger('django.request')
logger.error('Internal Server Error: %s' % request.path,
exc_info=sys.exc_info,
extra={
'status_code': 500,
'request': request
}
)
return HttpResponseRedirect(newsletter.get_edit_url())
def test_accepts_args(self):
"""
Ensure that user-supplied arguments and the EMAIL_SUBJECT_PREFIX
setting are used to compose the email subject.
Refs #16736.
"""
message = "Custom message that says '%s' and '%s'"
token1 = 'ping'
token2 = 'pong'
logger = getLogger('django.request')
# Inspired from regressiontests/views/views.py: send_log()
# ensuring the AdminEmailHandler does not get filtered out
# even with DEBUG=True.
admin_email_handler = [
h for h in logger.handlers
if h.__class__.__name__ == "AdminEmailHandler"
][0]
# Backup then override original filters
orig_filters = admin_email_handler.filters
admin_email_handler.filters = []
logger.error(message, token1, token2)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
self.assertEqual(mail.outbox[0].subject,
"-SuperAwesomeSubject-ERROR: Custom message that says 'ping' and 'pong'")
# Restore original filters
admin_email_handler.filters = orig_filters
def upload_import(request):
logger = getLogger('app')
if request.method == 'POST':
# Provided numbers identify dives which should be imported
numbers = request.POST.getlist('numbers')
upload_id = request.POST.get('upload_id')
upload = get_object_or_404(DiveUpload, pk=upload_id, user=request.user)
try:
logger.debug("Parsing dives from upload #%d" % int(upload_id))
# TODO: Parse only requested dives to improve performance
dives = subsurface.parse_full(upload.data.path)
logger.debug("Parsed %d dives" % len(dives))
# Save parsed dives
count = 0
for dive, samples, events, sLocation in dives:
if unicode(dive.number) in numbers:
_save_dive(request.user, dive, samples, events, sLocation)
count += 1
logger.info("Saved %d dives" % count)
messages.success(request, "Successfully imported %d dives." % count)
return redirect('divelog_dive_list')
except ParseError as ex:
logger.error(ex)
messages.error(request, "Failed parsing XML file.<br />Underlying error: %s" % ex.message)
return redirect('divelog_upload_view', upload_id = upload_id)
raise Http404
def _save_dive(user, dive, samples, events, sLocation):
logger = getLogger('app')
logger.info("Saving dive %s" % dive.fingerprint)
if sLocation:
locations = Location.objects.filter(name=sLocation)
if locations:
location = locations[0]
else:
location = Location()
location.name = sLocation
location.user = user
location.save()
dive.location = location
dive.user = user
dive.size = len(samples)
dive.save()
for sample in samples:
sample.dive = dive
for event in events:
event.dive = dive
Sample.objects.bulk_create(samples)
Event.objects.bulk_create(events)
def test_accepts_args(self):
"""
Ensure that user-supplied arguments and the EMAIL_SUBJECT_PREFIX
setting are used to compose the email subject.
Refs #16736.
"""
message = "Custom message that says '%s' and '%s'"
token1 = 'ping'
token2 = 'pong'
logger = getLogger('django.request')
admin_email_handler = self.get_admin_email_handler(logger)
# Backup then override original filters
orig_filters = admin_email_handler.filters
try:
admin_email_handler.filters = []
logger.error(message, token1, token2)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
self.assertEqual(mail.outbox[0].subject,
"-SuperAwesomeSubject-ERROR: Custom message that says 'ping' and 'pong'")
finally:
# Restore original filters
admin_email_handler.filters = orig_filters
def test_accepts_args_and_request(self):
"""
Ensure that the subject is also handled if being
passed a request object.
"""
message = "Custom message that says '%s' and '%s'"
token1 = 'ping'
token2 = 'pong'
logger = getLogger('django.request')
admin_email_handler = self.get_admin_email_handler(logger)
# Backup then override original filters
orig_filters = admin_email_handler.filters
try:
admin_email_handler.filters = []
rf = RequestFactory()
request = rf.get('/')
logger.error(message, token1, token2,
extra={
'status_code': 403,
'request': request,
}
)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].to, ['*****@*****.**'])
self.assertEqual(mail.outbox[0].subject,
"-SuperAwesomeSubject-ERROR (internal IP): Custom message that says 'ping' and 'pong'")
finally:
# Restore original filters
admin_email_handler.filters = orig_filters
def handle_exception(self, exc, request):
from django.utils.log import getLogger
from django.conf import settings
logger = getLogger('django.request')
exc_info = sys.exc_info()
logger.error(
'Internal Server Error: %s', request.path,
exc_info=exc_info,
extra={
'status_code': 500,
'request': request
}
)
resp = HttpResponse('', status=500, content_type='text/plain')
resp.content = ''
if hasattr(exc, 'resp_obj'):
resp = exc.resp_obj
resp.status_code = 500
resp.set_common_headers(request)
else:
resp = HttpResponse('', status=500, content_type='text/plain')
resp.content = 'An error occured.'
if settings.DEBUG:
from django.views.debug import ExceptionReporter
reporter = ExceptionReporter(request, *exc_info)
resp.content = reporter.get_traceback_text()
resp['Content-Type'] = 'text/plain'
return resp
def _caller(*args, **kwargs):
"""Caller."""
logger = getLogger(**kwargs)
ret_value = None
# cache.add fails if if the key already exists
# memcache delete is very slow, but we have to use it to take
# advantage of using add() for atomic locking
have_lock = lambda: str(cache.get(key)) == "true"
task_lock = lambda: cache.add(key, "true", timeout)
release_lock = lambda: cache.delete(key)
if not have_lock():
try:
task_lock()
logger.debug("Lock aquired for task : %s(%s)" % (key, args))
ret_value = run_func(*args, **kwargs)
except Exception as e:
logger.error("The task failed to execute: %s (%s, %s)" % (e.message, type(e), e))
ret_value = e
finally:
if have_lock():
release_lock()
logger.debug("Lock released for task: %s(%s)" % (key, args))
return ret_value
else:
logger.debug("The task is already locked: %s(%s)" % (key, args))
_caller = _dec
def set_logging(self, verbosity):
"""Set the log-level."""
log = getLogger('nsot_server')
loglevel = self.get_loglevel(verbosity)
log.setLevel(loglevel)
self.log = log
def send_log(request, exc_info):
logger = getLogger('django.request')
logger.error('Internal Server Error: %s' % request.path,
exc_info=exc_info,
extra={
'status_code': 500,
'request': request
}
)
def handle_label(self, label, **options):
"""
Prints count of of objects of each model for app == label
"""
module = __import__(label)
module_models = models.get_models(getattr(module, 'models'))
logger = getLogger('')
for model in module_models:
logger.info(u' '.join([unicode(model),
unicode(model.objects.count())]))
def send_log(request, exc_info):
logger = getLogger("django.request")
# The default logging config has a logging filter to ensure admin emails are
# only sent with DEBUG=False, but since someone might choose to remove that
# filter, we still want to be able to test the behavior of error emails
# with DEBUG=True. So we need to remove the filter temporarily.
admin_email_handler = [h for h in logger.handlers if h.__class__.__name__ == "AdminEmailHandler"][0]
orig_filters = admin_email_handler.filters
admin_email_handler.filters = []
logger.error(
"Internal Server Error: %s" % request.path, exc_info=exc_info, extra={"status_code": 500, "request": request}
)
admin_email_handler.filters = orig_filters
def inner(*args, **kwargs):
try:
gen = func(*args, **kwargs)
for v in gen:
yield v
except OperationalError as e:
if getattr(settings, 'SPHINX_IMMORTAL', False):
logger = getLogger("django.db.backends.sphinx")
try:
query = args[0].query
except (IndexError, AttributeError):
query = "unknown"
logger.error(u"Sphinx search error at '{}'".format(query),
exc_info=True)
return
raise
def test_truncate_subject(self):
"""
RFC 2822's hard limit is 998 characters per line.
So, minus "Subject: ", the actual subject must be no longer than 989
characters.
Refs #17281.
"""
message = 'a' * 1000
expected_subject = 'ERROR: aa' + 'a' * 980
self.assertEqual(len(mail.outbox), 0)
logger = getLogger('django.request')
logger.error(message)
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, expected_subject)
def test_subject_accepts_newlines(self):
"""
Ensure that newlines in email reports' subjects are escaped to avoid
AdminErrorHandler to fail.
Refs #17281.
"""
message = u'Message \r\n with newlines'
expected_subject = u'ERROR: Message \\r\\n with newlines'
self.assertEqual(len(mail.outbox), 0)
logger = getLogger('django.request')
logger.error(message)
self.assertEqual(len(mail.outbox), 1)
self.assertFalse('\n' in mail.outbox[0].subject)
self.assertFalse('\r' in mail.outbox[0].subject)
self.assertEqual(mail.outbox[0].subject, expected_subject)
def recycle():
"""
the purpose of this tasks is to recycle the data from the cache
with version=2 in the main cache
"""
logger = getLogger('django_th.trigger_happy')
all_packages = MyService.all_packages()
for package in all_packages:
cache = caches[package]
# http://niwinz.github.io/django-redis/latest/#_scan_delete_keys_in_bulk
for service in cache.iter_keys('th_*'):
try:
# get the value from the cache version=2
service_value = cache.get(service, version=2)
# put it in the version=1
cache.set(service, service_value)
# remote version=2
cache.delete_pattern(service, version=2)
except ValueError:
pass
logger.info('recycle of cache done!')
def send_mail(accounts, subject, text_content, html_content):
connection = mail.get_connection()
connection.open()
system_user = get_system_user()
fails = 0
for account in accounts:
if isinstance(account, (tuple, list)):
account_email = account[1]
account = account[0]
else:
account_email = account.email
if not account_email:
continue
if account.id == system_user.id or account.is_bot:
continue
email = mail.EmailMultiAlternatives(subject, text_content, project_settings.EMAIL_NOREPLY, [account_email], connection=connection)
email.attach_alternative(html_content, "text/html")
try:
email.send()
except Exception:
from django.utils.log import getLogger
if not project_settings.TESTS_RUNNING:
logger = getLogger('the-tale.workers.post_service_message_sender')
logger.error('Exception while send email',
exc_info=sys.exc_info(),
extra={} )
fails += 1
connection.close()
return fails == 0
def __init__(self):
self._log = getLogger(__name__)
if len(PanoptoMockData.app_resource_dirs) < 1:
for app in settings.INSTALLED_APPS:
try:
mod = import_module(app)
except ImportError, e:
raise ImproperlyConfigured('ImportError %s: %s' % (app, e.args[0]))
resource_dir = os.path.join(os.path.dirname(mod.__file__),
'resources/panopto/file')
if os.path.isdir(resource_dir):
# Cheating, to make sure our resources are overridable
data = {
'path': resource_dir.decode(PanoptoMockData.fs_encoding),
'app': app,
}
if app == 'restclients':
PanoptoMockData.app_resource_dirs.append(data)
else:
PanoptoMockData.app_resource_dirs.insert(0, data)
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with DjangoContribAderit. If not, see <http://www.gnu.org/licenses/>.
'''
Extensions of qprocessors.py for adding new type of questions
'''
__copyright__ = '''Copyright (C) 2012 Aderit srl'''
from django.utils.log import getLogger
from django.utils.simplejson import dumps
from django.utils.translation import ugettext as _, ungettext
from questionnaire import (question_proc, answer_proc, add_type,
AnswerException)
logger = getLogger('aderit.questionnaire_extensions.qprocessors')
@question_proc('choice-select')
def question_choice(request, question):
choices = []
jstriggers = []
cd = question.getcheckdict()
key = "question_%s" % question.number
key2 = "question_%s_comment" % question.number
val = None
if key in request.POST:
val = request.POST[key]
else:
if 'default' in cd:
val = cd['default']
from django import forms
from django.template import Context
from django.template import RequestContext
from django.template import loader
from django.template import TemplateDoesNotExist
from django.utils.html import escape
from django.utils.html import conditional_escape
from django.utils.log import getLogger
from django.http import QueryDict
from django.http import HttpResponse
from django.http import HttpResponseRedirect
logger = getLogger('debugging')
simple_response = '''<html>
<head><title>{response_string}</title></head>
<body><h1>{response_string}</h1><p>{details}</p></body>
</html>'''
class BoolSelect(forms.Select):
'''Fixed drop-down select for BOOLEAN_CHOICES'''
def render_option(self, selected_choices, option_value, option_label):
# Output is very much not expected.
# Why in the world "selected_choices"
# based on the *labels*?
# logger.debug('What is selected: %s %s %s' % (
# repr(selected_choices),
# repr(option_value),
# repr(option_label)))
option_value = option_value
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with DjangoContribAderit. If not, see <http://www.gnu.org/licenses/>.
'''
Admin for Seantis Questionnaire extensions by Aderit.
'''
__copyright__ = '''Copyright (C) 2012 Aderit srl'''
from django.contrib import admin
from django.forms import forms, models as forms_models
from django.utils.log import getLogger
from django.contrib.aderit.access_account import _get_model_from_auth_profile_module
from django.contrib.aderit.questionnaire_extensions.models import Questionnaire, QuestionnaireMails
logger = getLogger('aderit.questionnaire_extensions.admin')
# class QuestionnaireAdmin(admin.ModelAdmin):
# # fields = ('name', 'redirect_url', 'accounts')
# # fields = ('name', 'redirect_url')
# # filter_horizontal = ('accounts',)
# def get_form(self, request, obj=None, **kwargs):
# logger.debug("get_form: obj %s -- kw: %s -- self.fields: %s",
# obj, kwargs, self.fields)
# form_k = super(QuestionnaireAdmin, self).get_form(request,
# obj=obj,
# **kwargs)
# acc_model = _get_model_from_auth_profile_module()
try:
from threading import local
except ImportError:
from django.utils._threading_local import local
from django.conf import settings
from django.contrib.sites import models as sites_models
from django.core.exceptions import MiddlewareNotUsed, ImproperlyConfigured
from django.utils import log
from django_tools.local_sync_cache.local_sync_cache import LocalSyncCache
from django_tools.dynamic_site.models import SiteAlias
USE_DYNAMIC_SITE_MIDDLEWARE = getattr(settings, "USE_DYNAMIC_SITE_MIDDLEWARE", False)
logger = log.getLogger("django_tools.DynamicSite")
#if "runserver" in sys.argv or "tests" in sys.argv:
# log.logging.basicConfig(format='%(created)f pid:%(process)d %(message)s')
# logger.setLevel(log.logging.DEBUG)
# logger.addHandler(log.logging.StreamHandler())
#
#if not logger.handlers:
# # ensures we don't get any 'No handlers could be found...' messages
# logger.addHandler(log.NullHandler())
Site = sites_models.Site # Shortcut
class DynamicSiteId(object):
# Sort from biggest to lowest:
AUTOUPDATECACHE_TIMES = list(AUTOUPDATECACHE_TIMES)
AUTOUPDATECACHE_TIMES.sort(reverse=True)
AUTOUPDATECACHE_TIMES = tuple(AUTOUPDATECACHE_TIMES)
def get_max_age(load_average):
""" return max age for the given load average. """
load_average += 0.1
for load, max_age in AUTOUPDATECACHE_TIMES:
if load_average > load:
break
return max_age
logger = log.getLogger("SmoothyFileBasedCache")
#if "runserver" in sys.argv or "tests" in sys.argv:
# log.logging.basicConfig(format='%(created)f pid:%(process)d %(message)s')
# logger.setLevel(log.logging.DEBUG)
# logger.addHandler(log.logging.StreamHandler())
#
#if not logger.handlers:
# # ensures we don't get any 'No handlers could be found...' messages
# logger.addHandler(log.NullHandler())
class AutoUpdateFileBasedCache(FileBasedCache):
CHANGE_TIME = None # Timestamp of the "last update"
NEXT_SYNC = None # Point in the future to update the CHANGE_TIME
# You should have received a copy of the GNU General Public License
# along with DjangoContribAderit. If not, see <http://www.gnu.org/licenses/>.
'''Built-in, globally-available admin actions.'''
from django.contrib import admin
from django import template
from django.contrib.admin import helpers
from django.contrib.admin.util import model_ngettext
from django.shortcuts import render_to_response
from django.utils.encoding import force_unicode
from django.utils.translation import ugettext_lazy as _
from django.utils.log import getLogger
from django.http import HttpResponse
import csv
logger = getLogger('aderit.generic_utils.actions')
def export_as_csv_action(modeladmin, request, queryset):
"""
Exports all selected objects from model
"""
opts = modeladmin.model._meta
fields = [field.name for field in opts.fields]
app_label = opts.app_label
if request.POST.get('post'):
fields_wanted = []
for i in request.POST.items():
if str(i[0]).startswith('field-'):
fields_wanted.append(str(i[0])[6:])
response = HttpResponse(mimetype='text/csv')
def get_logger():
log.dictConfig(settings.LOGGING)
return log.getLogger('custom')
import sys
from django.conf import settings
from django.contrib import messages
from django.utils.safestring import mark_safe
from django.utils.log import getLogger
from django_tools.utils.messages import failsafe_message
from pylucid_project.apps.pylucid.preference_forms import SystemPreferencesForm
from pylucid_project.apps.pylucid.system import extrahead
from pylucid_project.utils.escape import escape
# see: http://www.pylucid.org/permalink/443/how-to-display-debug-information
log = getLogger("pylucid-objects")
# max value length in debug __setattr__
MAX_VALUE_LENGTH = 150
class PathInfo(object):
def __init__(self, request):
self.raw_path = request.path
def set_url_lang_info(self, url_lang_code, url_slugs):
"""
set information fom the requested url.
e.g.:
/en/page/sub-page/
->
'''
Created on Jan 11, 2011
@author: akai
'''
from django.contrib import admin
import models
from django.utils import log
from django.conf import settings
log.dictConfig(settings.LOGGING)
logger = log.getLogger('custom')
m = dir(models)
for i in m:
try:
admin.site.register(getattr(models, i))
except Exception, e:
pass
#map(admin.site.register, map(__import__,dir(ideab.ideabuilder.models)))
from django.core.urlresolvers import reverse
from django.db import models
from django.db.models import Q
from django.db.models.loading import get_model
from django.utils.encoding import python_2_unicode_compatible
from django.utils.functional import cached_property
from django.utils.log import getLogger
from ..files.utils import sign_s3_url
from ..notifications.signals import notify
from ..utils.decorators import autoconnect
from ..utils.fields import ReservedKeywordsAutoSlugField
from ..utils.models import BaseModel
from .constants import BOARD_RESERVED_KEYWORDS
logger = getLogger(__name__)
@autoconnect
@python_2_unicode_compatible
class Board(BaseModel):
name = models.CharField(max_length=255)
slug = ReservedKeywordsAutoSlugField(
populate_from='name',
unique_with='account',
editable=True,
reserved_keywords=BOARD_RESERVED_KEYWORDS)
account = models.ForeignKey('accounts.Account')
created_by = models.ForeignKey('users.User')
modified_by = models.ForeignKey('users.User',
import time
if __name__ == "__main__":
# For doctest only
os.environ["DJANGO_SETTINGS_MODULE"] = "django.conf.global_settings"
from django.conf import settings
from django.core.cache.backends.db import DatabaseCache
from django.core.cache.backends.filebased import FileBasedCache
from django.core.cache.backends.locmem import LocMemCache
from django.core.cache.backends.memcached import MemcachedCache, PyLibMCCache
from django.utils import log
logger = log.getLogger("django-tools.SmoothCache")
if not logger.handlers:
# ensures we don't get any 'No handlers could be found...' messages
logger.addHandler(log.NullHandler())
#if "runserver" in sys.argv or "tests" in sys.argv:
# log.logging.basicConfig(format='%(created)f pid:%(process)d %(message)s')
# logger.setLevel(log.logging.DEBUG)
# logger.addHandler(log.logging.StreamHandler())
SMOOTH_CACHE_CHANGE_TIME = getattr(settings, "SMOOTH_CACHE_CHANGE_TIME", "DJANGO_TOOLS_SMOOTH_CACHE_CHANGE_TIME")
SMOOTH_CACHE_UPDATE_TIMESTAMP = getattr(settings, "SMOOTH_CACHE_UPDATE_TIMESTAMP", 10)
SMOOTH_CACHE_TIMES = getattr(settings, "SMOOTH_CACHE_TIMES", (
# load value, max age in sec.
(0, 5), # < 0.1 -> 5sec
:license: GNU GPL v3 or above, see LICENSE for more details.
"""
import sys
import logging
from django.conf import settings
from django.contrib import messages
from django.core.cache import cache
from django.http import HttpResponse
from django.utils.cache import get_max_age, patch_response_headers
from django.utils.log import getLogger
from django_tools.utils.importlib import get_attr_from_settings
logger = getLogger("django-tools.CacheMiddleware")
#logger.setLevel(logging.DEBUG)
#logger.addHandler(logging.StreamHandler())
CACHE_MIDDLEWARE_ANONYMOUS_ONLY = getattr(settings,
'CACHE_MIDDLEWARE_ANONYMOUS_ONLY',
False)
RUN_WITH_DEV_SERVER = getattr(settings, "RUN_WITH_DEV_SERVER", "runserver"
in sys.argv)
EXTRA_DEBUG = getattr(settings, "CACHE_EXTRA_DEBUG", False)
COUNT_FETCH_FROM_CACHE = getattr(settings, "COUNT_FETCH_FROM_CACHE", False)
COUNT_UPDATE_CACHE = getattr(settings, "COUNT_UPDATE_CACHE", False)
COUNT_IN_CACHE = getattr(settings, "COUNT_IN_CACHE", False)
cache_callback = get_attr_from_settings("CACHE_CALLBACK",
from __future__ import unicode_literals
from __future__ import absolute_import
import datetime
import time
import arrow
from celery import shared_task
from django.conf import settings
from django_th.services import default_provider
from django_th.models import TriggerService
from django.utils.log import getLogger
# create logger
logger = getLogger('django_th.trigger_happy')
default_provider.load_services()
def update_trigger(service):
"""
update the date when occurs the trigger
"""
now = arrow.utcnow().to(settings.TIME_ZONE).format('YYYY-MM-DD HH:mm:ss')
TriggerService.objects.filter(id=service.id).update(date_triggered=now)
def to_datetime(data):
"""
convert Datetime 9-tuple to the date and time format
# -*- coding: utf-8 -*-
# vim: set fileencoding=utf-8 :
from django.conf import settings
from django.db.models import fields as models_fields
from django.contrib.auth.models import User
from django.core.validators import RegexValidator
from django.utils.log import getLogger
from django.utils.translation import ugettext_lazy as _
from django.contrib.aderit.access_account.models import AccessAccount
from django.contrib.aderit.generic_utils.models.fields import \
GenericPhoneField as PhoneField
logger = getLogger('account.models')
### User Profile Model
class Account(AccessAccount):
phone = PhoneField(_("Phone"), max_length=125, blank=True) # home phone
mobile_phone = PhoneField(_("Mobile Phone"), max_length=125, blank=True) # mobile phone
reported_by = models_fields.CharField(_("Reported By"), max_length=250, blank=True) # who spoke about
class Meta:
verbose_name = _('Account')
verbose_name_plural = _('Accounts')
ordering = ["user"]
def __unicode__(self):
return self.user.username
from django.utils.log import getLogger
from django.views.generic import RedirectView
# 2. 3rd parties
from lxml import etree
import magic
# 3. system
import sys, os, shutil, datetime, pprint, re, uuid
import logging
# 4. my
import models, views
# constants
log = getLogger('app')
mime = magic.open(magic.MIME_TYPE)
mime.load()
etree.register_namespace('D', 'DAV:')
etree.register_namespace('M', 'urn:schemas-microsoft-com:')
etree.register_namespace('A', 'http://apache.org/dav/props/')
locks = dict() # id: (token:str, timeout:datetime)
LOCK_MAX_TIMEOUT = 300
def __url2path(url):
'''
? Depth ?
Converts requested URL into real path
@return tuple - (ok, File() or None, filename:str or None)
# django_th classes
from django_th.services.services import ServicesMgr
from th_instapush.models import Instapush as InstapushModel
"""
handle process with instapush
put the following in settings.py
TH_SERVICES = (
...
'th_instapush.my_instapush.ServiceInstapush',
...
)
"""
logger = getLogger("django_th.trigger_happy")
class ServiceInstapush(ServicesMgr):
"""
Service Instapush
"""
def __init__(self, token=None, **kwargs):
super(ServiceInstapush, self).__init__(token, **kwargs)
self.token = token
def read_data(self, **kwargs):
"""
get the data from the service
as the pocket service does not have any date
:copyleft: 2011-2015 by the django-tools team, see AUTHORS for more details.
:license: GNU GPL v3 or above, see LICENSE for more details.
"""
from __future__ import absolute_import, division, print_function
import sys
import time
import datetime
from django.conf import settings
from django.core import cache
from django.utils import log
logger = log.getLogger("django_tools.local_sync_cache")
#if "runserver" in sys.argv or "tests" in sys.argv:
# log.logging.basicConfig(format='%(created)f pid:%(process)d %(message)s')
# logger.setLevel(log.logging.DEBUG)
# logger.addHandler(log.logging.StreamHandler())
#if not logger.handlers:
# # ensures we don't get any 'No handlers could be found...' messages
# logger.addHandler(log.NullHandler())
LOCAL_SYNC_CACHE_BACKEND = getattr(settings, "LOCAL_SYNC_CACHE_BACKEND",
"local_sync_cache")
def _get_cache():
import datetime
import simplejson
# Create your views here.
from django.contrib.auth import authenticate, login
from django.views.generic import View, ListView, DetailView
from django.views.generic.base import TemplateView
from django.core import serializers
from django.http import HttpResponse
from django.template import RequestContext
from django.shortcuts import render_to_response
from django.utils.log import getLogger
from sensordata import models
logger = getLogger("app")
#########################################################################
#
# Group of Home views
#
def ping(request):
msg = "pong %s" % (datetime.datetime.now())
logger.info(msg)
return HttpResponse(msg)
class HomePageView(TemplateView):
template_name = "home.html"
def get_context_data(self, **kwargs):
from django.conf import settings
from django.core import signals
from django.core.cache import cache
from django.template import RequestContext
from django.template.loader import render_to_string
from django.utils.http import urlquote
from django.utils.log import getLogger
from django.utils.translation import get_language, ugettext as _
from merengue.block.models import RegisteredBlock
from merengue.registry import params
from merengue.registry.items import RegistrableItem
from merengue.registry.signals import item_registered
logger = getLogger('merengue.block')
# block information for debugging purposes
block_debug_info = {}
class BaseBlock(RegistrableItem):
model = RegisteredBlock
singleton = False
is_addable = True
cache_allowed = True
default_caching_params = {
'enabled': False,
'only_anonymous': False,
'timeout': 0,
'vary_on_url': False,
import socket, sys, traceback, datetime, re
import settings
from django.core.mail import send_mail
from django import http
from django.shortcuts import Http404, render
from django.utils.log import getLogger
logger = getLogger('django.request')
mailto_list = getattr(settings, 'ERROR_SNIPPET_EMAILS', [])
from_addr = getattr(settings, 'DEFAULT_FROM_EMAIL', "admin@localhost")
class error_ping(object):
"""
This is a middleware class that sends short email snippets per uncaught exception
"""
def process_exception(self, request, exception):
if isinstance(exception, Http404):
return None
username = request.user.username if request.user.is_authenticated() else "Anonymous"
datestring = datetime.datetime.isoformat(datetime.datetime.now())
user_agent = request.META.get('HTTP_USER_AGENT', 'NO USER AGENT FOUND')
exc_info = sys.exc_info()
(type, value, tb) = exc_info
(path, lineno, exc, text) = traceback.extract_tb(tb)[-1]
email_subj = "%s on %s" % (repr(exception), repr(socket.gethostname()))
email_subj = re.sub(r'\n','',email_subj)
email_msg = "User: %s\nTime: %s\nUser-agent: %s\nFile path %s:%d\nLine text: %s\n" % (username, datestring, user_agent, path, lineno, text)
send_mail(email_subj, email_msg, from_addr, mailto_list)
del tb
# -*- coding: utf-8 -*-
from django.http import HttpResponseRedirect, HttpResponse, Http404
from django.utils.translation import ugettext as _
from django.utils.log import getLogger
from django.contrib.auth.decorators import permission_required, login_required
from django.shortcuts import get_object_or_404
from django.views.generic import ListView, DetailView
from models import Product, ProductForm
from TeaScrum.utils import render
logger = getLogger('TeaScrum')
@permission_required('product.add_product')
def edit_product(request, pid=None):
""" Show an edit form for a Product entity.
"""
if not pid:
pid = request.REQUEST.get('pid', None)
if pid:
product = get_object_or_404(Product, pk=pid)
if not product.owner_or_master(request.user):
return render(request, 'error', {'err': _('Permission denied')})
else:
product = None
if request.method == 'POST':
form = ProductForm(request.POST, instance=product)
if form.is_valid():
import psycopg2 as Database
import psycopg2.extensions
except ImportError, e:
from django.core.exceptions import ImproperlyConfigured
raise ImproperlyConfigured("Error loading psycopg2 module: %s" % e)
DatabaseError = Database.DatabaseError
IntegrityError = Database.IntegrityError
psycopg2.extensions.register_type(psycopg2.extensions.UNICODE)
psycopg2.extensions.register_adapter(SafeString,
psycopg2.extensions.QuotedString)
psycopg2.extensions.register_adapter(SafeUnicode,
psycopg2.extensions.QuotedString)
logger = getLogger('django.db.backends')
def utc_tzinfo_factory(offset):
if offset != 0:
raise AssertionError("database connection isn't set to UTC")
return utc
class CursorWrapper(object):
"""
A thin wrapper around psycopg2's normal cursor class so that we can catch
particular exception instances and reraise them with the right types.
"""
def __init__(self, cursor):
self.cursor = cursor
from django.contrib.auth import REDIRECT_FIELD_NAME
from django.contrib.auth.decorators import (login_required,
permission_required,
user_passes_test)
_DEFAULT_CACHE_TIMEOUT = getattr(settings, 'CACHE_MIDDLEWARE_SECONDS', 3600)
_UNCLEANABLE_COOKIES = getattr(settings, 'UNCLEANABLE_COOKIES',
['__utmz', 'sessionid', 'csrftoken', '__utma'])
class GenericUtilUseDecoratorError(Exception):
"""Illegal use of decorators in GenericUtilView"""
pass
logger = getLogger('aderit.generic_utils.views')
def _setup_attrs(self, debug=False, **attrs):
'''setattr @attrs on @self'''
for k in attrs.keys():
if getattr(self, 'force_setup_attrs', False) or hasattr(self, k):
setattr(self, k, attrs.get(k))
if debug is True:
logger.debug("setattr done: %s ==> %s", k, attrs.get(k))
class GenericUtilView(View):
'''Decoratable View'''
debug_dispatch_method = False
debug_dispatch_method_full = True
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with DjangoContribAderit. If not, see <http://www.gnu.org/licenses/>.
'''Sending mails utility functions.'''
__copyright__ = '''Copyright (C) 2012 Aderit srl'''
from django.conf import settings
from django.core.mail.backends.smtp import EmailBackend
from django.core.mail.backends.base import BaseEmailBackend
from django.utils.log import getLogger
from django.contrib.aderit.send_mail.utils import send_email_msg
from django.contrib.aderit.send_mail.models import SendMail
logger = getLogger("aderit.send_mail")
class SendTypeMailError(Exception):
'''Error for SendTypeMail family functions'''
def __repr__(self):
return "Invalid parameters"
def _SendTypeMail(kwargs, in_bulk=False):
"""
il dizionario kwargs prevede due khiavi obbligatorie: 'type' e 'mailto'
'type' : deve essere il valore di `type_mail' nel SendMail model
'mailto' : deve essere la LISTA dei destinatari
Il dizionario @kwargs è del tipo:
"""
Middleware for authentication.
"""
from django.contrib.auth import backends, middleware
from django.conf import settings
from django.core.exceptions import ValidationError
from django.core.validators import EmailValidator
from django.utils.log import getLogger
from ..util import normalize_auth_header
log = getLogger('nsot_server')
class EmailHeaderMiddleware(middleware.RemoteUserMiddleware):
header = normalize_auth_header(settings.USER_AUTH_HEADER)
class EmailHeaderBackend(backends.RemoteUserBackend):
"""Custom backend that validates username is an email."""
def authenticate(self, remote_user):
"""Override default to return None if username is invalid."""
if not remote_user:
return
username = self.clean_username(remote_user)
if not username:
return
return super(EmailHeaderBackend, self).authenticate(remote_user)
# -*- coding: utf-8 -*-
from apps.core.models import Selection_Entity, Entity
from apps.core.extend.paginator import ExtentPaginator
from django.utils.log import getLogger
from django.views.generic import ListView
from datetime import datetime, timedelta
from haystack.query import SearchQuerySet
log = getLogger('django')
TIME_FORMAT = '%Y-%m-%d 8:00:00'
def get_time_range():
if datetime.now().hour > 8:
today_start = datetime.now().strftime(TIME_FORMAT)
today_end = (datetime.now() + timedelta(days=1)).strftime(TIME_FORMAT)
else:
today_start = (datetime.now() - timedelta(days=1)).strftime(TIME_FORMAT)
today_end = datetime.now().strftime(TIME_FORMAT)
return today_start, today_end
def get_today_Secelction():
return Selection_Entity.objects.filter(pub_time__range=(get_time_range()))
class SelectionReportListView(ListView):
template_name = 'management/selection_report/list.html'
from django import template
from django.template.defaultfilters import stringfilter
from django.utils.safestring import mark_safe
import re
from django.utils.log import getLogger
import json
from django.utils.encoding import force_text
from django.conf import settings
from django.template.loader import render_to_string
LOGGER = getLogger(__name__)
register = template.Library()
def obfuscate_string(value):
'''
Simple string obfuscator
Source: https://github.com/morninj/django-email-obfuscator
'''
return ''.join(['&#{0:s};'.format(str(ord(char))) for char in value])
@register.filter
def keyvalue(d, key):
"""
Forms expose fields like a dict, but they don't support get() or __contains__ so
we need to just call and catch KeyError
"""
if not hasattr(d, '__getitem__'):
return None
try:
from the_tale.linguistics import prototypes
from the_tale.linguistics.lexicon import keys
from the_tale.linguistics.lexicon.relations import VARIABLE
from the_tale.linguistics.lexicon.groups import relations as groups_relations
from the_tale.linguistics.storage import game_dictionary
from the_tale.linguistics.storage import game_lexicon
from the_tale.linguistics.storage import restrictions_storage
from . import exceptions
from . import objects
from . import models
from .lexicon.keys import LEXICON_KEY
logger = getLogger('the-tale.linguistics')
def get_templates_count():
keys_count_data = prototypes.TemplatePrototype._db_filter(
state=relations.TEMPLATE_STATE.IN_GAME).values('key').annotate(
django_models.Count('key'))
keys_count = {key: 0 for key in keys.LEXICON_KEY.records}
keys_count.update({
keys.LEXICON_KEY(data['key']): data['key__count']
for data in keys_count_data
})
groups_count = {
:copyleft: 2009-2011 by the PyLucid team, see AUTHORS for more details.
:license: GNU GPL v3 or above, see LICENSE for more details.
"""
from django import http
from django.contrib import messages
from django.core.urlresolvers import reverse
from django.shortcuts import render_to_response
from django.utils.log import getLogger
from django.views.decorators.csrf import csrf_exempt
from pylucid_project.apps.pylucid.models import Language
from pylucid_project.apps.pylucid.decorators import render_to
logger = getLogger("pylucid.unittest_plugin")
#_____________________________________________________________________________
# http_get_view()
GET_KEY = "unittest_plugin" # plugin name
ACTION_NONE_RESPONSE = "NoneResponse"
ACTION_STRING_RESPONSE = "StringResponse"
STRING_RESPONSE = "String response from http_get_view() unittest plugin."
ACTION_HTTP_RESPONSE = "HttpResponse"
HTTP_RESPONSE = "HttpResponse from unittest plugin."
ACTION_REDIRECT = "RedirectResponse"
import hashlib
import re
from django.conf import settings
from django import http
from django.core.mail import mail_managers
from django.utils.http import urlquote
from django.core import urlresolvers
from django.utils.log import getLogger
logger = getLogger('django.request')
class CommonMiddleware(object):
"""
"Common" middleware for taking care of some basic operations:
- Forbids access to User-Agents in settings.DISALLOWED_USER_AGENTS
- URL rewriting: Based on the APPEND_SLASH and PREPEND_WWW settings,
this middleware appends missing slashes and/or prepends missing
"www."s.
- If APPEND_SLASH is set and the initial URL doesn't end with a
slash, and it is not found in urlpatterns, a new URL is formed by
appending a slash at the end. If this new URL is found in
urlpatterns, then an HTTP-redirect is returned to this new URL;
otherwise the initial URL is processed as usual.
- ETags: If the USE_ETAGS setting is set, ETags will be calculated from
the entire page content and Not Modified responses will be returned
from django import forms
from django.http import Http404
from django.core.exceptions import ObjectDoesNotExist
from django.core.paginator import EmptyPage
from django.core.paginator import PageNotAnInteger
from django.core.paginator import Paginator
from django.utils.log import getLogger
from main.utils import ActionView
from main.utils import BoolSelect
from main.models import MotionData
from main.models import UserData
logger = getLogger("debugging")
# class MotionsView(ActionView):
# def default(self):
# self.data["myvar"] = "Hi there!"
# return self.render_html("main/motion.html")
logger = getLogger("debugging")
class MotionForm(forms.ModelForm):
class Meta:
model = MotionData
widgets = {
"motion_motion_maint": BoolSelect(),
"motion_run_reports": BoolSelect(),
"motion_voter": BoolSelect(),
"motion_admin": BoolSelect(),
}
def __init__(self):
self.logger = getLogger('nsot_server')
__version__ = VERSION
from time import time
import django
from django.conf import settings
if django.VERSION < (1, 7):
from django.db.backends import util
else:
from django.db.backends import utils as util
from django.utils.log import getLogger
from readonly.exceptions import DatabaseWriteDenied
logger = getLogger('django.db.backends')
def _readonly():
return getattr(settings, 'SITE_READ_ONLY', False)
def _get_readonly_dbs():
read_on_db_names = []
for db_key in getattr(settings, 'DB_READ_ONLY_DATABASES', tuple()):
db = settings.DATABASES.get(db_key)
if db:
read_on_db_names.append(db['NAME'])
return read_on_db_names
import sys
from django.core.management.base import CommandError, NoArgsCommand
from django.utils.log import getLogger
from ...leads import sync_leads_from_profiles
logger = getLogger('management_commands')
class Command(NoArgsCommand):
def handle_noargs(self, **options):
try:
sync_leads_from_profiles()
except Exception as e:
logger.error('sync_leads Error: ' + e.message,
exc_info=sys.exc_info())
raise CommandError(e)
"""
PyLucid signals
~~~~~~~~~~~~~~~
:copyleft: 2009-2013 by the PyLucid team, see AUTHORS for more details.
:license: GNU GPL v3 or above, see LICENSE for more details.
"""
from django.utils.log import getLogger
from django.dispatch.dispatcher import Signal
# see: http://www.pylucid.org/permalink/443/how-to-display-debug-information
log = getLogger("pylucid.signals")
pre_render_global_template = Signal(providing_args=["request", "page_template"])
# post_render_global_template = django.dispatch.Signal(providing_args=["toppings", "size"])
def update_plugin_urls(sender, **kwargs):
"""
Would be connected in:
* pylucid.models.pagetree
* pylucid.models.pluginpage
"""
# import and connect signal here agains import loops
from pylucid_project.system.pylucid_plugins import clear_plugin_url_caches
# coding: utf-8
from django.utils.log import getLogger
from the_tale.game.heroes import messages
logger = getLogger('the-tale.workers.game_logic')
class Writer(object):
__init__ = ('type', 'message', 'substitution', 'hero')
def __init__(self, type, message, substitution, hero):
self.type = type
self.message = message
self.substitution = substitution
self.hero = hero
def actor_id(self, actor):
return 'quest_%s_actor_%s' % (self.type, actor)
def name_id(self):
return 'quest_%s_name' % (self.type, )
def action_id(self):
return 'quest_%s_action_%s' % (self.type, self.message)
def journal_id(self):
return 'quest_%s_journal_%s' % (self.type, self.message)
import hashlib
from django.db.backends.creation import BaseDatabaseCreation
from django.db.backends.utils import truncate_name
from django.db.models.fields.related import ManyToManyField
from django.db.transaction import atomic
from django.utils.encoding import force_bytes
from django.utils.log import getLogger
from django.utils import six
logger = getLogger('django.db.backends.schema')
class BaseDatabaseSchemaEditor(object):
"""
This class (and its subclasses) are responsible for emitting schema-changing
statements to the databases - model creation/removal/alteration, field
renaming, index fiddling, and so on.
It is intended to eventually completely replace DatabaseCreation.
This class should be used by creating an instance for each set of schema
changes (e.g. a syncdb run, a migration file), and by first calling start(),
then the relevant actions, and then commit(). This is necessary to allow
things like circular foreign key references - FKs will only be created once
commit() is called.
"""
# Overrideable SQL templates
sql_create_table = "CREATE TABLE %(table)s (%(definition)s)"
sql_create_table_unique = "UNIQUE (%(columns)s)"
import hashlib
import operator
from django.db.backends.creation import BaseDatabaseCreation
from django.db.backends.utils import truncate_name
from django.db.models.fields.related import ManyToManyField
from django.db.transaction import atomic
from django.utils.encoding import force_bytes
from django.utils.log import getLogger
from django.utils.six.moves import reduce
from django.utils.six import callable
logger = getLogger('django.db.backends.schema')
class BaseDatabaseSchemaEditor(object):
"""
This class (and its subclasses) are responsible for emitting schema-changing
statements to the databases - model creation/removal/alteration, field
renaming, index fiddling, and so on.
It is intended to eventually completely replace DatabaseCreation.
This class should be used by creating an instance for each set of schema
changes (e.g. a syncdb run, a migration file), and by first calling start(),
then the relevant actions, and then commit(). This is necessary to allow
things like circular foreign key references - FKs will only be created once
commit() is called.
"""
# Overrideable SQL templates
