363 lines
13 KiB
Python
363 lines
13 KiB
Python
# w.c.s. - web application for online forms
|
|
# Copyright (C) 2005-2010 Entr'ouvert
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import json
|
|
import os
|
|
import random
|
|
import sys
|
|
import traceback
|
|
import zipfile
|
|
|
|
from django.utils import six
|
|
from django.utils.encoding import force_text
|
|
from django.utils.six.moves import cPickle
|
|
|
|
from .Defaults import *
|
|
|
|
try:
|
|
from .wcs_cfg import *
|
|
except ImportError:
|
|
pass
|
|
|
|
from wcs.qommon import force_str
|
|
from .qommon.publisher import set_publisher_class, QommonPublisher, get_request
|
|
|
|
# this is terribly ugly but import RootDirectory will import a bunch of things,
|
|
# and some of them need a publisher to be set
|
|
class StubWcsPublisher(QommonPublisher):
|
|
pass
|
|
set_publisher_class(StubWcsPublisher)
|
|
|
|
|
|
from .root import RootDirectory
|
|
from .backoffice import RootDirectory as BackofficeRootDirectory
|
|
from .admin import RootDirectory as AdminRootDirectory
|
|
from . import sessions
|
|
from .qommon.cron import CronJob
|
|
|
|
from .users import User
|
|
from .tracking_code import TrackingCode
|
|
from .logged_errors import LoggedError
|
|
|
|
import pickle
|
|
|
|
class UnpicklerClass(pickle.Unpickler):
|
|
def find_class(self, module, name):
|
|
if module == 'qommon.form':
|
|
module = 'wcs.qommon.form'
|
|
elif module in ('formdata', 'formdef', 'roles', 'users', 'workflows'):
|
|
module = 'wcs.%s' % module
|
|
__import__(module)
|
|
mod = sys.modules[module]
|
|
klass = getattr(mod, name)
|
|
return klass
|
|
|
|
|
|
class WcsPublisher(StubWcsPublisher):
|
|
APP_NAME = 'wcs'
|
|
APP_DIR = APP_DIR
|
|
DATA_DIR = DATA_DIR
|
|
ERROR_LOG = ERROR_LOG
|
|
USE_LONG_TRACES = USE_LONG_TRACES
|
|
auto_create_appdir = AUTO_CREATE_VHOSTS
|
|
missing_appdir_redirect = REDIRECT_ON_UNKNOWN_VHOST
|
|
|
|
supported_languages = ['fr', 'es', 'de']
|
|
|
|
root_directory_class = RootDirectory
|
|
backoffice_directory_class = BackofficeRootDirectory
|
|
admin_directory_class = AdminRootDirectory
|
|
|
|
session_manager_class = None
|
|
user_class = User
|
|
tracking_code_class = TrackingCode
|
|
unpickler_class = UnpicklerClass
|
|
|
|
@classmethod
|
|
def get_backoffice_module(cls):
|
|
import backoffice
|
|
return backoffice
|
|
|
|
@classmethod
|
|
def get_admin_module(cls):
|
|
import admin
|
|
return admin
|
|
|
|
@classmethod
|
|
def configure(cls, config):
|
|
if config.has_section('extra'):
|
|
for name, directory in config.items('extra'):
|
|
cls.register_extra_dir(directory)
|
|
if config.has_option("main", "app_dir"):
|
|
cls.APP_DIR = config.get("main", "app_dir")
|
|
if config.has_option("main", "data_dir"):
|
|
cls.DATA_DIR = config.get("main", "data_dir")
|
|
if config.has_option("main", "error_log"):
|
|
cls.ERROR_LOG = config.get("main", "error_log")
|
|
if config.has_option("main", "use_long_traces"):
|
|
cls.USE_LONG_TRACES = config.getboolean("main",
|
|
"use_long_traces")
|
|
if config.has_option("main", "auto_create_appdir"):
|
|
cls.auto_create_appdir = config.getboolean("main",
|
|
"auto_create_appdir")
|
|
if config.has_option("main", "missing_appdir_redirect"):
|
|
cls.missing_appdir_redirect = config.get("main",
|
|
"missing_appdir_redirect")
|
|
|
|
@classmethod
|
|
def register_cronjobs(cls):
|
|
super(WcsPublisher, cls).register_cronjobs()
|
|
# every hour: check for global action timeouts
|
|
cls.register_cronjob(CronJob(cls.apply_global_action_timeouts, hourly=True))
|
|
|
|
def is_using_postgresql(self):
|
|
return bool(self.has_site_option('postgresql') and self.cfg.get('postgresql', {}))
|
|
|
|
def set_config(self, request=None, skip_sql=False):
|
|
QommonPublisher.set_config(self, request = request)
|
|
if request:
|
|
request.response.charset = self.site_charset
|
|
|
|
# make sure permissions are set using strings
|
|
if self.cfg.get('admin-permissions'):
|
|
for key in self.cfg['admin-permissions'].keys():
|
|
if not self.cfg['admin-permissions'][key]:
|
|
continue
|
|
self.cfg['admin-permissions'][key] = [str(x) for x in self.cfg['admin-permissions'][key]]
|
|
|
|
import wcs.workflows
|
|
wcs.workflows.load_extra()
|
|
|
|
if self.is_using_postgresql() and not skip_sql:
|
|
from . import sql
|
|
self.user_class = sql.SqlUser
|
|
self.tracking_code_class = sql.TrackingCode
|
|
self.session_class = sql.Session
|
|
sql.get_connection(new=True)
|
|
else:
|
|
self.user_class = User
|
|
self.tracking_code_class = TrackingCode
|
|
self.session_class = sessions.BasicSession
|
|
|
|
self.session_manager_class = sessions.StorageSessionManager
|
|
self.set_session_manager(self.session_manager_class(session_class=self.session_class))
|
|
|
|
def import_zip(self, fd):
|
|
z = zipfile.ZipFile(fd)
|
|
results = {'formdefs': 0, 'carddefs': 0, 'workflows': 0, 'categories': 0, 'roles': 0,
|
|
'settings': 0, 'datasources': 0, 'wscalls': 0}
|
|
|
|
def _decode_list(data):
|
|
rv = []
|
|
for item in data:
|
|
if isinstance(item, six.string_types):
|
|
item = force_str(item)
|
|
elif isinstance(item, list):
|
|
item = _decode_list(item)
|
|
elif isinstance(item, dict):
|
|
item = _decode_dict(item)
|
|
rv.append(item)
|
|
return rv
|
|
|
|
def _decode_dict(data):
|
|
rv = {}
|
|
for key, value in data.items():
|
|
key = force_str(key)
|
|
if isinstance(value, six.string_types):
|
|
value = force_str(value)
|
|
elif isinstance(value, list):
|
|
value = _decode_list(value)
|
|
elif isinstance(value, dict):
|
|
value = _decode_dict(value)
|
|
rv[key] = value
|
|
return rv
|
|
|
|
for f in z.namelist():
|
|
if '.indexes' in f:
|
|
continue
|
|
if os.path.dirname(f) in ('formdefs_xml', 'carddefs_xml', 'workflows_xml'):
|
|
continue
|
|
path = os.path.join(self.app_dir, f)
|
|
if not os.path.exists(os.path.dirname(path)):
|
|
os.mkdir(os.path.dirname(path))
|
|
if not os.path.basename(f):
|
|
# skip directories
|
|
continue
|
|
data = z.read(f)
|
|
if f in ('config.pck', 'config.json'):
|
|
results['settings'] = 1
|
|
if f == 'config.pck':
|
|
d = cPickle.loads(data)
|
|
else:
|
|
d = json.loads(force_text(data), object_hook=_decode_dict)
|
|
if 'sp' in self.cfg:
|
|
current_sp = self.cfg['sp']
|
|
else:
|
|
current_sp = None
|
|
self.cfg = d
|
|
if current_sp:
|
|
self.cfg['sp'] = current_sp
|
|
elif 'sp' in self.cfg:
|
|
del self.cfg['sp']
|
|
self.write_cfg()
|
|
continue
|
|
open(path, 'wb').write(data)
|
|
if os.path.split(f)[0] in results:
|
|
results[os.path.split(f)[0]] += 1
|
|
|
|
# second pass, workflows
|
|
from wcs.workflows import Workflow
|
|
for f in z.namelist():
|
|
if os.path.dirname(f) == 'workflows_xml' and os.path.basename(f):
|
|
workflow = Workflow.import_from_xml(z.open(f), include_id=True)
|
|
workflow.store()
|
|
results['workflows'] += 1
|
|
|
|
# third pass, forms and cards
|
|
from wcs.formdef import FormDef
|
|
from wcs.carddef import CardDef
|
|
formdefs = []
|
|
carddefs = []
|
|
for f in z.namelist():
|
|
if os.path.dirname(f) == 'formdefs_xml' and os.path.basename(f):
|
|
formdef = FormDef.import_from_xml(z.open(f), include_id=True)
|
|
formdef.store()
|
|
formdefs.append(formdef)
|
|
results['formdefs'] += 1
|
|
if os.path.dirname(f) == 'carddefs_xml' and os.path.basename(f):
|
|
carddef = CardDef.import_from_xml(z.open(f), include_id=True)
|
|
carddef.store()
|
|
carddefs.append(carddef)
|
|
results['carddefs'] += 1
|
|
|
|
# rebuild indexes for imported objects
|
|
for k, v in results.items():
|
|
if k == 'settings':
|
|
continue
|
|
if v == 0:
|
|
continue
|
|
klass = None
|
|
if k == 'formdefs':
|
|
from .formdef import FormDef
|
|
klass = FormDef
|
|
elif k == 'carddefs':
|
|
from .carddef import CardDef
|
|
klass = CardDef
|
|
elif k == 'categories':
|
|
from .categories import Category
|
|
klass = Category
|
|
elif k == 'roles':
|
|
from .roles import Role
|
|
klass = Role
|
|
elif k == 'workflows':
|
|
from wcs.workflows import Workflow
|
|
klass = Workflow
|
|
if klass:
|
|
klass.rebuild_indexes()
|
|
|
|
if k == 'formdefs':
|
|
# in case of formdefs, we store them anew in case SQL changes
|
|
# are required.
|
|
for formdef in (formdefs or FormDef.select()):
|
|
formdef.store()
|
|
elif k == 'carddefs':
|
|
# ditto for cards
|
|
for carddef in (carddefs or CardDef.select()):
|
|
carddef.store()
|
|
|
|
z.close()
|
|
return results
|
|
|
|
def get_object_visitors(self, object_key):
|
|
session_manager = self.session_manager_class(session_class=self.session_class)
|
|
return session_manager.session_class.get_object_visitors(object_key)
|
|
|
|
def get_visited_objects(self, exclude_user=None):
|
|
session_manager = self.session_manager_class(session_class=self.session_class)
|
|
return session_manager.session_class.get_visited_objects(
|
|
exclude_user=exclude_user)
|
|
|
|
def initialize_sql(self):
|
|
from . import sql
|
|
sql.get_connection(new=True)
|
|
sql.do_session_table()
|
|
sql.do_user_table()
|
|
sql.do_tracking_code_table()
|
|
sql.do_meta_table()
|
|
from .formdef import FormDef
|
|
from .carddef import CardDef
|
|
conn, cur = sql.get_connection_and_cursor()
|
|
sql.drop_views(None, conn, cur)
|
|
for formdef in FormDef.select() + CardDef.select():
|
|
sql.do_formdef_tables(formdef)
|
|
sql.migrate_global_views(conn, cur)
|
|
conn.commit()
|
|
cur.close()
|
|
|
|
def notify_of_exception(self, exc_tuple, context=None):
|
|
exc_type, exc_value, tb = exc_tuple
|
|
error_summary = traceback.format_exception_only(exc_type, exc_value)
|
|
error_summary = error_summary[0][0:-1] # de-listify and strip newline
|
|
if context:
|
|
error_summary = '%s %s' % (context, error_summary)
|
|
|
|
plain_error_msg = str(self._generate_plaintext_error(
|
|
get_request(),
|
|
self,
|
|
exc_type, exc_value,
|
|
tb))
|
|
|
|
self.log_internal_error(error_summary, plain_error_msg, record=True)
|
|
|
|
def log_internal_error(self, error_summary, plain_error_msg, record=False):
|
|
tech_id = None
|
|
if record:
|
|
logged_exception = LoggedError.record_exception(
|
|
error_summary, plain_error_msg, publisher=self)
|
|
if logged_exception:
|
|
tech_id = logged_exception.tech_id
|
|
try:
|
|
self.logger.log_internal_error(error_summary, plain_error_msg, tech_id)
|
|
except socket.error:
|
|
# will happen if there is no mail server available and exceptions
|
|
# were configured to be mailed.
|
|
pass
|
|
except OSError:
|
|
# this could happen on file descriptor exhaustion
|
|
pass
|
|
|
|
def apply_global_action_timeouts(self):
|
|
from wcs.workflows import Workflow, WorkflowGlobalActionTimeoutTrigger
|
|
for workflow in Workflow.select():
|
|
WorkflowGlobalActionTimeoutTrigger.apply(workflow)
|
|
|
|
def migrate_sql(self):
|
|
from . import sql
|
|
sql.migrate()
|
|
|
|
def reindex_sql(self):
|
|
from . import sql
|
|
sql.reindex()
|
|
|
|
def cleanup(self):
|
|
if self.is_using_postgresql():
|
|
from . import sql
|
|
sql.cleanup_connection()
|
|
|
|
set_publisher_class(WcsPublisher)
|
|
WcsPublisher.register_extra_dir(os.path.join(os.path.dirname(__file__), 'extra'))
|
|
|