def _initialize(self, request, *args):
self._change_instance(request)
app_instance = '%s.instance' % conf('config.app')
if self.instance:
request.session[app_instance] = self.instance
instance_name = self.instance
else:
instance_name = request.args.get('instance', None)
if not instance_name:
instance_name = request.session.get(app_instance, None)
if instance_name:
request.session[app_instance] = instance_name
else:
abort(Response(
self._instance_selection(request),
mimetype='text/html')
)
self.instance_name = instance_name
self.instance_config = conf('crud.instances.%s.%s' % (
conf('config.app'),
self.instance_name
))
self._get_database()
self._get_session()
def parse_servers(host_list):
servers = []
for query in host_list:
user = conf("servers.user", None)
port = conf("servers.port", None)
if "@" in query:
user, query = query.split("@", 1)
if ":" in query:
query, port = query.split(":", 1)
if query == "all":
for s, server in conf("servers").iteritems():
servers.append(server_append(server['addr'], user, port))
elif query == "none":
pass
elif query == "local":
servers.append("local") # TODO: this doesn't work
elif "=" in query:
key, val = query.split("=", 1)
for s, server in conf("servers").iteritems():
if server.get(key) == val:
servers.append(server_append(server['addr'], user, port))
if not env.roledefs.get(val):
env.roledefs[val] = []
env.roledefs[val].append(server['addr'])
else:
server = conf("servers").get(query)
if server:
servers.append(server_append(server['addr'], user, port))
return servers
def get(self):
website, controller, action, values = self.routing.get_controller()
if controller:
self.request.website_id = website.website_id
user = self.request.session.get('user')
authorized = not conf(
'werkzeug.use_auth', False) or self.security.authorize(
user=user,
action=action,
website_id=self.request.website_id,
) or action.key == 'auth.login' or action.key == 'auth.logout'
if user is None and not authorized:
return redirect(
'%s%s' %
(website.mount_point, conf('web.login_url'))), None
elif user is not None and not authorized:
raise Error501()
_controller = import_string(controller.python_module)
if inspect.isclass(_controller):
controller_instance = _controller(self.request)
if hasattr(controller_instance, action.python_callable):
controller = getattr(controller_instance,
action.python_callable)
elif inspect.ismodule(_controller):
if hasattr(_controller, action.python_callable):
controller = getattr(_controller, action.python_callable)
return controller, values
def parse_servers(host_list):
servers = []
for query in host_list:
user=conf("servers.user", None)
port=conf("servers.port", None)
if "@" in query:
user, query = query.split("@",1)
if ":" in query:
query, port = query.split(":",1)
if query == "all":
for s, server in conf("servers").iteritems():
servers.append(server_append(server['addr'], user, port))
elif query == "none":
pass
elif query == "local":
servers.append("local") # TODO: this doesn't work
elif "=" in query:
key, val = query.split("=",1)
for s, server in conf("servers").iteritems():
if server.get(key) == val:
servers.append(server_append(server['addr'], user, port))
if not env.roledefs.get(val):
env.roledefs[val] = []
env.roledefs[val].append(server['addr'])
else:
server = conf("servers").get(query)
if server:
servers.append(server_append(server['addr'], user, port))
return servers
def get(self):
website, controller, action, values = self.routing.get_controller()
if controller:
self.request.website_id = website.website_id
user = self.request.session.get("user")
authorized = (
not conf("werkzeug.use_auth", False)
or self.security.authorize(user=user, action=action, website_id=self.request.website_id)
or action.key == "auth.login"
or action.key == "auth.logout"
)
if user is None and not authorized:
return redirect("%s%s" % (website.mount_point, conf("web.login_url"))), None
elif user is not None and not authorized:
raise Error501()
_controller = import_string(controller.python_module)
if inspect.isclass(_controller):
controller_instance = _controller(self.request)
if hasattr(controller_instance, action.python_callable):
controller = getattr(controller_instance, action.python_callable)
elif inspect.ismodule(_controller):
if hasattr(_controller, action.python_callable):
controller = getattr(_controller, action.python_callable)
return controller, values
def __init__(self):
db_server_ip = conf("config.db_server_ip")
db_server_port = conf("config.db_server_port")
self.__connection = Connection(host=db_server_ip, port=db_server_port)
db_name = conf("config.db_name")
self.__db = Database(connection= self.__connection, name=db_name)
def __init__(self):
self.styles = []
self.scripts = []
self.cdn = conf('werkzeug.cdn_url')
self.static = conf('werkzeug.static_url')
self.registerAllStaticScripts()
self.registerAllStaticStyles()
def send_email(_from, to, subject, message_text, message_html=None):
smpp_host = conf('email.host')
smpp_port = conf('email.port')
smpp_user = conf('email.user')
logger.debug('Sending email to SMPP %s@%s:%s',
smpp_user, smpp_host, smpp_port)
logger.debug('Sending email to %s, from %s', to, _from)
logger.debug('Email plain message with subject %s is: %s',
subject, message_text)
msg = MIMEMultipart('alternative')
msg['Subject'] = subject
msg['From'] = _from
msg['To'] = ', '.join(to)
part1 = MIMEText(message_text, 'plain')
msg.attach(part1)
if message_html:
logger.debug('Email html message with subject %s is: %s',
subject, message_html)
part2 = MIMEText(message_html, 'html')
msg.attach(part2)
mailServer = smtplib.SMTP(smpp_host, smpp_port)
mailServer.ehlo()
mailServer.starttls()
mailServer.ehlo()
mailServer.login(smpp_user, conf('email.pass'))
mailServer.sendmail(smpp_user, to, msg.as_string())
mailServer.close()
def __init__(self):
db_server_ip = conf("config.db_server_ip")
db_server_port = conf("config.db_server_port")
self.__client = MongoClient(host=db_server_ip, port=db_server_port)
db_name = conf("config.db_name")
self.__db = self.__client[db_name]
def __init__(self):
self.styles = []
self.scripts = []
self.cdn = conf("werkzeug.cdn_url")
self.static = conf("werkzeug.static_url")
self.registerAllStaticScripts()
self.registerAllStaticStyles()
def _instance_selection(self, request):
flash(request, 'error', 'Seleccione una instancia.')
return Template('crud_instance_selection', {
'instances': conf('crud.instances.%s' % conf('config.app')),
'body_class': 'instance_selection',
'title': conf('config.name'),
'subtitle': 'Seleccion de instancia'
})
def send_email_monitoring(subject, body):
if conf('config.send_monitoring_emails', False):
send_email(
conf('config.monitoring_email_from'),
conf('config.monitoring_recipients'),
subject,
body
)
def end(self, response):
if conf('werkzeug.sessions'):
if self.session.should_save:
session_store.save(self.session)
response.set_cookie(conf('werkzeug.cookie_name'), self.session.sid)
if conf('werkzeug.sa_remove_sessions'):
if sa_sessions:
sa_sessions.remove_all()
def end(self, response):
if conf('werkzeug.sessions'):
if self.session.should_save:
session_store.save(self.session)
response.set_cookie(conf('werkzeug.cookie_name'),
self.session.sid)
if conf('werkzeug.sa_remove_sessions'):
if sa_sessions:
sa_sessions.remove_all()
def __init__(self):
host = conf("mysql.host")
port = conf("mysql.port")
usr = conf("mysql.default_username")
pwd = conf("mysql.default_password")
db = conf("mysql.databases.default")
self.__db = MySQLdb.connect(host="" if host is None else host,
port="" if port is None else port,
user="" if usr is None else usr,
passwd="" if pwd is None else pwd,
db="" if db is None else db)
def __init__(self, environ, populate_request=True, shallow=False):
super(Request, self).__init__(environ, populate_request=True, shallow=False)
if conf('werkzeug.sessions'):
sid = self.cookies.get(conf('werkzeug.cookie_name'))
if sid is None:
self.session = session_store.new()
else:
self.session = session_store.get(sid)
else:
self.session = None
def __init__(self, request, environ):
config = conf("werkzeug")
super(TemplateDefaults, self).__init__(
{
"request": request,
"BASE": "%s%s" % (self.normalize(request.path_info), self.normalize(conf("web.mount"))),
"CDN": self.normalize(config.get("cdn_url")),
"STATIC": conf("werkzeug.static_url"),
"MOUNT": self.normalize(request.environ.get("SCRIPT_NAME") or "/"),
"get_flash_messages": get_flash_messages,
}
)
def __init__(self, environ, populate_request=True, shallow=False):
super(Request, self).__init__(environ,
populate_request=True,
shallow=False)
if conf('werkzeug.sessions'):
sid = self.cookies.get(conf('werkzeug.cookie_name'))
if sid is None:
self.session = session_store.new()
else:
self.session = session_store.get(sid)
else:
self.session = None
def registerStaticStyle(self, id):
styles = conf("layouts.styles")
if styles.get(id):
style = styles.get(id)
style["id"] = id
# self.styles[self.cdn + style.get("path")] = style
self.styles.append({"id": id, "path": self.cdn + style.get("path"), "style": style})
def registerStaticScript(self, id):
scripts = conf("layouts.scripts")
if scripts.get(id):
script = scripts.get(id)
# script["id"] = id
# self.scripts[self.cdn + script.get("path")] = script
self.scripts.append({"id": id, "pos": "HEAD", "path": self.cdn + script.get("path")})
def __init__(self, request, environ):
config = conf('werkzeug')
super(TemplateDefaults, self).__init__({
'request':
request,
'BASE':
'%s%s' % (self.normalize(
request.path_info), self.normalize(conf('web.mount'))),
'CDN':
self.normalize(config.get('cdn_url')),
'STATIC':
conf('werkzeug.static_url'),
'MOUNT':
self.normalize(request.environ.get('SCRIPT_NAME') or '/'),
'get_flash_messages':
get_flash_messages,
})
def register_templates(self):
if configs.get('templates') is None:
configs['templates'] = {}
if configs['templates'].get('directories') is None:
configs['templates']['directories'] = []
app_templates = os.path.join(conf('project_path'), 'templates')
configs['templates']['directories'].append(app_templates)
def registerStaticScript(self, id):
scripts = conf('layouts.scripts')
if scripts.get(id):
script = scripts.get(id)
self.scripts.append({
"id": id,
"pos": "HEAD",
"path": self.cdn + script.get("path")
})
def registerStaticStyle(self, id):
styles = conf('layouts.styles')
if styles.get(id):
style = styles.get(id)
style["id"] = id
self.styles.append({
"id": id,
"path": self.cdn + style.get("path"),
"style": style
})
def __init__(self, request=None):
if not conf('layouts'):
raise Error400("Layouts configuration was not defined.")
self.request = request
self.base = conf('web.mount') or '/'
self.master = conf('layouts.default.master')
self.layout = conf('layouts.default.layout')
self.format = conf('layouts.default.format')
ext = '.' + self.format
self.custom_helpers = conf(
'layouts.default.custom-helpers') + ext if not conf(
'layouts.default.custom-helpers').endswith(ext) else ''
self.login_template = conf('layouts.default.login-template')
self.template_config = conf('layouts.template_config')
self.assets = Assets()
self.languages = conf('lang')
self.lang = None
def __init__(self, request=None):
if not conf("layouts"):
raise Error400("Layouts configuration was not defined.")
self.request = request
self.base = conf("web.mount") or "/"
self.master = conf("layouts.default.master")
self.layout = conf("layouts.default.layout")
self.format = conf("layouts.default.format")
ext = "." + self.format
self.custom_helpers = (
conf("layouts.default.custom-helpers") + ext
if not conf("layouts.default.custom-helpers").endswith(ext)
else ""
)
self.login_template = conf("layouts.default.login-template")
self.template_config = conf("layouts.template_config")
self.assets = Assets()
self.languages = conf("lang")
self.lang = None
def _process_login(self, username, password):
user = None
self.security = Security(conf('werkzeug.security_manager', 'simple'))
website_id = self.request.website_id
if website_id is not None:
user = self.security.authenticate(username=username,
password=password,
website_id=website_id)
if user:
self.request.login(user)
return True
else:
return False
else:
return False
def __init__(self, request, environ):
self.environ = environ
config = conf('werkzeug')
logged_in = None
if hasattr(request, 'logged_in'):
logged_in = request.logged_in
user_role = None
if hasattr(request, 'user_role'):
user_role = request.user_role
mount_point = config.get('mount_point', '/')
if mount_point != '/':
mount_point = '/%s/' % mount_point
port = config.get('port')
host = config.get(
'host') + ':%s' % port if port and port != '80' else ''
base_url = '%s://%s%s' % (config.get('url_scheme'), host, mount_point)
super(TemplateDefaults, self).__init__({
'request':
request,
'current_url':
self._get_current_url,
'base_url':
base_url,
'get_flash_messages':
get_flash_messages,
'logged_in':
logged_in,
'user_role':
user_role,
#'url_for': url_for,
'BASE':
base_url,
'STATIC':
config.get('static_url'),
'CDN':
config.get('cdn_url'),
'user_roles':
request.user_roles
})
def _check_for_layout(self):
try:
layout = conf('layouts.layouts.%s' % self.template_name, False)
except AttributeError:
layout = False
if not layout:
logger.debug('Getting template %s' % self.template_name)
self.template_name = '%s.%s' % (self.template_name, self.config.get('extension'))
return
inherit = layout.get('inherit', '/core/layouts/empty')
self.template_inherit = inherit % {'format': self.template_format}
self.template_sections = layout.get('sections', False)
self.template_name = '/core/layouts/%(format)s/base.%(extension)s' % {
'format': self.template_format,
'extension': self.config.get('extension'),
}
self.template_layout = layout
def run_development_server(app):
from werkzeug.serving import run_simple
extra_files = _get_local_config_files()
extra_files.extend(_get_local_query_files())
extra_files.extend(_get_global_config_files())
extra_files.extend(conf('werkzeug.extra_files_autoreload', []))
run_simple(
app.config.get('host'),
app.config.get('port'),
app,
use_debugger=app.config.get('debug'),
use_evalex=app.config.get('evalex'),
use_reloader=app.config.get('reloader'),
static_files={
app.config.get('static_url'): app.config.get('static_path'),
'/favicon.ico': os.path.join(
app.config.get('static_path'), 'favicon.ico'),
},
extra_files=extra_files,
threaded=False
)
def _check_for_layout(self):
try:
layout = conf('layouts.layouts.%s' % self.template_name, False)
except AttributeError:
layout = False
if not layout:
logger.debug('Getting template %s' % self.template_name)
self.template_name = '%s.%s' % (self.template_name,
self.config.get('extension'))
return
inherit = layout.get('inherit', '/core/layouts/empty')
self.template_inherit = inherit % {'format': self.template_format}
self.template_sections = layout.get('sections', False)
self.template_name = '/core/layouts/%(format)s/base.%(extension)s' % {
'format': self.template_format,
'extension': self.config.get('extension'),
}
self.template_layout = layout
def get(self):
if conf('werkzeug.mount_point') and \
not conf('werkzeug.multiple_mount_points', False):
current_path = '/%s%s' % (conf('werkzeug.mount_point',
''), self.request.path)
else:
current_path = self.request.path
if conf('werkzeug.use_auth')\
and hasattr(self.request, 'logged_in')\
and not self.request.logged_in\
and current_path != conf('werkzeug.login_url'):
return redirect(conf('werkzeug.login_url')), None
return self.routing.controller_from_request(self.request)
def __init__(self, request, environ):
self.environ = environ
config = conf('werkzeug')
logged_in = None
if hasattr(request, 'logged_in'):
logged_in = request.logged_in
user_role = None
if hasattr(request, 'user_role'):
user_role = request.user_role
mount_point = config.get('mount_point', '/')
if mount_point != '/':
mount_point = '/%s/' % mount_point
port = config.get('port')
host = config.get('host') + ':%s' % port if port and port != '80' else ''
base_url = '%s://%s%s' % (
config.get('url_scheme'),
host,
mount_point
)
super(TemplateDefaults, self).__init__({
'request': request,
'current_url': self._get_current_url,
'base_url': base_url,
'get_flash_messages': get_flash_messages,
'logged_in': logged_in,
'user_role': user_role,
#'url_for': url_for,
'BASE': base_url,
'STATIC': config.get('static_url'),
'CDN': config.get('cdn_url'),
'user_roles': request.user_roles
})
def get(self):
if conf('werkzeug.mount_point') and \
not conf('werkzeug.multiple_mount_points', False):
current_path = '/%s%s' % (
conf('werkzeug.mount_point', ''),
self.request.path
)
else:
current_path = self.request.path
if conf('werkzeug.use_auth')\
and hasattr(self.request, 'logged_in')\
and not self.request.logged_in\
and current_path != conf('werkzeug.login_url'):
return redirect(conf('werkzeug.login_url')), None
return self.routing.controller_from_request(self.request)
def _get_website(self):
self.website = Query('core/web/website/by_url_and_mount_point', {
'mount_point': conf('web.mount'),
'url': conf('web.host'),
}).one()
def _get_global_config_files():
return _get_all_files_in_dir(conf('global_config.configs_path'))
import locale
from bson import ObjectId
import datetime
from django.http import HttpResponseRedirect
from django.shortcuts import render, redirect
from django.views.decorators.csrf import csrf_exempt
from im.core.config import conf
import time
from Forms import *
import logging
from django import template
register = template.Library()
watch_folder = conf("config.watch_folder")
@register.simple_tag
def dict_key_lookup(the_dict, key):
return the_dict.get(key, '')
def index(request):
return render(request, "hello.html", dict(test="xxyy"))
@csrf_exempt
def campaign_save(request):
if request.method == "POST":
cdb = ConfigDB()
def registerAllStaticStyles(self):
for id, style in conf('layouts.styles').iteritems():
if style.get("autoload"):
self.registerStaticStyle(id)
def _get_website(self):
self.website = Query('core/web/website/by_url_and_mount_point', {
'mount_point': conf('web.mount'),
'url': conf('web.host'),
}).one()
def unRegisterStaticStyle(self, id):
styles = conf('layouts.styles')
if styles.get(id):
style = styles.get(id)
self.styles[self.cdn + style.get("path")] = None
def unRegisterStaticScript(self, id):
scripts = conf('layouts.scripts')
if scripts.get(id):
script = scripts.get(id)
self.scripts[self.cdn + script.get("path")] = None
def __init__(self, request=None):
if not conf('layouts'):
raise Error400("Layouts configuration was not defined.")
self.request = request
self.base = '%s%s' % (normalize(
conf('web.host')), normalize(conf('web.mount')))
if not conf('web.cdn_url', '/').startswith("http"):
self.cdn = '%s%s' % (self.base, normalize(conf('web.cdn_url',
'/')))
else:
self.cdn = normalize(conf('web.cdn_url'))
if not conf('web.static_url', '/').startswith("http"):
self.static = '%s%s' % (self.base,
normalize(conf('web.static_url', '/')))
else:
self.static = normalize(conf('web.static_url'))
self.host = normalize(conf('web.host', 'http://127.0.0.1'))
self.mount = normalize(conf('web.mount', '/'))
self.master = conf('layouts.default.master')
self.layout = conf('layouts.default.layout')
self.format = conf('layouts.default.format')
ext = '.' + self.format
self.custom_helpers = conf(
'layouts.default.custom-helpers') + ext if not conf(
'layouts.default.custom-helpers').endswith(ext) else ''
self.login_template = conf('layouts.default.login-template')
self.template_config = conf('layouts.template_config')
self.assets = Assets(self.cdn, self.static)
self.languages = conf('lang')
self.lang = None
def __init__(self, environ, request):
self.config = conf('werkzeug')
self.endpoints = {}
self.load()
def __init__(self, request=None):
super(InstanceController, self).__init__(request)
self._url = conf('werkzeug.mount_point', '/')
if self.instance is None:
self.instance = conf('crud.force_instance', None)
def __call__(self, request, *args):
search_term = request.form.get('search', None)
self._initialize(request, *args)
if search_term is not None and hasattr(self.model, 'search'):
search_term = urlparse.unquote(search_term)
self.query = self.model.search(request, self.session, search_term)
filtered = False
if '__extra_filters__' in self.model.__dict__\
and self.model.__extra_filters__:
for filter in self.model.__extra_filters__:
if hasattr(self.model, filter) and filter in request.args:
f = getattr(self.model, filter)
self.query = f(request, self.query)
filtered = True
break
page = request.args.get('page', 1)
per_page = request.args.get('per_page', str(conf('crud.per_page', 10)))
offset = None
pagination = None
total_items = None
if per_page and per_page != 'all':
offset = (int(page) - 1) * int(per_page)
items = self.query
total_items = items.count()
items = items.limit(per_page).offset(offset).all()
pagination = Pagination(int(page), int(per_page), total_items)
else:
items = self.query.all()
columns = self._get_model_columns(items)
foreign_selection = False
if 'foreign_selection' in request.args:
foreign_selection = True
title = self.instance_config['name']
if self.title:
if callable(self.title):
title = self.title(request, *args)
else:
title = self.title
subtitle = 'Listado de %s' % self.model.__verbose_name_plural__
if self.subtitle:
if callable(self.subtitle):
subtitle = self.subtitle(request, *args)
else:
subtitle = self.subtitle
return Template('crud_list', {
'body_class': 'crud_list %s' % self.instance_name,
'title': title,
'subtitle': subtitle,
'items': items,
'columns': columns,
'pagination': pagination,
'toolbar': self.toolbar,
'id': id,
'current_page': int(page),
'per_page': per_page,
'offset': offset,
'total_items': total_items,
'filtered': filtered,
'foreign_selection': foreign_selection,
'base_url': self._url,
'model': self.model,
'search_term': search_term,
'read_only': self.read_only,
})
def __init__(self, environ, request):
self.request = request
self.environ = environ
self.routing = self.routing_class(environ, request)
self.security = self.security_class(
conf('werkzeug.security_manager', 'simple'))
# Django settings for mysite project.
import os, sys, hashlib
from im.core.config import conf
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
import warnings
import MySQLdb
warnings.filterwarnings('ignore', category=MySQLdb.Warning)
DEBUG = conf('web.debug')
TEMPLATE_DEBUG = DEBUG
ADMINS = (
# ('Your Name', '*****@*****.**'),
)
MANAGERS = ADMINS
DATABASES = {}
for key, c in conf('mysql.databases', {}).iteritems():
database = {}
if type(c) is str:
database['NAME'] = c
c = {}
else:
database['NAME'] = c['name'] if c.get('name') else key
database['ENGINE'] = c['engine'] if c.get(
'engine') else "django.db.backends.mysql"
def registerAllStaticScripts(self):
for id, script in conf('layouts.scripts').iteritems():
if script.get("autoload"):
self.registerStaticScript(id)
def __init__(self, name):
db_server_ip = conf("config.db_server_ip")
db_server_port = conf("config.db_server_port")
self.__db_name = "camp{0}".format(name)
self.__connection = Connection(host=db_server_ip, port=db_server_port)
self.__db = Database(connection=self.__connection, name=self.__db_name)
def user_roles(self):
if not conf('werkzeug.use_auth'):
return None
return self.session.get('user_roles')
