def smooch_events():
"""
the firehose of events that the webhooks subscribed to,
this will send all messages from people who visit your website
to this endmpoint, the robot then parses those messages and
does a postback of its response.
"""
# this is actually everything people say to the robot, may be good
# to send this to a log file or database
# print json.dumps(request.json)
# get the singletons
smooch_api = LocalProxy(get_smooch_api)
robot = LocalProxy(get_robot)
for message in request.json['messages']:
response = robot.query(message['text'])
if 'status' in response and response['status'][
'errorType'] == 'success' and 'result' in response and 'fulfillment' in response[
'result'] and 'speech' in response['result']['fulfillment']:
smooch_api.postback_message(
response['result']['fulfillment']['speech'],
message['authorId'])
data = {'message': 'succeed'}
resp = Response(json.dumps(data), status=200, mimetype='application/json')
return resp
class WebSite:
def __init__(self, application, site_load=True):
self._application = application
self._config = self._application.config_xml
self._database = LocalProxy(self._application.database.context_get)
self._sql = None
if site_load:
self._id = int(self._config.get("web", "", "site_id", "-1"))
self._title = "Undefined"
self._description = "Undefined"
self._url = "Undefined"
self._is_loaded = False
self._is_enable = True
self._is_secure = False
self._is_devel = True
self._meta_title = "Undefined"
self._meta_description = "Undefined"
self._meta_autor = "Undefined"
self._meta_autor_url = "Undefined"
self._meta_description = "Undefined"
self._meta_keywords = "Undefined"
self._meta_copyrights = "Undefined"
self._pages = []
if site_load:
self.load()
def load(self, db_site=None):
from Scopuli.Interfaces.MySQL.Schema.Web.Core import WebSite as dbWebSite
if db_site is None:
query = self._database.query(dbWebSite)
query = query.filter(dbWebSite.id == self._id)
self._sql = query.first()
else:
self._sql = db_site
if self._sql:
self._id = self._sql.id
self._title = self._sql.title
self._description = self._sql.description
self._url = self._sql.url
self._is_loaded = True
self._is_enable = self._sql.is_enable
self._is_secure = self._sql.is_secure
self._is_devel = self._sql.is_devel
self._meta_title = self._sql.meta_title
self._meta_description = self._sql.meta_description
self._meta_autor = self._sql.meta_autor
self._meta_autor_url = self._sql.meta_autor_url
self._meta_keywords = self._sql.meta_autor_url
self._meta_copyrights = self._sql.meta_copyrights
for db_page in self._sql.pages:
self._pages.append(
WebPage(application=self._application,
page_id=db_page.id,
page_load=False).load(db_page=db_page))
return self
@property
def application(self):
"""
Свойство возвращающее текущее приложение.
:return: Загруженный обьект :ref:`module-web-application`
:rtype: :ref:`module-web-application`
"""
return self._application
@property
def config(self):
"""
Свойство возвращающее текущий конфиг.
:return: Загруженный обьект :ref:`module-interfaces-config`
:rtype: :ref:`module-interfaces-config`
"""
return self._config
@property
def id(self):
return self._id
@property
def title(self):
return self._title
@property
def description(self):
return self._description
@property
def url(self):
return self._url
@property
def url_prefix(self):
if self._is_secure:
return "https://"
else:
return "http://"
@property
def meta_autor(self):
return self._meta_autor
@property
def meta_autor_url(self):
return self._meta_autor_url
@property
def meta_title(self):
return self._meta_title
@property
def meta_description(self):
return self._meta_description
@property
def meta_keywords(self):
return self._meta_keywords
@property
def meta_copyrights(self):
return self._meta_copyrights
@property
def is_loaded(self):
return self._is_loaded
@property
def is_enable(self):
return self._is_enable
@property
def is_secure(self):
return self._is_secure
@property
def is_devel(self):
return self._is_devel
@property
def pages(self):
return self._pages
def __repr__(self):
return u"<{} id:'{}' is_enable:'{}' is_secure:'{}' url:'{}' title:'{}' description:'{}' />".format(
str(self.__class__), self._id, self._is_enable, self._is_secure,
self._url, self._title, self._description)
# father = Parent(name="LiLei")
# mother = Parent(name="HanMeimei")
# teacher = Teacher(name="Jim")
# proxy_session.add(father)
# proxy_session.add(mother)
# for n in range(20):
# c = Child(name="LiXiaolei-{}".format(n))
# proxy_session.add(c)
# father.children.append(c)
# mother.children.append(c)
# if n < 10:
# teacher.children.append(c)
# proxy_session.commit()
parent = proxy_session.query(Parent).all()[0]
print(parent.name)
print('hybrid_property: ', parent.children_count)
print(parent.children.count())
children = proxy_session.query(Child).all()
child = children[0]
print(child.name)
print(child.parents)
print(child.teachers)
child = children[-1]
print(child.teachers)
proxy_session.delete(child)
proxy_session.commit()
class WebModule:
#: Уникальное имя модуля
_instance_name = "Module"
#: Уникальный префикс фильтров модуля
_instance_filter = "_4g_module_filter"
#: Имя ноды в конфиге
_instance_config = "module-dummy"
#: Путь до шаблона
_template_name = "/dummy/module.html"
#: Контекс
_context = {}
#: Список маршрутов обрабатываемых модулем
_routes = {}
#: HTTP Return Code
_http_code = 200
#: Перечень зависимостей
_dependency = []
def __init__(self, application, page=None):
self._application = application
self._page = page
self._site = self._application.site
self._config = self._application.config_xml
self._database = LocalProxy(self._application.database.request_get)
self._form = WebUtils.WebForm(self._application)
self.load()
@property
def template_name(self):
"""
Свойство возвращающее название шаблона.
:return: Название шаблона
:rtype: String
"""
return self._template_name
@property
def application(self):
"""
Свойство возвращающее текущее приложение.
:return: Загруженный обьект :ref:`module-web-application`
:rtype: :ref:`module-web-application`
"""
return self._application
@property
def config(self):
"""
Свойство возвращающее текущий конфиг.
:return: Загруженный обьект :ref:`module-interfaces-config`
:rtype: :ref:`module-interfaces-config`
"""
return self._config
def load(self):
pass
def render(self, caller=None):
if self._page:
return self._application.render(self._page.template_name,
self._page,
self._page.module,
http_code=self._http_code)
else:
return self._application.render(self._template_name,
self._context,
self,
http_code=self._http_code)
def render_json(self, json_object, caller=None):
if self._page:
return self._application.render_json(json_object,
self._page,
self._page.module,
http_code=self._http_code)
else:
return self._application.render_json(json_object,
self._context,
self,
http_code=self._http_code)
def register_routes(self):
for route in self._routes.keys():
route_func_name = self._routes[route]
route_func = getattr(self, route_func_name)
self._application.add_url_rule(route,
'{}{}'.format(
str(route).replace("/", "_"),
route_func_name),
route_func,
methods=['GET', 'POST'])
def register(self):
self._application.module_register(self._instance_name, self)
self.register_routes()
@property
def module_name(self):
return self._instance_name.replace("/", "")
@staticmethod
def module_load(page):
#module_list = page.application._config.get("web", "application", "module_list", "Scopuli.WEB.Application.Modules")
module = getattr(import_module("ApplicationModules"), page.code)
if module:
return module(page.application, page)
return None
def make_url(self, module_name, module_value, module_prefix="/"):
from Scopuli.Interfaces.MySQL.Schema.Web.Core import WebPage as dbWebPage
query = self._database.query(dbWebPage)
query = query.filter(dbWebPage.cd_web_site == self._site.id)
query = query.filter(dbWebPage.is_enable == 1)
query = query.filter(dbWebPage.code == module_name)
for module in query.all():
return "{}{}{}".format(module.url, module_prefix, module_value)
def callback_render(self, template, web_page, web_module):
pass
@property
def sitemap_links(self):
"""
Функция возвращает список ссылок для карты сайта
:return: Массив ссылок для карты сайта
:rtype: Array of String
"""
return []
@property
def robots_disallow(self):
"""
Функция возвращает список запрещенных ссылок для индексирования в robots.txt
:return: Массив запрещенных ссылок для robots.txt
:rtype: Array of String
"""
return []
@property
def robots_allow(self):
"""
Функция возвращает список разрешенный ссылок для индексирования в robots.txt
:return: Массив разрещенных ссылок для robots.txt
:rtype: Array of String
"""
return []
def __repr__(self):
return u"<{} template:'{}' instance:'{}' />".format(
str(self.__class__), self._template_name, self._instance_name)
class WebPage:
def __init__(self, application, page_id, page_load=True):
self._application = application
self._config = self._application.config_xml
self._database = LocalProxy(self._application.database.context_get)
self._sql = None
self._module = None
self._id = page_id
self._cd_parent = "Undefined"
self._code = "Undefined"
self._title = "Undefined"
self._description = "Undefined"
self._url = "Undefined"
self._url_title = "Undefined"
self._url_title_short = "Undefined"
self._url_discription = "Undefined"
self._url_discription_short = "Undefined"
self._is_enable = False
self._is_loaded = False
self._template_name = "Undefined"
self._meta_title = "Undefined"
self._meta_description = "Undefined"
self._meta_autor = "Undefined"
self._meta_autor_url = "Undefined"
self._meta_keywords = "Undefined"
self._date_create = datetime.today()
self._date_change = datetime.today()
if page_load:
self.load()
def load(self, db_page=None):
from Scopuli.Interfaces.MySQL.Schema.Web.Core import WebPage as dbWebPage
if db_page is None:
query = self._database.query(dbWebPage)
query = query.filter(dbWebPage.id == self._id)
self._sql = query.first()
else:
self._sql = db_page
if self._sql:
self._cd_parent = self._sql.cd_parent
self._code = self._sql.code
self._title = self._sql.title
self._description = self._sql.description
self._url = self._sql.url
self._url_title = self._sql.url_title
self._url_title_short = self._sql.url_title_short
self._url_description = self._sql.url_description
self._url_description_short = self._sql.url_description_short
self._is_enable = self._sql.is_enable
self._is_loaded = True
self._template_name = self._sql.template_name
self._meta_title = self._sql.meta_title
self._meta_description = self._sql.meta_description
self._meta_autor = self._sql.meta_autor
self._meta_autor_url = self._sql.meta_autor_url
self._meta_keywords = self._sql.meta_autor_url
self._date_create = self._sql.date_create
self._date_change = self._sql.date_change
return self
@property
def application(self):
"""
Свойство возвращающее текущее приложение.
:return: Загруженный обьект :ref:`module-web-application`
:rtype: :ref:`module-web-application`
"""
return self._application
@property
def config(self):
"""
Свойство возвращающее текущий конфиг.
:return: Загруженный обьект :ref:`module-interfaces-config`
:rtype: :ref:`module-interfaces-config`
"""
return self._config
@property
def id(self):
return self._id
@property
def cd_parent(self):
return self._cd_parent
@property
def code(self):
return self._code
@property
def title(self):
return self._title
@property
def description(self):
return self._description
@property
def url(self):
return self._url
@property
def url_title(self, short=False):
if short:
if len(self._url_title_short) != 0:
return self._url_title_short
return self._url_title
@property
def url_description(self, short=False):
if short:
if len(self._url_description_short) != 0:
return self._url_description_short
return self._url_description
@property
def is_enable(self):
return self._is_enable
@property
def is_loaded(self):
if self._is_loaded and self._module:
return True
return False
@property
def meta_autor(self):
return self._meta_autor
@property
def meta_autor_url(self):
return self._meta_autor_url
@property
def meta_title(self):
return self._meta_title
@property
def meta_description(self):
return self._meta_description
@property
def meta_keywords(self):
return self._meta_keywords
@property
def date_create(self):
return self._date_create
@property
def date_change(self):
return self._date_change
@property
def robots_disallow(self):
if self._module:
if hasattr(self._module, "robots_disallow"):
return self._module.robots_disallow
return []
@property
def robots_allow(self):
if self._module:
if hasattr(self._module, "robots_allow"):
return self._module.robots_allow
return []
@property
def sitemap_links(self):
if self._module:
if hasattr(self._module, "sitemap_links"):
return self._module.sitemap_links
return []
@property
def module(self):
if not self._module:
self._module = WebModule.module_load(self)
return self._module
@property
def template_name(self):
if len(self._template_name) != 0:
return self._template_name
if self._module:
return self._module.template_name
return "dummy/module.html"
def __repr__(self):
return u"<{} id:'{}' parent:'{}' is_enable:'{}' code:'{}' url:'' template:'{}' />".format(
str(self.__class__), self._id, self._cd_parent, self._is_enable,
self._code, self._url, self._template_name)
proxy_session.add(model)
proxy_session.commit()
@event.listens_for(Teacher, "after_update")
def teacher_modify(mapper, connection, target):
state = inspect(target)
chanages = {}
for attr in state.attrs:
print(attr.key)
hist = state.get_history(attr.key, True)
print(hist.has_changes())
if not hist.has_changes():
continue
print(dir(hist))
chanages[attr.key] = hist.added
print(chanages)
print(target.id, target.name, target.age, target.mobile)
@event.listens_for(Teacher, "after_bulk_delete")
def teacher_remove(mapper, connection, target):
print(target.id, target.name, target.age, target.mobile)
# teacher = proxy_session.query(Teacher).all()[0]
proxy_session.query(Teacher).filter_by(name="Lucy").delete()
proxy_session.commit()
