id
int64 0
458k
| file_name
stringlengths 4
119
| file_path
stringlengths 14
227
| content
stringlengths 24
9.96M
| size
int64 24
9.96M
| language
stringclasses 1
value | extension
stringclasses 14
values | total_lines
int64 1
219k
| avg_line_length
float64 2.52
4.63M
| max_line_length
int64 5
9.91M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 7
101
| repo_stars
int64 100
139k
| repo_forks
int64 0
26.4k
| repo_open_issues
int64 0
2.27k
| repo_license
stringclasses 12
values | repo_extraction_date
stringclasses 433
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
9,700
|
main.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/main.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2023, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# ConcurrentLogHandler - updates stlidb's logging config on import so this needs to stay
try:
import cloghandler # type: ignore
except ImportError:
pass
else:
cloghandler = cloghandler # For pyflakes
# stdlib
import logging
import os
# MySQL
try:
import pymysql
pymysql.install_as_MySQLdb()
except ImportError:
pass
# Django
import django
from django.core.management import call_command, execute_from_command_line
# Zato
from zato.admin.zato_settings import update_globals
from zato.common.json_internal import loads
from zato.common.repo import RepoManager
from zato.common.util.api import store_pidfile
from zato.common.util.open_ import open_r
# ################################################################################################################################
# ################################################################################################################################
logging.basicConfig(
level=logging.INFO, format='%(asctime)s - %(levelname)s - %(process)d:%(threadName)s - %(name)s:%(lineno)d - %(message)s')
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
# Currently, this is not needed.
needs_migrate = True
# ################################################################################################################################
# ################################################################################################################################
def update_password(base_dir:'str') -> 'None':
# stdlib
import sys # type: ignore
from json import loads
# Obtain a full path to an optional file with credentials
file_dir = os.path.join(base_dir, '..')
file_dir = os.path.abspath(file_dir)
file_path = os.path.join(file_dir, 'env.json')
# First, ensure that the optional file with credentials exists at all
if not os.path.exists(file_path):
return
# .. extract the underlying details ..
data = open(file_path).read()
data = loads(data)
password = data.get('dashboard_password')
# .. make sure we have a password for the user ..
if not password:
return
# At this point, we have all the information required to change the password
# Build a full path to the main Zato command
bin_dir = os.path.dirname(sys.executable)
zato_cmd = os.path.join(bin_dir, 'zato')
# .. build the command to use ..
command = f'{zato_cmd} update password {base_dir} admin --password {password}'
# .. and do run it.
_ = os.system(command)
# ################################################################################################################################
# ################################################################################################################################
def main():
# stdlib
import sys
# Zato
from zato.common.util.api import parse_cmd_line_options
from zato.common.util.env import populate_environment_from_file
cmd_line_options = sys.argv[1]
cmd_line_options = parse_cmd_line_options(cmd_line_options)
env_file = cmd_line_options.get('env_file') or ''
populate_environment_from_file(env_file)
env_dir = os.environ.get('ZATO_DASHBOARD_BASE_DIR')
base_dir = env_dir or '.'
base_dir_abs = os.path.abspath(base_dir)
store_pidfile(base_dir_abs)
repo_dir = os.path.join(base_dir, 'config', 'repo')
# Update Django settings
config = loads(open_r(os.path.join(repo_dir, 'web-admin.conf')).read())
config['config_dir'] = base_dir_abs
if env_dir:
log_config = config['log_config']
log_config = os.path.join(env_dir, log_config)
config['log_config'] = log_config
# Load our configuration for Django
update_globals(config)
# Initialize Django
os.environ['DJANGO_SETTINGS_MODULE'] = 'zato.admin.settings'
django.setup()
# Optionally, reset the admin user's password
try:
update_password(base_dir_abs)
except Exception as e:
logger.info('Exception caught: %s', e)
# Optionally, run internal Django migrations
if needs_migrate:
_ = call_command('migrate', verbosity=999, fake=True)
# Load our initial data
_ = call_command('loaddata', os.path.join(repo_dir, 'initial-data.json'))
RepoManager(repo_dir).ensure_repo_consistency()
execute_from_command_line([
'zato-web-admin',
'runserver',
'--noreload',
'--nothreading',
'--skip-checks',
'{host}:{port}'.format(**config)
])
# ################################################################################################################################
# ################################################################################################################################
if __name__ == '__main__':
_ = main()
# ################################################################################################################################
# ################################################################################################################################
| 5,523
|
Python
|
.py
| 121
| 41.247934
| 130
| 0.484605
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,701
|
models.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/models.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# Django
from django.db import models
from django.contrib.auth.models import User
# Zato
from zato.admin.web import DATE_FORMATS, MONTH_YEAR_FORMATS, TIME_FORMATS
from zato.common.json_internal import loads
# Not used in practice
def _on_delete(*unused_args, **unused_kwargs):
pass
class TOTPData:
def __init__(self):
self.key = None
self.label = None
class UserProfile(models.Model):
class Meta:
db_table = 'user_profile'
user = models.OneToOneField(User, on_delete=_on_delete)
timezone = models.CharField(max_length=100, null=True, default='UTC')
date_format = models.CharField(max_length=100, null=True, default='dd-mm-yyyy')
time_format = models.CharField(max_length=10, null=True, default='24')
opaque1 = models.TextField(null=True)
def __init__(self, *args, **kwargs):
super(UserProfile, self).__init__(*args, **kwargs)
self.date_format_py = DATE_FORMATS[self.date_format]
self.time_format_py = TIME_FORMATS[self.time_format]
self.month_year_format_py = MONTH_YEAR_FORMATS[self.date_format]
self.month_year_format_strptime = self.month_year_format_py.replace('m', '%m').replace('y', '%y').replace('Y', '%Y')
self.year_format_py = 'Y'
self.date_time_format_py = '{} {}'.format(self.date_format_py, self.time_format_py)
def __repr__(self):
return '<{} at {} user:[{}] timezone:[{}] date_format_py:[{}] time_format_py:[{}] month_year_format_py:[{}] date_time_format_py:[{}]>'.format(
self.__class__.__name__, hex(id(self)), self.user, self.timezone, self.date_format_py,
self.time_format_py, self.month_year_format_py, self.date_time_format_py)
__unicode__ = __repr__
def get_totp_data(self):
totp_data = TOTPData()
if self.opaque1:
opaque = loads(self.opaque1)
totp_data.key = opaque.get('totp_key')
totp_data.label = opaque.get('totp_label')
return totp_data
class ClusterColorMarker(models.Model):
class Meta:
db_table = 'cluster_color_marker'
user_profile = models.ForeignKey(UserProfile, on_delete=_on_delete, related_name='cluster_color_markers')
cluster_id = models.IntegerField()
color = models.CharField(max_length=6) # RGB
def __repr__(self):
return '<{} at {} user_profile:[{}] cluster_id:[{}] color:[{}]>'.format(
self.__class__.__name__, hex(id(self)), self.user_profile, self.cluster_id, self.color)
__unicode__ = __repr__
| 2,766
|
Python
|
.py
| 57
| 42.421053
| 150
| 0.654647
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,702
|
util.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/util.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2024, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import mimetypes
import posixpath
from logging import getLogger
from pathlib import Path
# Django
from django.http import FileResponse, Http404, HttpResponseNotModified
from django.template.response import TemplateResponse
from django.utils._os import safe_join
from django.utils.http import http_date, parse_http_date
# Zato
from zato.common.crypto.api import CryptoManager
from zato.common.json_internal import loads
from zato.common.util.platform_ import is_windows
# ################################################################################################################################
# ################################################################################################################################
logger = getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
windows_disabled = [
'jms-wmq',
'sftp'
]
# ################################################################################################################################
# ################################################################################################################################
def get_template_response(req, template_name, return_data):
if is_windows:
for name in windows_disabled:
if name in template_name:
return_data['is_disabled'] = True
return_data['disabled_template_name'] = template_name
return TemplateResponse(req, template_name, return_data)
# ################################################################################################################################
# ################################################################################################################################
def get_user_profile(user, needs_logging=True):
if needs_logging:
logger.info('Getting profile for user `%s`', user)
from zato.admin.web.models import UserProfile
try:
user_profile = UserProfile.objects.get(user=user)
if needs_logging:
logger.info('Found an existing profile for user `%s`', user)
except UserProfile.DoesNotExist:
if needs_logging:
logger.info('Did not find an existing profile for user `%s`', user)
user_profile = UserProfile(user=user)
user_profile.save()
if needs_logging:
logger.info('Created a profile for user `%s`', user)
finally:
if needs_logging:
logger.info('Returning a user profile for `%s`', user)
return user_profile
# ################################################################################################################################
# ################################################################################################################################
def set_user_profile_totp_key(user_profile, zato_secret_key, totp_key, totp_key_label=None, opaque_attrs=None):
if not opaque_attrs:
opaque_attrs = user_profile.opaque1
opaque_attrs = loads(opaque_attrs) if opaque_attrs else {}
cm = CryptoManager(secret_key=zato_secret_key)
# TOTP key is always encrypted
totp_key = cm.encrypt(totp_key.encode('utf8'))
opaque_attrs['totp_key'] = totp_key
# .. and so is its label
if totp_key_label:
totp_key_label = cm.encrypt(totp_key_label.encode('utf8'))
opaque_attrs['totp_key_label'] = totp_key_label
return opaque_attrs
# ################################################################################################################################
# ################################################################################################################################
#
# Taken from Django to change the content type from application/json to application/javascript.
#
def static_serve(request, path, document_root=None, show_indexes=False):
"""
Serve static files below a given point in the directory structure.
To use, put a URL pattern such as::
from django.views.static import serve
path('<path:path>', serve, {'document_root': '/path/to/my/files/'})
in your URLconf. You must provide the ``document_root`` param. You may
also set ``show_indexes`` to ``True`` if you'd like to serve a basic index
of the directory. This index view will use the template hardcoded below,
but if you'd like to override it, you can create a template called
``static/directory_index.html``.
"""
path = posixpath.normpath(path).lstrip("/")
fullpath = Path(safe_join(document_root, path))
if fullpath.is_dir():
if show_indexes:
return directory_index(path, fullpath)
raise Http404(_("Directory indexes are not allowed here."))
if not fullpath.exists():
raise Http404(_("“%(path)s” does not exist") % {"path": fullpath})
# Respect the If-Modified-Since header.
statobj = fullpath.stat()
if not was_modified_since(
request.META.get("HTTP_IF_MODIFIED_SINCE"), statobj.st_mtime
):
return HttpResponseNotModified()
content_type, encoding = mimetypes.guess_type(str(fullpath))
content_type = content_type or "application/octet-stream"
# Explicitly set the content type for JSON resources.
# Note that this needs to be combined with SECURE_CONTENT_TYPE_NOSNIFF=False in settings.py
if fullpath.name.endswith('.js'):
content_type = 'application/javascript'
response = FileResponse(fullpath.open("rb"), content_type=content_type)
response.headers["Last-Modified"] = http_date(statobj.st_mtime)
if encoding:
response.headers["Content-Encoding"] = encoding
return response
def was_modified_since(header=None, mtime=0):
"""
Was something modified since the user last downloaded it?
header
This is the value of the If-Modified-Since header. If this is None,
I'll just return True.
mtime
This is the modification time of the item we're talking about.
"""
try:
if header is None:
raise ValueError
header_mtime = parse_http_date(header)
if int(mtime) > header_mtime:
raise ValueError
except (ValueError, OverflowError):
return True
return False
# ################################################################################################################################
# ################################################################################################################################
| 6,871
|
Python
|
.py
| 135
| 45.37037
| 130
| 0.504259
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,703
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# dateutil
from dateutil.relativedelta import relativedelta
# Django
from django.template.defaultfilters import date as django_date_filter
# Zato
from zato.common.api import INVOCATION_TARGET
from zato.common.util.api import from_local_to_utc as _from_local_to_utc, from_utc_to_local as _from_utc_to_local
logger = logging.getLogger(__name__)
class _Format:
def __init__(self, frontend, python):
self.frontend = frontend
self.python = python
DATE_FORMATS = {
'dd/mm/yyyy': 'd/m/Y',
'dd/mm/yy': 'd/m/y',
'dd-mm-yyyy': 'd-m-Y',
'dd.mm.yyyy': 'd.m.Y',
'dd.mm.yy': 'd.m.y',
'mm-dd-yy': 'm-d-y',
'mm-dd-yyyy': 'm-d-Y',
'yyyy/mm/dd': 'Y/m/d',
'yyyy-mm-dd': 'Y-m-d',
'yyyy.mm.dd': 'Y.m.d',
}
MONTH_YEAR_FORMATS = {
'dd/mm/yyyy': 'm/y',
'dd/mm/yy': 'm/Y',
'dd-mm-yyyy': 'm-Y',
'dd.mm.yyyy': 'm.Y',
'dd.mm.yy': 'm.y',
'mm-dd-yy': 'm-y',
'mm-dd-yyyy': 'm-Y',
'yyyy/mm/dd': 'Y/m',
'yyyy-mm-dd': 'Y-m',
'yyyy.mm.dd': 'Y.m',
}
TIME_FORMATS = {
'12': 'g:i.s A',
'24': 'H:i:s',
}
TARGET_TYPE_HUMAN = {
INVOCATION_TARGET.CHANNEL_AMQP: 'AMQP channel',
INVOCATION_TARGET.CHANNEL_WMQ: 'IBM MQ channel',
INVOCATION_TARGET.CHANNEL_ZMQ: 'ZeroMQ channel',
INVOCATION_TARGET.OUTCONN_AMQP: 'AMQP outgoing connection',
INVOCATION_TARGET.OUTCONN_WMQ: 'IBM MQ outgoing connection',
INVOCATION_TARGET.OUTCONN_ZMQ: 'ZeroMQ outgoing connection',
INVOCATION_TARGET.SERVICE: 'Service',
}
def last_hour_start_stop(now):
""" Returns an ISO-8601 formatted pair of start/stop timestamps representing
now-1 hour and now.
"""
return (now + relativedelta(minutes=-60)).isoformat(), now.isoformat()
def from_utc_to_user(dt, user_profile, format='date_time'):
""" Converts a datetime object from UTC to a user-selected timezone and datetime format.
"""
return django_date_filter(
_from_utc_to_local(dt, user_profile.timezone), getattr(user_profile, '{}_format_py'.format(format)))
def from_user_to_utc(dt, user_profile, format='date_time'):
""" Converts a datetime object from a user-selected timezone to UTC.
"""
# The underlying parser gets confused by stuff like '15.08.12 9:56.59 PM',
# that is, where the seconds separator (.) is different from what separates hours from minutes,
# so we need replace the dot with semicolon in order to make the parser happy.
if user_profile.time_format == '12':
# Reverse the string, replace the first occurence of . with a : and reverse it back
dt = dt[::-1].replace('.', ':', 1)[::-1]
if format == 'year':
dt = '01-01-' + dt
dt_format = getattr(user_profile, '{}_format_py'.format(format))
return _from_local_to_utc(dt, user_profile.timezone, dt_format.startswith('d')).replace(tzinfo=None)
| 3,099
|
Python
|
.py
| 80
| 34.6125
| 113
| 0.65878
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,704
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/templatetags/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,705
|
extras.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/templatetags/extras.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import os
# Django
from django import template
from django.utils.safestring import mark_safe
# ################################################################################################################################
register = template.Library()
# ################################################################################################################################
# Taken from https://djangosnippets.org/snippets/38/ and slightly updated
@register.filter
def bunchget(obj, args):
""" Try to get an attribute from an object.
Example: {% if block|bunchget:"editable,True" %}
Beware that the default is always a string, if you want this
to return False, pass an empty second argument:
{% if block|bunchget:"editable," %}
"""
args = str(args).split(',')
if len(args) == 1:
(attribute, default) = [args[0], '']
else:
(attribute, default) = args
if attribute in obj:
return obj[attribute]
return default
# ################################################################################################################################
# Taken from https://stackoverflow.com/a/16609498
@register.simple_tag
def url_replace(request, field, value):
dict_ = request.GET.copy()
dict_[field] = value
return dict_.urlencode()
# ################################################################################################################################
@register.filter
def no_value_indicator(value):
return value or mark_safe('<span class="form_hint">---</span>')
# ################################################################################################################################
@register.filter
def format_float(value, digits=5):
if not value:
return 0
value = str(value)
as_float = float(value)
as_int = int(as_float)
if as_int == as_float:
result = as_int
else:
result = round(as_float, digits)
result = str(result)
return result
# ################################################################################################################################
@register.filter
def stats_float(value):
return value if value else '< 0.01'
# ################################################################################################################################
@register.filter
def get_item(elems, idx):
try:
value = elems[idx]
return value
except Exception:
return None
# ################################################################################################################################
@register.filter
def endswith(value, suffix):
if value and suffix:
return value.endswith(suffix)
# ################################################################################################################################
@register.filter
def get_os_variable(_ignored, name):
return os.environ.get(name)
# ################################################################################################################################
@register.filter
def replace_in_string(item, config):
config = config.strip()
config = config.split(',')
config = [elem.strip() for elem in config]
old_value, new_value = config
return item.replace(old_value, new_value)
# ################################################################################################################################
| 3,638
|
Python
|
.py
| 85
| 38.870588
| 130
| 0.405859
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,706
|
0001_initial.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/migrations/0001_initial.py
|
# -*- coding: utf-8 -*-
# Generated by Django 1.9.7 on 2016-06-27 12:57
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='ClusterColorMarker',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('cluster_id', models.IntegerField()),
('color', models.CharField(max_length=6)),
],
options={
'db_table': 'cluster_color_marker',
},
),
migrations.CreateModel(
name='UserProfile',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('timezone', models.CharField(default='UTC', max_length=100, null=True)),
('date_format', models.CharField(default='dd-mm-yyyy', max_length=100, null=True)),
('time_format', models.CharField(default='24', max_length=10, null=True)),
('opaque1', models.TextField(null=True)),
('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
options={
'db_table': 'user_profile',
},
),
migrations.AddField(
model_name='clustercolormarker',
name='user_profile',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='cluster_color_markers', to='web.UserProfile'),
),
]
| 1,866
|
Python
|
.py
| 43
| 32.767442
| 141
| 0.591635
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,707
|
cluster.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cluster.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2021, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
from string import whitespace
from traceback import format_exc
# Bunch
from bunch import Bunch
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template import loader
from django.template.response import TemplateResponse
# pytz
from pytz import UTC
# Zato
from zato.admin.web import from_utc_to_user
from zato.admin.web.forms.cluster import DeleteClusterForm, EditClusterForm, EditServerForm
from zato.admin.web.views import Delete as _Delete, get_lb_client, method_allowed, set_servers_state
from zato.common.api import SERVER_UP_STATUS
from zato.common.json_internal import dumps
from zato.common.odb.model import Cluster, Server
from zato.common.util.platform_ import is_windows, is_non_windows
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
def _edit_create_response(item, verb):
if item.lb_config:
has_lb_config = True
addresses = loader.render_to_string('zato/cluster/addresses.html', {'item':item})
else:
has_lb_config = False
addresses = ''
return_data = {
'id': item.id,
'message': 'Successfully {0} the cluster [{1}]'.format(verb, item.name),
'addresses': addresses,
'has_lb_config': has_lb_config
}
return HttpResponse(dumps(return_data), content_type='application/javascript')
# ################################################################################################################################
# ################################################################################################################################
def _create_edit(req, verb, item, form_class, prefix=''):
join = '-' if prefix else ''
try:
for s in whitespace:
if s in req.POST[prefix + join + 'name']:
return HttpResponseServerError('Cluster name must not contain whitespace.')
description = req.POST[prefix + join + 'description'].strip()
description = description if description else None
item.name = req.POST[prefix + join + 'name'].strip()
item.description = description
item.lb_host = req.POST[prefix + join + 'lb_host'].strip()
item.lb_port = req.POST[prefix + join + 'lb_port'].strip()
item.lb_agent_port = req.POST[prefix + join + 'lb_agent_port'].strip()
try:
req.zato.odb.add(item)
req.zato.odb.commit()
try:
item.lb_config = get_lb_client(item).get_config()
except Exception:
item.lb_config = None
msg = "Exception caught while fetching the load balancer's config, e:`{}`".format(format_exc())
logger.error(msg)
return _edit_create_response(item, verb)
except Exception:
msg = 'Exception caught, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
except Exception:
req.zato.odb.rollback()
return HttpResponseServerError(str(format_exc()))
# ################################################################################################################################
# ################################################################################################################################
def _get_server_data(client, server_name):
""" Gets the server's state as seen by the load balancer.
"""
lb_server_data = client.get_server_data_dict(server_name)
if lb_server_data:
in_lb = True
state = lb_server_data[server_name]['state']
lb_address = lb_server_data[server_name]['address']
else:
in_lb = False
state = '(unknown)'
lb_address = '(unknown)'
return Bunch({
'in_lb': in_lb,
'state': state,
'lb_address': lb_address,
})
# ################################################################################################################################
# ################################################################################################################################
def _common_edit_message(client, success_msg, id, name, host, up_status, up_mod_date, cluster_id, user_profile,
fetch_lb_data=True):
""" Returns a common JSON message for both the actual 'edit' and 'add/remove to/from LB' actions.
"""
return_data = {
'id': id,
'name': name,
'host': host if host else '(unknown)',
'up_status': up_status if up_status else '(unknown)',
'up_mod_date': from_utc_to_user(up_mod_date+'+00:00', user_profile) if up_mod_date else '(unknown)',
'cluster_id': cluster_id if cluster_id else '',
'lb_state': '(unknown)',
'lb_address': '(unknown)',
'in_lb': '(unknown)',
'message': success_msg.format(name)
}
if fetch_lb_data:
lb_server_data = _get_server_data(client, name)
return_data.update({
'lb_state': lb_server_data.state,
'lb_address': lb_server_data.lb_address,
'in_lb': lb_server_data.in_lb,
})
return HttpResponse(dumps(return_data), content_type='application/javascript')
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def index(req):
delete_form = DeleteClusterForm(prefix='delete')
items = req.zato.odb.query(Cluster).order_by(Cluster.name).all()
for item in items:
if is_non_windows:
client = get_lb_client(item)
try:
lb_config = client.get_config()
item.lb_config = lb_config
# Assign the flags indicating whether servers are DOWN or in the MAINT mode.
set_servers_state(item, client)
except Exception:
msg = 'Could not invoke agent, client:`{!r}`, e:`{}`'.format(client, format_exc())
logger.error(msg)
item.lb_config = None
return_data = {
'delete_form':delete_form,
'edit_form':EditClusterForm(prefix='edit'),
'items':items,
'lb_use_tls': req.zato.lb_use_tls,
'lb_tls_verify': req.zato.lb_tls_verify,
'is_windows': is_windows,
}
return TemplateResponse(req, 'zato/cluster/index.html', return_data)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def edit(req):
return _create_edit(req, 'updated',
req.zato.odb.query(Cluster).filter_by(id=req.POST['id']).one(), EditClusterForm, 'edit')
# ################################################################################################################################
# ################################################################################################################################
def _get(req, **filter):
cluster = req.zato.odb.query(Cluster).filter_by(**filter).one()
return HttpResponse(cluster.to_json(), content_type='application/javascript')
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def get_by_id(req, cluster_id):
return _get(req, id=cluster_id)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def get_by_name(req, cluster_name):
return _get(req, name=cluster_name)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def get_servers_state(req, cluster_id):
cluster = req.zato.odb.query(Cluster).filter_by(id=cluster_id).one()
client = get_lb_client(cluster)
# Assign the flags indicating whether servers are DOWN or in the MAINT mode.
try:
set_servers_state(cluster, client)
except Exception:
msg = 'Failed to invoke the load-balancer\'s agent and set the state of servers, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
return TemplateResponse(req, 'zato/cluster/servers_state.html', {'cluster':cluster})
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def delete(req, id):
""" Deletes a cluster *permanently*.
"""
try:
cluster = req.zato.odb.query(Cluster).filter_by(id=id).one()
req.zato.odb.delete(cluster)
req.zato.odb.commit()
except Exception:
msg = 'Cluster could not be deleted, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
else:
return HttpResponse()
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def servers(req):
""" A view for server management.
"""
items = req.zato.odb.query(Server).order_by(Server.name).all()
for item in items:
if item.up_mod_date:
item.up_mod_date_user = from_utc_to_user(item.up_mod_date.replace(tzinfo=UTC).isoformat(), req.zato.user_profile)
try:
client = get_lb_client(req.zato.get('cluster'))
server_data_dict = client.get_server_data_dict()
bck_http_plain = client.get_config()['backend']['bck_http_plain']
lb_client_invoked = True
except Exception:
logger.error(format_exc())
lb_client_invoked = False
if lb_client_invoked:
def _update_item(server_name, lb_address, lb_state):
for item in items:
if item.name == server_name:
item.in_lb = True
item.lb_address = lb_address
item.lb_state = lb_state
if item.up_status == SERVER_UP_STATUS.RUNNING:
item.may_be_deleted = False
else:
item.may_be_deleted = True
for server_name in bck_http_plain:
lb_address = '{}:{}'.format(bck_http_plain[server_name]['address'], bck_http_plain[server_name]['port'])
_update_item(server_name, lb_address, server_data_dict[server_name]['state'])
return_data = {
'items':items,
'search_form':req.zato.search_form,
'zato_clusters':req.zato.clusters,
'cluster':req.zato.get('cluster'),
'edit_form':EditServerForm(prefix='edit')
}
return TemplateResponse(req, 'zato/cluster/servers.html', return_data)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def servers_edit(req):
""" Updates a server in both ODB and the load balancer.
"""
try:
client = get_lb_client(req.zato.cluster)
server_id = req.POST['id']
server = req.zato.odb.query(Server).filter_by(id=server_id).one()
if client.get_server_data_dict(server.name):
fetch_lb_data = True
client.rename_server(req.POST['edit-old_name'], req.POST['edit-name'])
else:
fetch_lb_data = False
response = req.zato.client.invoke('zato.server.edit', {'id':server_id, 'name':req.POST['edit-name']})
return _common_edit_message(client, 'Server [{}] updated',
response.data.id, response.data.name, response.data.host,
response.data.up_status, response.data.up_mod_date,
req.zato.cluster_id, req.zato.user_profile, fetch_lb_data)
except Exception:
return HttpResponseServerError(format_exc())
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def servers_add_remove_lb(req, action, server_id):
""" Adds or removes a server from the load balancer's configuration.
"""
server = req.zato.odb.query(Server).filter_by(id=server_id).one()
up_mod_date = server.up_mod_date.isoformat() if server.up_mod_date else ''
client = get_lb_client(req.zato.cluster)
client.add_remove_server(action, server.name)
if action == 'add':
success_msg = 'added to'
fetch_lb_data = True
else:
success_msg = 'removed from'
fetch_lb_data = False
return _common_edit_message(client,
'Server [{{}}] {} the load balancer'.format(success_msg),
server.id, server.name, server.host, server.up_status, up_mod_date,
server.cluster_id, req.zato.user_profile, fetch_lb_data)
# ################################################################################################################################
# ################################################################################################################################
class ServerDelete(_Delete):
url_name = 'cluster-servers-delete'
error_message = 'Could not delete the server'
service_name = 'zato.server.delete'
def __call__(self, req, *args, **kwargs):
response = req.zato.client.invoke('zato.server.get-by-id', {'id':req.zato.id})
server = req.zato.odb.query(Server).filter_by(id=req.zato.id).one()
client = get_lb_client(req.zato.cluster) # Checks whether the server is known by LB
if client.get_server_data_dict(server.name):
client.add_remove_server('remove', response.data.name)
return super(ServerDelete, self).__call__(req, *args, **kwargs)
# ################################################################################################################################
# ################################################################################################################################
| 15,804
|
Python
|
.py
| 296
| 46.273649
| 130
| 0.452747
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,708
|
http_soap.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/http_soap.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2024, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
from operator import itemgetter
from traceback import format_exc
# Django
from django.http import HttpResponse, HttpResponseRedirect, HttpResponseServerError
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.forms.http_soap import SearchForm, CreateForm, EditForm
from zato.admin.web.views import get_group_list as common_get_group_list, get_http_channel_security_id, \
get_security_id_from_select, get_security_groups_from_checkbox_list, get_tls_ca_cert_list, id_only_service, \
method_allowed, parse_response_data, SecurityList
from zato.common.api import AuditLog, CACHE, DEFAULT_HTTP_PING_METHOD, DEFAULT_HTTP_POOL_SIZE, DELEGATED_TO_RBAC, \
generic_attrs, Groups, HTTP_SOAP_SERIALIZATION_TYPE, MISC, PARAMS_PRIORITY, SEC_DEF_TYPE, \
SOAP_CHANNEL_VERSIONS, SOAP_VERSIONS, URL_PARAMS_PRIORITY, URL_TYPE
from zato.common.exception import ZatoException
from zato.common.json_internal import dumps
from zato.common.odb.model import HTTPSOAP
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
CONNECTION = {
'channel': 'channel',
'outgoing': 'outgoing connection',
}
CONNECTION_PLURAL = {
'channel': 'channels',
'outgoing': 'outgoing connections',
}
TRANSPORT = {
'plain_http': 'REST',
'soap': 'SOAP',
}
CACHE_TYPE = {
CACHE.TYPE.BUILTIN: 'Built-in',
CACHE.TYPE.MEMCACHED: 'Memcached',
}
_rest_security_type_supported = {
SEC_DEF_TYPE.APIKEY,
SEC_DEF_TYPE.BASIC_AUTH,
SEC_DEF_TYPE.NTLM,
SEC_DEF_TYPE.OAUTH,
SEC_DEF_TYPE.TLS_KEY_CERT,
}
_max_len_messages = AuditLog.Default.max_len_messages
_max_data_stored_per_message = AuditLog.Default.max_data_stored_per_message
# ################################################################################################################################
# ################################################################################################################################
def _get_edit_create_message(params, prefix=''): # type: ignore
""" A bunch of attributes that can be used by both 'edit' and 'create' actions
for channels and outgoing connections.
"""
security_id = get_security_id_from_select(params, prefix)
security_groups = get_security_groups_from_checkbox_list(params, prefix)
message = {
'is_internal': False,
'connection': params['connection'],
'transport': params['transport'],
'id': params.get('id'),
'cluster_id': params['cluster_id'],
'name': params[prefix + 'name'],
'is_active': bool(params.get(prefix + 'is_active')),
'host': params.get(prefix + 'host'),
'url_path': params[prefix + 'url_path'],
'merge_url_params_req': bool(params.get(prefix + 'merge_url_params_req')),
'match_slash': bool(params.get(prefix + 'match_slash')),
'http_accept': params.get(prefix + 'http_accept'),
'url_params_pri': params.get(prefix + 'url_params_pri', URL_PARAMS_PRIORITY.DEFAULT),
'params_pri': params.get(prefix + 'params_pri', PARAMS_PRIORITY.DEFAULT),
'serialization_type': params.get(prefix + 'serialization_type', HTTP_SOAP_SERIALIZATION_TYPE.DEFAULT.id),
'method': params.get(prefix + 'method'),
'soap_action': params.get(prefix + 'soap_action', ''),
'soap_version': params.get(prefix + 'soap_version', None),
'data_format': params.get(prefix + 'data_format', None),
'service': params.get(prefix + 'service'),
'ping_method': params.get(prefix + 'ping_method'),
'pool_size': params.get(prefix + 'pool_size'),
'timeout': params.get(prefix + 'timeout'),
'sec_tls_ca_cert_id': params.get(prefix + 'sec_tls_ca_cert_id'),
'security_id': security_id,
'security_groups': security_groups,
'has_rbac': bool(params.get(prefix + 'has_rbac')),
'content_type': params.get(prefix + 'content_type'),
'cache_id': params.get(prefix + 'cache_id'),
'cache_expiry': params.get(prefix + 'cache_expiry'),
'content_encoding': params.get(prefix + 'content_encoding'),
'hl7_version': params.get(prefix + 'hl7_version'),
'json_path': params.get(prefix + 'json_path'),
'data_encoding': params.get(prefix + 'data_encoding'),
'is_rate_limit_active': params.get(prefix + 'is_rate_limit_active'),
'rate_limit_type': params.get(prefix + 'rate_limit_type'),
'rate_limit_def': params.get(prefix + 'rate_limit_def'),
'rate_limit_check_parent_def': params.get(prefix + 'rate_limit_check_parent_def'),
'max_len_messages_sent': params.get(prefix + 'max_len_messages_sent') or _max_len_messages,
'max_len_messages_received': params.get(prefix + 'max_len_messages_received') or _max_len_messages,
'max_bytes_per_message_sent': params.get(prefix + 'max_bytes_per_message_sent') or _max_data_stored_per_message,
'max_bytes_per_message_received': params.get(prefix + 'max_bytes_per_message_received') or _max_data_stored_per_message,
}
# If these fields exist, no matter what their values are, perhaps empty,
# it means that they are on (True). Otherwise, the values are set to False,
# again, the mere fact that they do not exist means that.
field_is_audit_log_received_active = prefix + 'is_audit_log_received_active'
field_is_audit_log_sent_active = prefix + 'is_audit_log_sent_active'
is_audit_log_received_active = field_is_audit_log_received_active in params
is_audit_log_sent_active = field_is_audit_log_sent_active in params
message['is_audit_log_received_active'] = is_audit_log_received_active
message['is_audit_log_sent_active'] = is_audit_log_sent_active
return message
# ################################################################################################################################
# ################################################################################################################################
def _edit_create_response(req, id, verb, transport, connection, name): # type: ignore
groups = common_get_group_list(req, Groups.Type.API_Clients, http_soap_channel_id=id)
group_count = 0
group_member_count = 0
for item in groups:
if item.is_assigned:
group_count += 1
group_member_count += item.member_count
if (group_count == 0) or (group_count > 1):
group_count_suffix = 's'
else:
group_count_suffix = ''
if (group_member_count == 0) or (group_member_count > 1):
group_member_count_suffix = 's'
else:
group_member_count_suffix = ''
return_data = {
'id': id,
'transport': transport,
'message': 'Successfully {} {} {} `{}`'.format(verb, TRANSPORT[transport], CONNECTION[connection], name),
'security_groups_info': f'{group_count} group{group_count_suffix}, {group_member_count} client{group_member_count_suffix}'
}
# If current item has a cache assigned, provide its human-friendly name to the caller
response = req.zato.client.invoke('zato.http-soap.get', {
'cluster_id': req.zato.cluster_id,
'id': id,
})
if response.data.cache_id:
cache_type = response.data.cache_type
cache_name = '{}/{}'.format(CACHE_TYPE[cache_type], response.data.cache_name)
else:
cache_type = None
cache_name = None
return_data['cache_type'] = cache_type
return_data['cache_name'] = cache_name
return HttpResponse(dumps(return_data), content_type='application/javascript')
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def index(req): # type: ignore
connection = req.GET.get('connection')
transport = req.GET.get('transport')
query = req.GET.get('query', '')
items = []
_security = SecurityList()
if not all((connection, transport)):
log_msg = "Redirecting to / because at least one of ('connection', 'transport') GET parameters was missing"
logger.debug(log_msg)
return HttpResponseRedirect('/')
create_form = None
edit_form = None
meta = None
colspan = 17
if transport == 'soap':
colspan += 2
if req.zato.cluster_id:
for def_item in req.zato.client.invoke('zato.security.get-list', {'cluster_id': req.zato.cluster.id}):
if connection == 'outgoing':
if transport == URL_TYPE.PLAIN_HTTP and def_item.sec_type not in _rest_security_type_supported:
continue
_security.append(def_item)
_soap_versions = SOAP_CHANNEL_VERSIONS if connection == 'channel' else SOAP_VERSIONS
tls_ca_cert_list = get_tls_ca_cert_list(req.zato.client, req.zato.cluster)
cache_list = []
for cache_type in (CACHE.TYPE.BUILTIN, CACHE.TYPE.MEMCACHED):
service_name = 'zato.cache.{}.get-list'.format(cache_type)
response = req.zato.client.invoke(service_name, {'cluster_id': req.zato.cluster.id})
for item in sorted(response, key=itemgetter('name')):
cache_list.append({'id':item.id, 'name':'{}/{}'.format(CACHE_TYPE[cache_type], item.name)})
create_form = CreateForm(_security, tls_ca_cert_list, cache_list, _soap_versions, req=req)
edit_form = EditForm(_security, tls_ca_cert_list, cache_list, _soap_versions, prefix='edit', req=req)
input_dict = {
'cluster_id': req.zato.cluster_id,
'connection': connection,
'transport': transport,
'paginate': True,
'cur_page': req.GET.get('cur_page', 1),
'query': req.GET.get('query', ''),
}
data, meta = parse_response_data(req.zato.client.invoke('zato.http-soap.get-list', input_dict))
for item in data:
if query not in item.name:
continue
_security_name = item.security_name
if _security_name:
sec_type_as_link = item.sec_type.replace('_', '-')
if item.sec_type == SEC_DEF_TYPE.OAUTH:
direction = 'outconn/client-credentials/'
else:
direction = ''
security_href = f'/zato/security/{sec_type_as_link}/{direction}'
security_href += f'?cluster={req.zato.cluster_id}&query={_security_name}'
security_link = f'<a href="{security_href}">{_security_name}</a>'
security_name = security_link
else:
if item.sec_use_rbac:
security_name = DELEGATED_TO_RBAC
else:
security_name = '<span class="form_hint">---</span>'
security_id = get_http_channel_security_id(item)
if item.cache_id:
cache_name = '{}/{}'.format(CACHE_TYPE[item.cache_type], item.cache_name)
else:
cache_name = None
# New in 3.0, hence optional
match_slash = item.get('match_slash')
if match_slash == '':
match_slash = True
# New in 3.1
http_accept = item.get('http_accept') or ''
http_soap = HTTPSOAP(item.id, item.name, item.is_active, item.is_internal, connection,
transport, item.host, item.url_path, item.method, item.soap_action,
item.soap_version, item.data_format, item.ping_method,
item.pool_size, item.merge_url_params_req, item.url_params_pri, item.params_pri,
item.serialization_type, item.timeout, item.sec_tls_ca_cert_id, service_id=item.service_id,
service_name=item.service_name, security_id=security_id, has_rbac=item.has_rbac,
security_name=security_name, content_type=item.content_type,
cache_id=item.cache_id, cache_name=cache_name, cache_type=item.cache_type, cache_expiry=item.cache_expiry,
content_encoding=item.content_encoding, match_slash=match_slash, http_accept=http_accept)
for name in generic_attrs:
setattr(http_soap, name, item.get(name))
items.append(http_soap)
return_data = {'zato_clusters':req.zato.clusters,
'cluster_id':req.zato.cluster_id,
'search_form':SearchForm(req.zato.clusters, req.GET),
'items':items,
'create_form':create_form,
'edit_form':edit_form,
'connection':connection,
'transport':transport,
'connection_label':CONNECTION[connection],
'connection_label_plural':CONNECTION_PLURAL[connection],
'transport_label':TRANSPORT[transport],
'colspan': colspan,
'default_http_ping_method':DEFAULT_HTTP_PING_METHOD,
'default_http_pool_size':DEFAULT_HTTP_POOL_SIZE,
'default_http_timeout':MISC.DEFAULT_HTTP_TIMEOUT,
'audit_max_len_messages': _max_len_messages,
'audit_max_data_stored_per_message': _max_data_stored_per_message,
'paginate':True,
'meta': meta,
'req':req
}
return TemplateResponse(req, 'zato/http_soap/index.html', return_data)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def create(req): # type: ignore
try:
response = req.zato.client.invoke('zato.http-soap.create', _get_edit_create_message(req.POST))
if response.has_data:
return _edit_create_response(req, response.data.id, 'created',
req.POST['transport'], req.POST['connection'], req.POST['name'])
else:
raise ZatoException(msg=response.details)
except Exception:
msg = 'Object could not be created, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def edit(req): # type: ignore
try:
edit_create_request = _get_edit_create_message(req.POST, 'edit-')
response = req.zato.client.invoke('zato.http-soap.edit', edit_create_request)
if response.has_data:
return _edit_create_response(req, response.data.id, 'updated',
req.POST['transport'], req.POST['connection'], req.POST['edit-name'])
else:
raise ZatoException(msg=response.details)
except Exception as e:
msg = 'Update error: {}'.format(e.args[0])
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def delete(req, id, cluster_id): # type: ignore
_ = id_only_service(req, 'zato.http-soap.delete', id, 'Object could not be deleted, e:`{}`')
return HttpResponse()
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id): # type: ignore
response = id_only_service(req, 'zato.http-soap.ping', id, 'Could not ping the connection, e:`{}`')
if isinstance(response, HttpResponseServerError):
return response
else:
if response.data.is_success:
return HttpResponse(response.data.info)
else:
return HttpResponseServerError(response.data.info)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def reload_wsdl(req, id, cluster_id): # type: ignore
ret = id_only_service(req, 'zato.http-soap.reload-wsdl', id, 'WSDL could not be reloaded, e:`{}`')
if isinstance(ret, HttpResponseServerError):
return ret
return HttpResponse('WSDL reloaded, check server logs for details')
# ################################################################################################################################
# ################################################################################################################################
| 17,831
|
Python
|
.py
| 320
| 47.740625
| 130
| 0.535417
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,709
|
config_file.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/config_file.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# Zato
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
# ################################################################################################################################
class ConfigFile:
def __init__(self):
self.id = None
self.name = None
self.type = None
self.data = None
self.size = None
self.size_pretty = None
self.last_modified = None
self.last_modified_utc = None
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'config-file'
template = 'zato/config_file/index.html'
service_name = 'config-file.get-list'
output_class = ConfigFile
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'type', 'size', 'size_pretty')
output_repeated = True
def handle(self):
return {}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('id', 'name', 'type', 'data')
def success_message(self, ignored_item):
return 'File saved succesfully'
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'config-file-create'
service_name = 'config-file.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'config-file-edit'
form_prefix = 'edit-'
service_name = 'config-file.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'config-file-delete'
error_message = 'File could not be deleted'
service_name = 'config-file.delete'
# ################################################################################################################################
| 2,578
|
Python
|
.py
| 55
| 42
| 130
| 0.419664
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,710
|
account.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/account.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
# Django
from django.contrib import messages
from django.urls import reverse
from django.http import HttpResponse
from django.shortcuts import redirect
from django.template.response import TemplateResponse
# PyOTP
import pyotp
# Python 2/3 compatibility
from zato.common.py23_.past.builtins import unicode
# Zato
from zato.admin import zato_settings
from zato.admin.web.forms.account import BasicSettingsForm
from zato.admin.web.models import ClusterColorMarker
from zato.admin.web.util import set_user_profile_totp_key
from zato.admin.web.views import method_allowed
from zato.common.crypto.api import CryptoManager
from zato.common.json_internal import dumps, loads
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
DEFAULT_PROMPT = 'Click to pick a color'
# ################################################################################################################################
profile_attrs = 'timezone', 'date_format', 'time_format'
profile_attrs_opaque = 'totp_key', 'totp_key_label'
# ################################################################################################################################
def set_initial_opaque_attrs(username, initial, opaque_attrs):
# By default, opaque attributes are not set for user
if opaque_attrs:
opaque_attrs = loads(opaque_attrs)
for attr in profile_attrs_opaque:
initial[attr] = opaque_attrs.get(attr) or ''
# Generate or use the existing TOTP key
totp_key = initial.get('totp_key')
if not totp_key:
totp_key = pyotp.random_base32()
initial['totp_key_label'] = 'Zato Dashboard'
else:
cm = CryptoManager(secret_key=zato_settings.zato_secret_key)
# TOTP key is always decrypted so we need to decrypt it here
totp_key = cm.decrypt(totp_key)
# .. same goes for its label
initial['totp_key_label'] = cm.decrypt(initial['totp_key_label'])
# Build the actual TOTP object for later use
totp = pyotp.totp.TOTP(totp_key)
# Update template data with TOTP information
initial['totp_key'] = totp.secret
initial['totp_key_provision_uri'] = totp.provisioning_uri(username, issuer_name=initial['totp_key_label'])
# ################################################################################################################################
@method_allowed('GET')
def settings_basic(req):
# Data for the template
initial = {}
# Process explicitly named attributes
for attr in profile_attrs:
initial[attr] = getattr(req.zato.user_profile, attr, None)
# Process attributes from opaque data
set_initial_opaque_attrs(req.user.username, initial, req.zato.user_profile.opaque1)
return_data = {
'clusters': req.zato.clusters,
'default_prompt': DEFAULT_PROMPT,
'form':BasicSettingsForm(initial),
'username': req.user.username
}
cluster_color_markers = req.zato.user_profile.cluster_color_markers.all()
cluster_colors = {str(item.cluster_id):item.color for item in cluster_color_markers}
return_data['cluster_colors'] = cluster_colors
return TemplateResponse(req, 'zato/account/settings.html', return_data)
# ################################################################################################################################
@method_allowed('POST')
def settings_basic_save(req):
# Process explicitly named attributes
for attr in profile_attrs:
# Use False as default value so as to convert blank checkboxes into a boolean value
value = req.POST.get(attr, False)
setattr(req.zato.user_profile, attr, value)
# Process opaque attributes
opaque_attrs = {}
for attr in profile_attrs_opaque:
value = req.POST.get(attr)
opaque_attrs[attr] = value
# Encrypt TOTP before it is saved to the database
totp_key = opaque_attrs.get('totp_key')
if totp_key:
# set_user_profile_totp_key(profile, zato_secret_key, key, label, opaque_attrs=None)
set_user_profile_totp_key(req.zato.user_profile, zato_settings.zato_secret_key,
totp_key, opaque_attrs.get('totp_key_label'), opaque_attrs)
# Make sure all values are Unicode objects before serializing opaque attrs to JSON
for key, value in opaque_attrs.items():
if not isinstance(value, unicode):
opaque_attrs[key] = value.decode('utf8')
# Save all opaque attributes along with the profile
req.zato.user_profile.opaque1 = dumps(opaque_attrs)
# Save the profile
req.zato.user_profile.save()
# Save preferred cluster colour markers
for key, value in req.POST.items():
if key.startswith('color_') and value != DEFAULT_PROMPT:
cluster_id = key.replace('color_', '')
if 'checkbox_{}'.format(cluster_id) in req.POST:
try:
ccm = ClusterColorMarker.objects.get(cluster_id=cluster_id, user_profile=req.zato.user_profile)
except ClusterColorMarker.DoesNotExist:
ccm = ClusterColorMarker()
ccm.cluster_id = cluster_id
ccm.user_profile = req.zato.user_profile
ccm.color = value
ccm.save()
else:
ClusterColorMarker.objects.filter(cluster_id=cluster_id, user_profile=req.zato.user_profile).delete()
msg = 'Settings saved'
messages.add_message(req, messages.INFO, msg, extra_tags='success')
return redirect(reverse('account-settings-basic'))
# ################################################################################################################################
@method_allowed('POST')
def generate_totp_key(req):
return HttpResponse(pyotp.random_base32())
# ################################################################################################################################
| 6,332
|
Python
|
.py
| 125
| 44.584
| 130
| 0.580588
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,711
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2024, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# pylint: disable=attribute-defined-outside-init
# stdlib
import logging
from base64 import b64encode
from datetime import datetime, timedelta
from itertools import chain
from traceback import format_exc
# bunch
from bunch import Bunch
# Django
from django.http import HttpResponse, HttpResponseBadRequest, HttpResponseServerError
# pytz
from pytz import UTC
# Zato
try:
from zato.admin.settings import lb_agent_use_tls
except ImportError:
lb_agent_use_tls = True
from zato.admin.settings import ssl_key_file, ssl_cert_file, ssl_ca_certs, LB_AGENT_CONNECT_TIMEOUT
from zato.admin.web import from_utc_to_user
from zato.admin.web.util import get_template_response
from zato.common.api import CONNECTION, SEC_DEF_TYPE_NAME, URL_TYPE, ZATO_NONE, ZATO_SEC_USE_RBAC
from zato.common.exception import ZatoException
from zato.common.json_internal import dumps
from zato.common.util.api import get_lb_client as _get_lb_client, validate_python_syntax
# ################################################################################################################################
from django.urls import reverse as django_url_reverse
from django.utils.text import slugify
# For pyflakes
django_url_reverse = django_url_reverse
slugify = slugify
# ################################################################################################################################
if 0:
from zato.client import ServiceInvokeResponse
from zato.common.typing_ import any_, anylist
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
SKIP_VALUE = 'zato.skip.value'
# ################################################################################################################################
def parse_response_data(response):
""" Parses out data and metadata out an internal API call response.
"""
meta = response.data.pop('_meta', None)
keys = list(response.data.keys())
data = response.data[keys[0]]
return data, meta
# ################################################################################################################################
def invoke_list_service(client, cluster, service, extra=None):
out = {}
request = {'cluster_id':cluster.id}
request.update(extra or {})
for item in client.invoke(service, request):
out[item.id] = item.name
return out
# ################################################################################################################################
def get_definition_list(client, cluster, def_type):
""" Returns all definitions of a given type existing on a given cluster.
"""
return invoke_list_service(client, cluster, 'zato.definition.{}.get-list'.format(def_type))
# ################################################################################################################################
def get_outconn_rest_list(req, name_to_id=False):
""" Returns a list of all outgoing REST connections.
"""
out = {}
response = req.zato.client.invoke('zato.http-soap.get-list', {
'cluster_id': req.zato.cluster_id,
'connection': CONNECTION.OUTGOING,
'transport': URL_TYPE.PLAIN_HTTP,
})
for item in response:
if name_to_id:
key = item.name
value = item.id
else:
key = item.id
value = item.name
out[key] = value
return out
# ################################################################################################################################
def get_tls_ca_cert_list(client, cluster):
""" Returns all TLS CA certs on a given cluster.
"""
return invoke_list_service(client, cluster, 'zato.security.tls.ca-cert.get-list')
# ################################################################################################################################
def get_sample_dt(user_profile):
""" A sample date and time an hour in the future serving as a hint as to what
format to use when entering date and time manually in the user-provided format.
"""
return from_utc_to_user((datetime.utcnow() + timedelta(hours=1)).replace(tzinfo=UTC), user_profile)
# ################################################################################################################################
def get_js_dt_format(user_profile):
""" Converts the user-given datetime format to the one that JavaScript's date time picker is to use.
"""
return {
'js_date_format':user_profile.date_format.replace('yyyy', 'yy') if 'yyyy' in user_profile.date_format else user_profile.date_format.replace('yy', 'y'),
'js_time_format':'h:mm.ss TT' if user_profile.time_format == '12' else 'hh:mm:ss',
'js_ampm':user_profile.time_format == '12',
}
# ################################################################################################################################
def get_lb_client(cluster):
""" A convenience wrapper over the function for creating a load-balancer client
which may use web admin's SSL material (the client from zato.common can't use
it because it would make it dependent on the zato.admin package).
"""
return _get_lb_client(lb_agent_use_tls, cluster.lb_host, cluster.lb_agent_port, ssl_ca_certs,
ssl_key_file, ssl_cert_file, LB_AGENT_CONNECT_TIMEOUT)
# ################################################################################################################################
def method_allowed(*methods_allowed):
""" Accepts a list (possibly one-element long) of HTTP methods allowed
for a given view. An exception will be raised if a request has been made
with a method outside of those allowed, otherwise the view executes
unchanged.
"""
def inner_method_allowed(view):
def inner_view(*args, **kwargs):
req = args[1] if len(args) > 1 else args[0]
if req.method not in methods_allowed:
msg = 'Method `{}` is not allowed here `{}`, methods allowed:`{}`'.format(
req.method, view, methods_allowed)
logger.error(msg)
raise Exception(msg)
return view(*args, **kwargs)
return inner_view
return inner_method_allowed
# ################################################################################################################################
def set_servers_state(cluster, client):
""" Assignes 3 flags to the cluster indicating whether load-balancer believes the servers are UP, DOWN or in the MAINT mode.
"""
servers_state = client.get_servers_state()
up = []
down = []
maint = []
cluster.some_down = False
cluster.some_maint = False
cluster.all_down = False
# Note: currently we support only the 'http_plain' access_type.
for access_type in('http_plain',):
up.extend(servers_state['UP'][access_type])
down.extend(servers_state['DOWN'][access_type])
maint.extend(servers_state['MAINT'][access_type])
# Do we have any servers at all?
if any((up, down, maint)):
if not(up or maint) and down:
cluster.all_down = True
else:
if down:
cluster.some_down = True
if maint:
cluster.some_maint = True
# ################################################################################################################################
def change_password(req, service_name, field1='password1', field2='password2', success_msg='Password updated', data=None):
data = data or req.POST
secret_type = data.get('secret_type')
if secret_type == 'secret':
success_msg = 'Secret updated'
try:
input_dict = {
'id': data.get('id'),
'password1': data.get(field1, ''),
'password2': data.get(field2, ''),
'type_': data.get('type_', ''),
}
req.zato.client.invoke(service_name, input_dict)
except Exception:
msg = 'Caught an exception, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
else:
return HttpResponse(dumps({'message':success_msg}))
# ################################################################################################################################
def get_security_id_from_select(params, prefix, field_name='security'):
security = params[prefix + field_name]
if security == ZATO_NONE:
security_id = ZATO_NONE
elif security == ZATO_SEC_USE_RBAC:
security_id = ZATO_SEC_USE_RBAC
else:
_, security_id = security.split('/')
return security_id
# ################################################################################################################################
def get_security_groups_from_checkbox_list(params, prefix, field_name_prefix='http_soap_security_group_checkbox_'):
# Our response to produce
groups = []
# Local variables
full_prefix = prefix + field_name_prefix
for item in params:
if item.startswith(full_prefix):
item = item.replace(full_prefix, '')
groups.append(item)
return groups
# ################################################################################################################################
def build_sec_def_link(cluster_id, sec_type, sec_name):
sec_type_name = SEC_DEF_TYPE_NAME[sec_type]
sec_type = sec_type.replace('_', '-')
url_path = django_url_reverse('security-{}'.format(sec_type))
link = """
{sec_type_name}
<br/>
<a href="{url_path}?cluster={cluster_id}&query={sec_name}">{sec_name}</a>
""".format(**{
'cluster_id': cluster_id,
'sec_type_name': sec_type_name,
'sec_name': sec_name,
'url_path': url_path,
}).strip()
return link
# ################################################################################################################################
def build_sec_def_link_by_input(req, cluster_id, input_data):
# type: (dict) -> str
security_id = input_data.get('security_id')
if security_id and security_id != ZATO_NONE:
security_id = extract_security_id(input_data)
sec_response = id_only_service(req, 'zato.security.get-by-id', security_id).data
return build_sec_def_link(cluster_id, sec_response.sec_type, sec_response.name)
# ################################################################################################################################
class BaseView:
method_allowed = 'method_allowed-must-be-defined-in-a-subclass'
service_name = None
async_invoke = False
form_prefix = ''
def __init__(self):
self.req = None # type: any_
self.cluster_id = None
self.clear_user_message()
self.ctx = {}
def __call__(self, req, *args, **kwargs):
self.req = req
for k, v in kwargs.items():
self.req.zato.args[k] = v
self.cluster_id = None
self.fetch_cluster_id()
def build_sec_def_link_by_input(self, input_data):
return build_sec_def_link_by_input(self.req, self.cluster_id, input_data)
def on_before_append_item(self, item):
return item
def get_output_class(self):
pass
def on_after_set_input(self):
pass
def clear_user_message(self):
self.user_message = None
self.user_message_class = 'failure'
class SimpleIO:
input_required = []
input_optional = []
output_required = []
output_optional = []
output_repeated = False
def get_service_name(self, *_args, **_kwargs):
raise NotImplementedError('May be implemented by subclasses')
def fetch_cluster_id(self):
# Doesn't look overtly smart right now but more code will follow to sanction
# the existence of this function
cluster_id = self.req.zato.cluster_id
if cluster_id:
self.cluster_id = int(cluster_id)
def populate_initial_input_dict(self, initial_input_dict):
""" May be overridden by subclasses if needed.
"""
def get_sec_def_list(self, sec_type):
if self.req.zato.get('client'):
return SecurityList.from_service(self.req.zato.client, self.req.zato.cluster.id, sec_type)
else:
return []
def set_input(self, req=None, default_attrs=('cur_page', 'query')):
req = req or self.req
self.input.update({
'cluster_id':self.cluster_id,
'paginate': getattr(self, 'paginate', False),
})
initial_input_dict = {}
self.populate_initial_input_dict(initial_input_dict)
self.input.update(initial_input_dict)
for name in chain(self.SimpleIO.input_required, self.SimpleIO.input_optional, default_attrs):
if name != 'cluster_id':
value = req.GET.getlist(name)
if value:
value = value if len(value) > 1 else value[0]
if not value:
value = req.POST.getlist(self.form_prefix + name)
if value:
value = value if len(value) > 1 else value[0]
if not value:
value = req.zato.args.get(self.form_prefix + name)
self.input[name] = value
self.on_after_set_input()
# ################################################################################################################################
class Index(BaseView):
""" A base class upon which other index views are based.
"""
url_name = 'url_name-must-be-defined-in-a-subclass'
template = 'template-must-be-defined-in-a-subclass-or-get-template-name'
wrapper_type = None
output_class = None
clear_self_items = True
update_request_with_self_input = True
def __init__(self):
super(Index, self).__init__()
self.input = Bunch()
self.items = []
self.item = None
self.clear_user_message()
def can_invoke_admin_service(self):
""" Returns a boolean flag indicating that we know what service to invoke, what cluster it is on
and that all the required parameters were given in GET request. cluster_id doesn't have to be in GET,
'cluster' will suffice.
"""
input_elems = list(self.req.GET.keys()) + list(self.req.zato.args.keys())
if not self.cluster_id:
logger.info('Value missing; self.cluster_id `%s`', self.cluster_id)
return False
for elem in self.SimpleIO.input_required:
if elem == 'cluster_id':
continue
if not elem in input_elems:
logger.info('Elem `%s` not in input_elems `%s`', elem, input_elems)
return False
value = self.req.GET.get(elem)
if not value:
value = self.req.zato.args.get(elem)
if not value:
logger.info('Elem `%s` not in self.req.zato.args `%s`', elem, self.req.zato.args)
return False
return True
def before_invoke_admin_service(self):
pass
def get_service_name(self, _req):
raise NotImplementedError('May be implemented in subclasses')
def get_initial_input(self):
return {}
def get_template_name(self):
""" May be overridden by subclasses to dynamically decide which template to use,
otherwise self.template will be employed.
"""
def should_extract_top_level(self, _keys):
return True
def invoke_admin_service(self) -> 'ServiceInvokeResponse':
if self.req.zato.get('cluster'):
func = self.req.zato.client.invoke_async if self.async_invoke else self.req.zato.client.invoke
service_name = self.service_name if self.service_name else self.get_service_name(self.req)
request = self.get_initial_input()
if self.update_request_with_self_input:
request.update(self.input)
else:
logger.info('Not updating request with self.input')
# Auto-populate the field if it exists
if self.wrapper_type:
request['wrapper_type'] = self.wrapper_type
logger.info('Invoking `%s` with `%s`', service_name, request)
return func(service_name, request)
def should_include(self, item) -> 'bool':
return True
def _handle_single_item_list(self, container, item_list):
""" Creates a new instance of the model class for each of the element received
and fills it in with received attributes.
"""
names = tuple(chain(self.SimpleIO.output_required, self.SimpleIO.output_optional))
for msg_item in item_list or []:
output_class = self.get_output_class()
item = output_class() if output_class else self.output_class()
# Use attributes that were definded upfront for the SimpleIO definition
# or use everything that we received from the service.
names = names if names else msg_item.keys()
for name in sorted(names):
value = getattr(msg_item, name, None)
if value is not None:
value = getattr(value, 'text', '') or value
if value or value in (0, [], {}):
setattr(item, name, value)
item = self.on_before_append_item(item)
if isinstance(item, (list, tuple)):
func = container.extend
else:
func = container.append
func(item)
def handle_item_list(self, item_list, _ignored_is_extracted):
""" Creates a new instance of the model class for each of the element received
and fills it in with received attributes.
"""
names = tuple(chain(self.SimpleIO.output_required, self.SimpleIO.output_optional))
for msg_item in (item_list or []):
item = self.output_class()
for name in sorted(names):
value = getattr(msg_item, name, None)
if value is not None:
value = getattr(value, 'text', '') or value
if value or value == 0:
setattr(item, name, value)
if not self.should_include(item):
continue
item = self.on_before_append_item(item)
if isinstance(item, (list, tuple)):
func = self.items.extend
else:
func = self.items.append
func(item)
def _handle_item(self, item):
pass
def handle_return_data(self, return_data):
return return_data
def __call__(self, req, *args, **kwargs):
""" Handles the request, taking care of common things and delegating
control to the subclass for fetching this view-specific data.
"""
self.clear_user_message()
try:
super(Index, self).__call__(req, *args, **kwargs)
# The value of clear_self_items if True if we are returning a single list of elements,
# based on self.extract_top_level_key_from_payload.
if self.clear_self_items:
del self.items[:]
self.item = None
self.set_input()
return_data = {'cluster_id':self.cluster_id}
output_repeated = getattr(self.SimpleIO, 'output_repeated', False)
response = None
if self.can_invoke_admin_service():
self.before_invoke_admin_service()
response = self.invoke_admin_service()
logger.info('Response from service: `%s`', response.data)
if response and response.ok:
return_data['response_inner'] = response.inner_service_response
if output_repeated:
if response and isinstance(response.data, dict):
response.data.pop('_meta', None)
keys = list(response.data.keys())
if self.should_extract_top_level(keys):
data = response.data[keys[0]]
is_extracted = True
else:
data = response.data
is_extracted = False
else:
data = response.data
is_extracted = False
# At this point, this may be just a list of elements, if self.should_extract_top_level returns True,
# or a dictionary of keys pointing to lists with such elements.
self.handle_item_list(data, is_extracted)
else:
self._handle_item(response.data)
else:
self.user_message = response.details
else:
logger.info('can_invoke_admin_service returned False, not invoking an admin service:[%s]', self.service_name)
template_name = self.get_template_name() or self.template
return_data['req'] = self.req
return_data['items'] = self.items
return_data['item'] = self.item
return_data['input'] = self.input
return_data['user_message'] = self.user_message
return_data['user_message_class'] = self.user_message_class
return_data['zato_clusters'] = req.zato.clusters
return_data['search_form'] = req.zato.search_form
return_data['meta'] = response.meta if response else {}
return_data['paginate'] = getattr(self, 'paginate', False)
return_data['zato_template_name'] = template_name
view_specific = self.handle()
if view_specific:
return_data.update(view_specific)
return_data = self.handle_return_data(return_data)
for k, v in sorted(return_data.items()):
logger.info('Index key/value `%s` -> `%r`', k, v)
return get_template_response(req, template_name, return_data)
except Exception:
return HttpResponseServerError(format_exc())
def handle(self, req=None, *args, **kwargs):
return {}
# ################################################################################################################################
class CreateEdit(BaseView):
""" Subclasses of this class will handle the creation/updates of Zato objects.
"""
def __init__(self, *args, **kwargs):
super(CreateEdit, self).__init__()
self.input = Bunch()
self.input_dict = {}
def __call__(self, req, initial_input_dict=None, initial_return_data=None, *args, **kwargs):
""" Handles the request, taking care of common things and delegating
control to the subclass for fetching this view-specific data.
"""
initial_input_dict = initial_input_dict or {}
initial_return_data = initial_return_data or {}
self.input_dict.clear()
self.clear_user_message()
try:
super(CreateEdit, self).__call__(req, *args, **kwargs)
self.set_input()
self.populate_initial_input_dict(initial_input_dict)
input_dict = {'cluster_id': self.cluster_id}
post_id = self.req.POST.get('id')
if post_id:
input_dict['id'] = post_id
input_dict.update(initial_input_dict)
for name in chain(self.SimpleIO.input_required, self.SimpleIO.input_optional):
if name not in input_dict and name not in self.input_dict:
value = self.input.get(name)
value = self.pre_process_item(name, value)
if value != SKIP_VALUE:
input_dict[name] = value
self.input_dict.update(input_dict)
self.pre_process_input_dict(self.input_dict)
logger.info('Request self.input_dict %s', self.input_dict)
logger.info('Request self.SimpleIO.input_required %s', self.SimpleIO.input_required)
logger.info('Request self.SimpleIO.input_optional %s', self.SimpleIO.input_optional)
logger.info('Request self.input %s', self.input)
logger.info('Request self.req.GET %s', self.req.GET)
logger.info('Request self.req.POST %s', self.req.POST)
logger.info('Sending `%s` to `%s`', self.input_dict, self.service_name)
response = self.req.zato.client.invoke(self.service_name, self.input_dict)
if response.ok:
logger.info('Received `%s` from `%s`', response.data, self.service_name)
return_data = {
'message': self.success_message(response.data)
}
return_data.update(initial_return_data)
for name in chain(self.SimpleIO.output_optional, self.SimpleIO.output_required):
if name not in initial_return_data:
value = getattr(response.data, name, None)
if value:
value = str(value)
return_data[name] = value
self.post_process_return_data(return_data)
logger.info('CreateEdit data for frontend `%s`', return_data)
return HttpResponse(dumps(return_data), content_type='application/javascript')
else:
msg = 'response:`{}`, details.response.details:`{}`'.format(response, response.details)
logger.error(msg)
raise ZatoException(msg=msg)
except Exception:
return HttpResponseServerError(format_exc())
def pre_process_input_dict(self, input_dict):
pass
def pre_process_item(self, name, value):
return value
def success_message(self, item):
raise NotImplementedError('Must be implemented by a subclass')
def post_process_return_data(self, return_data):
return return_data
@property
def verb(self):
if self.form_prefix:
return 'updated'
return 'created'
# ################################################################################################################################
class BaseCallView(BaseView):
method_allowed = 'POST'
error_message = 'error_message-must-be-defined-in-a-subclass'
def get_input_dict(self):
raise NotImplementedError('Must be defined in subclasses')
def build_http_response(self, response):
return HttpResponse()
def __call__(self, req, initial_input_dict=None, *args, **kwargs):
initial_input_dict = initial_input_dict or {}
try:
super(BaseCallView, self).__call__(req, *args, **kwargs)
input_dict = self.get_input_dict()
input_dict.update(initial_input_dict)
response = req.zato.client.invoke(self.service_name or self.get_service_name(), input_dict)
http_response = self.build_http_response(response)
return http_response
except Exception:
msg = '{}, e:`{}`'.format(self.error_message, format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
class Delete(BaseCallView):
""" Our subclasses will delete objects such as connections and others.
"""
id_elem = 'id'
def get_input_dict(self):
return {
self.id_elem: self.req.zato.id,
'cluster_id': self.cluster_id
}
# ################################################################################################################################
class SecurityList:
def __init__(self, needs_def_type_name_label=True):
self.needs_def_type_name_label = needs_def_type_name_label
self.def_items = []
def __iter__(self):
return iter(self.def_items)
def append(self, def_item):
value = '{}/{}'.format(def_item.sec_type, def_item.id)
if self.needs_def_type_name_label:
label = '{}/{}'.format(SEC_DEF_TYPE_NAME[def_item.sec_type], def_item.name)
else:
label = def_item.name
self.def_items.append((value, label))
@staticmethod
def from_service(client, cluster_id, sec_type=None, needs_def_type_name_label=True):
out = SecurityList(needs_def_type_name_label=needs_def_type_name_label)
sec_type = sec_type if isinstance(sec_type, list) else [sec_type]
result = client.invoke('zato.security.get-list', {
'cluster_id': cluster_id,
})
for def_item in result:
out.append(def_item)
return out
# ################################################################################################################################
def id_only_service(req, service, id, error_template='{}', initial=None):
try:
request = {
'cluster_id': req.zato.cluster_id,
}
if id:
request['id'] = id
if initial:
request.update(initial)
logger.info('Sending `%s` to `%s` (id_only_service)', request, service)
result = req.zato.client.invoke(service, request)
if not result.ok:
raise Exception(result.details)
else:
return result
except Exception as e:
msg = error_template.format(e.args[0])
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
def ping_connection(req, service, connection_id, connection_type='{}', ping_path=None) -> 'any_':
error_template = 'Could not ping {}, e:`{{}}`'.format(connection_type)
if ping_path:
initial = {'ping_path': ping_path}
else:
initial = None
response = id_only_service(req, service, connection_id, error_template, initial)
if isinstance(response, HttpResponseServerError):
return response
else:
if 'info' in response.data:
is_success = response.data.is_success
response_class = HttpResponse if is_success else HttpResponseServerError
info = response.data.info
else:
response_class = HttpResponse
info = 'Ping OK'
return response_class(info)
# ################################################################################################################################
def invoke_service_with_json_response(req, service, input_dict, ok_msg, error_template='', content_type='application/javascript',
extra=None):
try:
req.zato.client.invoke(service, input_dict)
except Exception as e:
return HttpResponseServerError(e.message, content_type=content_type)
else:
response = {'msg': ok_msg}
response.update(extra or {})
response = dumps(response)
return HttpResponse(response, content_type=content_type)
# ################################################################################################################################
def upload_to_server(
client,
data,
payload_name,
cluster_id=1,
service='zato.service.upload-package',
error_msg_template='Deployment error, e:`{}`',
):
try:
# First, check if the source code is valid
validate_python_syntax(data)
input_dict = {
'cluster_id': cluster_id,
'payload': b64encode(data),
'payload_name': payload_name,
}
response = client.invoke(service, input_dict)
out = {
'success': True,
'data':'OK, deployed',
'response_time_human': response.inner.headers.get('X-Zato-Response-Time-Human')
}
return HttpResponse(dumps(out))
except SyntaxError:
out = {
'success': False,
'data':format_exc(),
'response_time_human': 'default' # This is required by the frontend
}
return HttpResponseBadRequest(dumps(out))
except Exception:
msg = error_msg_template.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
def extract_security_id(item):
# type: (dict) -> int
security_id = item.get('security_id') # type: str
if not security_id:
return
else:
if security_id == ZATO_NONE:
return security_id
else:
security_id = security_id.split('/')
security_id = security_id[1]
return int(security_id)
# ################################################################################################################################
def get_http_channel_security_id(item):
_security_id = item.security_id
if _security_id:
security_id = '{}/{}'.format(item.sec_type, _security_id)
else:
if item.sec_use_rbac:
security_id = ZATO_SEC_USE_RBAC
else:
security_id = ZATO_NONE
return security_id
# ################################################################################################################################
def invoke_action_handler(req, service_name:'str', send_attrs:'any_'=None, extra=None) -> 'any_':
try:
request = {
'cluster_id': req.zato.cluster_id
}
send_attrs = send_attrs or {}
for name in send_attrs:
request[name] = req.POST.get(name, '')
extra = extra or {}
request.update(extra)
logger.info('Invoking `%s` with `%s`', service_name, request)
response = req.zato.client.invoke(service_name, request)
logger.info('Response received `%s`', response.data)
if response.ok:
if 'response_data' in (response.data or ''):
response_data = response.data['response_data']
else:
response_data = response.data
logger.info('Invocation response -> `%s` (`%s`)', response_data, service_name)
if isinstance(response_data, dict):
response_data = dumps(response_data)
logger.info('Returning `%s` from `%s`', response_data, service_name)
return HttpResponse(response_data, content_type='application/javascript')
else:
logger.warn('Raising exception based on `%s` (`%s`)', response.details, service_name)
raise Exception(response.details)
except Exception:
msg = 'Caught an exception, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
def get_security_name_link(req, sec_type, sec_name, *, needs_type=True):
sec_type_name = SEC_DEF_TYPE_NAME[sec_type]
sec_type_as_link = sec_type.replace('_', '-')
security_href = f'/zato/security/{sec_type_as_link}/?cluster={req.zato.cluster_id}&query={sec_name}'
security_link = f'<a href="{security_href}">{sec_name}</a>'
if needs_type:
sec_name = f'{sec_type_name}<br/>{security_link}'
else:
sec_name = security_link
return sec_name
# ################################################################################################################################
# ################################################################################################################################
def get_group_list(req:'any_', group_type:'str', *, http_soap_channel_id:'str'='') -> 'anylist':
# Get a list of all the groups that exist
response = req.zato.client.invoke('zato.groups.get-list', {
'group_type': group_type,
})
# .. extract the business data ..
groups = response.data or []
# .. if we have a channel ID on input, we need to indicate which groups are assigned to it ..
if http_soap_channel_id:
http_soap_channel = req.zato.client.invoke('zato.http-soap.get', {
'id': http_soap_channel_id,
})
http_soap_channel = http_soap_channel.data
http_soap_channel_security_groups = http_soap_channel.get('security_groups') or []
for item in groups:
if item.id in http_soap_channel_security_groups:
item.is_assigned = True
else:
item.is_assigned = False
# .. and return it to our caller.
return groups
# ################################################################################################################################
# ################################################################################################################################
| 37,705
|
Python
|
.py
| 780
| 38.847436
| 159
| 0.528968
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,712
|
scheduler.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/scheduler.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
from datetime import datetime
from io import StringIO
from traceback import format_exc
# ciso8601
try:
from zato.common.util.api import parse_datetime
except ImportError:
from dateutil.parser import parse as parse_datetime
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template.response import TemplateResponse
# pytz
from pytz import UTC
# Zato
from zato.admin.web import from_user_to_utc, from_utc_to_user
from zato.admin.web.views import get_js_dt_format, method_allowed, Delete as _Delete, parse_response_data
from zato.admin.settings import job_type_friendly_names
from zato.admin.web.forms.scheduler import CronStyleSchedulerJobForm, IntervalBasedSchedulerJobForm, OneTimeSchedulerJobForm
from zato.common.api import SCHEDULER, TRACE1
from zato.common.exception import ZatoException
from zato.common.json_internal import dumps
from zato.common.odb.model import CronStyleJob, IntervalBasedJob, Job
from zato.common.util.api import pprint
# Python 2/3 compatibility
from zato.common.py23_.past.builtins import unicode
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
create_one_time_prefix = 'create-one_time'
create_interval_based_prefix = 'create-interval_based'
create_cron_style_prefix = 'create-cron_style'
edit_one_time_prefix = 'edit-one_time'
edit_interval_based_prefix = 'edit-interval_based'
edit_cron_style_prefix = 'edit-cron_style'
# ################################################################################################################################
# ################################################################################################################################
def _get_start_date(start_date):
if not start_date:
return ''
if not isinstance(start_date, datetime):
start_date = parse_datetime(start_date)
return start_date.replace(tzinfo=UTC)
# ################################################################################################################################
# ################################################################################################################################
def _one_time_job_def(user_profile, start_date):
start_date = _get_start_date(start_date)
return 'Execute once on {0} at {1}'.format(
from_utc_to_user(start_date, user_profile, 'date'),
from_utc_to_user(start_date, user_profile, 'time'))
# ################################################################################################################################
# ################################################################################################################################
def _interval_based_job_def(user_profile, start_date, repeats, weeks, days, hours, minutes, seconds):
buf = StringIO()
if start_date:
buf.write('Start on {} at {}.'.format(
from_utc_to_user(start_date, user_profile, 'date'),
from_utc_to_user(start_date, user_profile, 'time')))
if not repeats:
buf.write(' Repeat indefinitely.')
else:
if repeats == 1:
buf.write(' Execute once.')
elif repeats == 2:
buf.write(' Repeat twice.')
# .. thrice or more
elif int(repeats) > 2:
buf.write(' Repeat ')
if isinstance(repeats, int):
repeats = str(repeats)
else:
repeats = repeats if isinstance(repeats, unicode) else repeats.decode('utf8')
buf.write(repeats)
buf.write(' times.')
interval = []
buf.write(' Interval: ')
for name, value in (('week',weeks), ('day',days), ('hour',hours), ('minute',minutes), ('second',seconds)):
if value:
try:
value = int(value)
except ValueError:
logger.warning('Cannot convert `%s` `%s` to an int, `%s` `%s` `%s` `%s` `%s` `%s` `%s`',
name, value, start_date, repeats, weeks, days, hours, minutes, seconds)
else:
interval.append('{} {}{}'.format(value, name, 's' if value > 1 else ''))
buf.write(', '.join(interval))
buf.write('.')
return buf.getvalue()
# ################################################################################################################################
# ################################################################################################################################
def _get_success_message(action, job_type, job_name):
msg = 'Successfully {} the {} job `{}`'
verb = 'created' if action == 'create' else 'updated'
job_type = job_type.replace('_', '-')
return msg.format(verb, job_type, job_name)
# ################################################################################################################################
# ################################################################################################################################
def _cron_style_job_def(user_profile, start_date, cron_definition):
start_date = _get_start_date(start_date)
buf = StringIO()
buf.write('Start on {} at {}.'.format(
from_utc_to_user(start_date, user_profile, 'date'),
from_utc_to_user(start_date, user_profile, 'time')))
buf.write('<br/>{}'.format(cron_definition))
return buf.getvalue()
# ################################################################################################################################
# ################################################################################################################################
def _get_create_edit_message(user_profile, cluster, params, form_prefix=''):
""" A dictionary of core data which can be used by both 'edit' and 'create'
actions, regardless of the job's type.
"""
start_date = params.get(form_prefix + 'start_date', '')
if start_date:
start_date = from_user_to_utc(start_date, user_profile)
return {
'name': params[form_prefix + 'name'],
'cluster_id': cluster.id,
'id': params.get(form_prefix + 'id', ''),
'is_active': bool(params.get(form_prefix + 'is_active')),
'service': params.get(form_prefix + 'service', ''),
'extra': params.get(form_prefix + 'extra', ''),
'start_date': start_date.isoformat(),
}
# ################################################################################################################################
# ################################################################################################################################
def _get_create_edit_one_time_message(user_profile, cluster, params, form_prefix=''):
""" Creates a base document which can be used by both 'edit' and 'create'
actions. Used when creating one_time jobs.
"""
input_dict = _get_create_edit_message(user_profile, cluster, params, form_prefix)
input_dict['job_type'] = SCHEDULER.JOB_TYPE.ONE_TIME
return input_dict
# ################################################################################################################################
# ################################################################################################################################
def _get_create_edit_interval_based_message(user_profile, cluster, params, form_prefix=''):
""" A dictionary of core data which can be used by both 'edit' and 'create'
actions. Used when creating interval_based jobs.
"""
input_dict =_get_create_edit_message(user_profile, cluster, params, form_prefix)
input_dict['job_type'] = SCHEDULER.JOB_TYPE.INTERVAL_BASED
input_dict['weeks'] = params.get(form_prefix + 'weeks', '')
input_dict['days'] = params.get(form_prefix + 'days', '')
input_dict['hours'] = params.get(form_prefix + 'hours', '')
input_dict['seconds'] = params.get(form_prefix + 'seconds', '')
input_dict['minutes'] = params.get(form_prefix + 'minutes', '')
input_dict['repeats'] = params.get(form_prefix + 'repeats', '')
return input_dict
# ################################################################################################################################
# ################################################################################################################################
def _get_create_edit_cron_style_message(user_profile, cluster, params, form_prefix=''):
""" A dictionary of core data which can be used by both 'edit' and 'create'
actions. Used when creating cron_style jobs.
"""
input_dict =_get_create_edit_message(user_profile, cluster, params, form_prefix)
input_dict['job_type'] = SCHEDULER.JOB_TYPE.CRON_STYLE
input_dict['cron_definition'] = params[form_prefix + 'cron_definition']
return input_dict
# ################################################################################################################################
# ################################################################################################################################
def _create_one_time(client, user_profile, cluster, params):
""" Creates a one_time scheduler job.
"""
logger.debug('About to create a one_time job, cluster.id:[{0}], params:[{1}]'.format(cluster.id, params))
input_dict = _get_create_edit_one_time_message(user_profile, cluster, params, create_one_time_prefix+'-')
response = client.invoke('zato.scheduler.job.create', input_dict)
logger.debug('Successfully created a one_time job, cluster.id:[{0}], params:[{1}]'.format(cluster.id, params))
return {'id': response.data.id, 'definition_text':_one_time_job_def(user_profile, input_dict['start_date'])}
# ################################################################################################################################
# ################################################################################################################################
def _create_interval_based(client, user_profile, cluster, params):
""" Creates an interval_based scheduler job.
"""
logger.debug('About to create an interval_based job, cluster.id:[{0}], params:[{1}]'.format(cluster.id, params))
input_dict = _get_create_edit_interval_based_message(user_profile, cluster, params, create_interval_based_prefix+'-')
response = client.invoke('zato.scheduler.job.create', input_dict)
logger.debug('Successfully created an interval_based job, cluster.id:[{0}], params:[{1}]'.format(cluster.id, params))
start_date = input_dict.get('start_date')
if start_date:
start_date = _get_start_date(start_date)
repeats = params.get('create-interval_based-repeats')
repeats = int(repeats) if repeats else None
weeks = params.get('create-interval_based-weeks')
days = params.get('create-interval_based-days')
hours = params.get('create-interval_based-hours')
minutes = params.get('create-interval_based-minutes')
seconds = params.get('create-interval_based-seconds')
definition = _interval_based_job_def(user_profile, start_date, repeats, weeks, days, hours, minutes, seconds)
return {'id': response.data.id, 'definition_text':definition}
# ################################################################################################################################
# ################################################################################################################################
def _create_cron_style(client, user_profile, cluster, params):
""" Creates a cron_style scheduler job.
"""
logger.debug('About to create a cron_style job, cluster.id:`%s`, params:`%s`', cluster.id, params)
input_dict = _get_create_edit_cron_style_message(user_profile, cluster, params, create_cron_style_prefix+'-')
response = client.invoke('zato.scheduler.job.create', input_dict)
if response.ok:
cron_definition = response.data.cron_definition
logger.debug('Successfully created a cron_style job, cluster.id:`%s`, params:`%s`', cluster.id, params)
return {'id': response.data.id,
'definition_text':_cron_style_job_def(user_profile,
input_dict['start_date'], cron_definition),
'cron_definition': cron_definition}
else:
raise Exception(response.details)
# ################################################################################################################################
# ################################################################################################################################
def _edit_one_time(client, user_profile, cluster, params):
""" Updates a one_time scheduler job.
"""
logger.debug('About to change a one_time job, cluster.id:`%s`, params:`%s`', cluster.id, params)
input_dict = _get_create_edit_one_time_message(user_profile, cluster, params, edit_one_time_prefix+'-')
client.invoke('zato.scheduler.job.edit', input_dict)
logger.debug('Successfully updated a one_time job, cluster.id:`%s`, params:`%s`', cluster.id, params)
return {'definition_text':_one_time_job_def(user_profile, input_dict['start_date']), 'id':params['edit-one_time-id']}
# ################################################################################################################################
# ################################################################################################################################
def _edit_interval_based(client, user_profile, cluster, params):
""" Creates an interval_based scheduler job.
"""
logger.debug('About to change an interval_based job, cluster.id:`%s`, params:`%s`', cluster.id, params)
input_dict = _get_create_edit_interval_based_message(user_profile, cluster, params, edit_interval_based_prefix+'-')
client.invoke('zato.scheduler.job.edit', input_dict)
logger.debug('Successfully updated an interval_based job, cluster.id:`%s`, params:`%s`', cluster.id, params)
start_date = input_dict.get('start_date')
if start_date:
start_date = _get_start_date(start_date)
repeats = params.get('edit-interval_based-repeats')
repeats = int(repeats) if repeats else None
weeks = params.get('edit-interval_based-weeks')
days = params.get('edit-interval_based-days')
hours = params.get('edit-interval_based-hours')
minutes = params.get('edit-interval_based-minutes')
seconds = params.get('edit-interval_based-seconds')
definition = _interval_based_job_def(user_profile, start_date, repeats, weeks, days, hours, minutes, seconds)
return {'definition_text':definition, 'id':params['edit-interval_based-id']}
# ################################################################################################################################
# ################################################################################################################################
def _edit_cron_style(client, user_profile, cluster, params):
""" Creates an cron_style scheduler job.
"""
logger.debug('About to change a cron_style job, cluster.id:`%s`, params:`%s`', cluster.id, params)
input_dict = _get_create_edit_cron_style_message(user_profile, cluster, params, edit_cron_style_prefix+'-')
response = client.invoke('zato.scheduler.job.edit', input_dict)
if response.ok:
cron_definition = response.data.cron_definition
logger.debug('Successfully updated a cron_style job, cluster.id:`%s`, params:`%s`', cluster.id, params)
start_date = _get_start_date(input_dict.get('start_date'))
definition = _cron_style_job_def(user_profile, start_date, cron_definition)
return {'definition_text':definition, 'cron_definition': cron_definition, 'id':params['edit-cron_style-id']}
else:
raise Exception(response.details)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET', 'POST')
def index(req):
try:
jobs = []
meta = None
# Build a list of schedulers for a given Zato cluster.
if req.zato.cluster_id and req.method == 'GET':
# We have a cluster to pick the schedulers from, try to invoke it now.
request = {
'cluster_id': req.zato.cluster_id,
'paginate': True,
'cur_page': req.GET.get('cur_page', 1),
'query': req.GET.get('query', '')
}
data, meta = parse_response_data(req.zato.client.invoke('zato.scheduler.job.get-list', request))
for job_elem in data:
id = job_elem.id
name = job_elem.name
is_active = job_elem.is_active
job_type = job_elem.job_type
start_date = job_elem.start_date
service_name = job_elem.service_name
extra = job_elem.extra
job_type_friendly = job_type_friendly_names[job_type]
job = Job(id, name, is_active, job_type,
from_utc_to_user(start_date+'+00:00', req.zato.user_profile),
extra, service_name=service_name,
job_type_friendly=job_type_friendly)
if job_type == SCHEDULER.JOB_TYPE.ONE_TIME:
definition_text=_one_time_job_def(req.zato.user_profile, start_date)
elif job_type == SCHEDULER.JOB_TYPE.INTERVAL_BASED:
definition_text = _interval_based_job_def(req.zato.user_profile,
_get_start_date(job_elem.start_date),
job_elem.repeats, job_elem.weeks, job_elem.days,
job_elem.hours, job_elem.minutes, job_elem.seconds)
weeks = job_elem.weeks or ''
days = job_elem.days or ''
hours = job_elem.hours or ''
minutes = job_elem.minutes or ''
seconds = job_elem.seconds or ''
repeats = job_elem.repeats or ''
ib_job = IntervalBasedJob(None, None, weeks, days, hours, minutes, seconds, repeats)
job.interval_based = ib_job
elif job_type == SCHEDULER.JOB_TYPE.CRON_STYLE:
cron_definition = job_elem.cron_definition or ''
definition_text=_cron_style_job_def(req.zato.user_profile, start_date, cron_definition)
cs_job = CronStyleJob(None, None, cron_definition)
job.cron_style = cs_job
else:
msg = 'Unrecognized job type, name:`{}`, type:`{}`'.format(name, job_type)
logger.error(msg)
raise ZatoException(msg)
job.definition_text = definition_text
jobs.append(job)
if req.method == 'POST':
action = req.POST.get('zato_action', '')
if not action:
msg = 'req.POST contains no [zato_action] parameter.'
logger.error(msg)
return HttpResponseServerError(msg)
job_type = req.POST.get('job_type', '')
if action != 'execute' and not job_type:
msg = 'req.POST contains no [job_type] parameter.'
logger.error(msg)
return HttpResponseServerError(msg)
job_name = req.POST['{0}-{1}-name'.format(action, job_type)]
# Try to match the action and a job type with an action handler..
handler_name = '_' + action
if action != 'execute':
handler_name += '_' + job_type
handler = globals().get(handler_name)
if not handler:
msg = ('No handler found for action [{0}], job_type:[{1}], '
'req.POST:[{2}], req.GET:[{3}].'.format(action, job_type,
pprint(req.POST), pprint(req.GET)))
logger.error(msg)
return HttpResponseServerError(msg)
# .. invoke the action handler.
try:
response = handler(req.zato.client, req.zato.user_profile, req.zato.cluster, req.POST)
response = response if response else ''
if response:
response['message'] = _get_success_message(action, job_type, job_name)
response = dumps(response)
return HttpResponse(response, content_type='application/javascript')
except Exception:
msg = 'Could not invoke action `{}`, job_type:`{}`, e:`{}` req.POST:`{}`, req.GET:`{}'.format(
action, job_type, format_exc(), req.POST, req.GET)
logger.error(msg)
return HttpResponseServerError(msg)
template_name = 'zato/scheduler.html'
return_data = {'zato_clusters':req.zato.clusters,
'cluster_id':req.zato.cluster_id,
'search_form':req.zato.search_form,
'jobs':jobs,
'friendly_names':job_type_friendly_names.items(),
'create_one_time_form':OneTimeSchedulerJobForm(create_one_time_prefix, req),
'create_interval_based_form':IntervalBasedSchedulerJobForm(create_interval_based_prefix, req),
'create_cron_style_form':CronStyleSchedulerJobForm(create_cron_style_prefix, req),
'edit_one_time_form':OneTimeSchedulerJobForm(edit_one_time_prefix, req),
'edit_interval_based_form':IntervalBasedSchedulerJobForm(edit_interval_based_prefix, req),
'edit_cron_style_form':CronStyleSchedulerJobForm(edit_cron_style_prefix, req),
'paginate':True,
'meta': meta,
'req': req,
'zato_template_name': template_name,
}
return_data.update(get_js_dt_format(req.zato.user_profile))
return TemplateResponse(req, template_name, return_data)
except Exception:
msg = '<pre>Method could not be invoked, e:`{}`</pre>'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'scheduler-job-delete'
error_message = 'Could not delete the job'
service_name = 'zato.scheduler.job.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def execute(req, job_id, cluster_id):
""" Executes a scheduler's job.
"""
try:
req.zato.client.invoke('zato.scheduler.job.execute', {'id':job_id})
except Exception:
msg = 'Job could not be executed. job_id:`{}`, cluster_id:`{}`, e:`{}`'.format(job_id, cluster_id, format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
else:
# 200 OK
return HttpResponse()
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def get_definition(req, start_date, repeats, weeks, days, hours, minutes, seconds) -> 'HttpResponse':
start_date = _get_start_date(start_date)
definition = _interval_based_job_def(req.user_profile, start_date, repeats, weeks, days, hours, minutes, seconds)
logger.log(TRACE1, 'definition:[{}]'.format(definition))
return HttpResponse(definition)
# ################################################################################################################################
# ################################################################################################################################
| 25,041
|
Python
|
.py
| 406
| 53.458128
| 130
| 0.488395
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,713
|
main.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/main.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2021, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
from logging import getLogger
# Django
from django.contrib.auth import authenticate, login as django_login, logout as django_logout
from django.http import HttpResponseRedirect
from django.shortcuts import resolve_url
from django.template.response import TemplateResponse
from django.utils.http import url_has_allowed_host_and_scheme as is_safe_url
# PyOTP
import pyotp
# Zato
from zato.admin.settings import LOGIN_REDIRECT_URL
from zato.admin import zato_settings
from zato.admin.web.forms.main import AuthenticationForm
from zato.admin.web.util import get_user_profile
from zato.admin.web.views import method_allowed
from zato.common.crypto.api import CryptoManager
# ################################################################################################################################
logger = getLogger(__name__)
# ################################################################################################################################
@method_allowed('GET')
def index_redirect(req):
return HttpResponseRedirect('/zato')
# ################################################################################################################################
@method_allowed('GET')
def index(req):
return TemplateResponse(req, 'zato/index.html')
# ################################################################################################################################
def get_login_response(req, needs_post_form_data, has_errors):
form = AuthenticationForm(req.POST if needs_post_form_data else None)
return TemplateResponse(req, 'zato/login.html', {
'form': form,
'next': req.GET.get('next', ''),
'is_totp_enabled': zato_settings.is_totp_enabled,
'has_errors': has_errors or form.errors
})
# ################################################################################################################################
def login(req):
logger.info('Login request received')
# By default, assume the credentials are invalid unless proved otherwise
has_errors = True
# If it is a GET request, we only return the form to display
if req.method == 'GET':
needs_post_form_data = False
logger.info('Login request -> GET')
# No data was POST-ed so there cannot be any errors yet
has_errors = False
else:
logger.info('Login request -> POST')
# Get credentials from request
username = req.POST['username']
password = req.POST['password']
totp_code = req.POST.get('totp_code') or -1
logger.info('Login username -> `%s`', username)
# Check if basic credentials are valid
user = authenticate(username=username, password=password)
# If they are ..
if user is not None:
# Log in the user to site because we need the Django user object
django_login(req, user)
logger.info('User password confirmed `%s`', username)
# If TOTP is enabled, make sure that it matches what is expected
if zato_settings.is_totp_enabled:
logger.info('TOTP is enabled')
# At this point the user is logged in but we still do not have the person's profile
# so we need to look it up ourselves instead of relying on req.zato.user_profile.
user_profile = get_user_profile(req.user)
# This is what we have configured for user
user_totp_data = user_profile.get_totp_data()
# TOTP is required but it is not set for user, we need to reject such a request
if not user_totp_data.key:
logger.warning('No TOTP key for user `%s`', username)
return get_login_response(req, True, True)
# Decrypt the key found in the user profile
cm = CryptoManager(secret_key=zato_settings.zato_secret_key)
user_totp_key_decrypted = cm.decrypt(user_totp_data.key)
# Confirm that what user provided is what we expected
totp = pyotp.TOTP(user_totp_key_decrypted)
if not totp.verify(totp_code):
logger.warning('Invalid TOTP code received')
return get_login_response(req, True, True)
# Make sure the redirect-to address is valid
redirect_to = req.POST.get('next', '') or req.GET.get('next', '')
if not is_safe_url(url=redirect_to, allowed_hosts=req.get_host()):
redirect_to = resolve_url(LOGIN_REDIRECT_URL)
# At this point we know that all the possible credentials are valid
# so we can log the user in and redirect the person further.
logger.info('User credentials are valid, redirecting `%s` to `%s`', username, redirect_to)
return HttpResponseRedirect(redirect_to)
else:
logger.warning('User password validation error `%s`', username)
needs_post_form_data = True
# Here, we know that we need to return the form, either because it is a GET request
# or because it was POST but credentials were invalid
return get_login_response(req, needs_post_form_data, has_errors)
# ################################################################################################################################
@method_allowed('GET')
def logout(req):
django_logout(req)
return index_redirect(req)
# ################################################################################################################################
| 5,777
|
Python
|
.py
| 106
| 46.443396
| 130
| 0.555891
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,714
|
load_balancer.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/load_balancer.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
from traceback import format_exc
from xmlrpc.client import Fault
# OrderedDict is new in 2.7
try:
from collections import OrderedDict
except ImportError:
from ordereddict import OrderedDict
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template.response import TemplateResponse
# Python 2/3 compatibility
from zato.common.ext.future.utils import iteritems
# Zato
from zato.admin.web import from_utc_to_user
from zato.admin.web.forms.load_balancer import ManageLoadBalancerForm, RemoteCommandForm, \
ManageLoadBalancerSourceCodeForm
from zato.admin.web.views import get_lb_client, method_allowed
from zato.common.haproxy import haproxy_stats, Config
from zato.common.json_internal import dumps
from zato.common.odb.model import Cluster
logger = logging.getLogger(__name__)
def _haproxy_alive(client, lb_use_tls):
""" Check whether HAProxy is up and running. If 'status' is True then HAProxy
is alive, sets 'status' to False otherwise and fills in the 'error' attribute
with the details of an exception caught.
"""
haproxy_alive = {}
try:
client.is_haproxy_alive(lb_use_tls)
except Exception:
haproxy_alive['status'] = False
haproxy_alive['error'] = format_exc()
else:
haproxy_alive['status'] = True
return haproxy_alive
def _haproxy_stat_config(client=None, lb_config=None):
""" Return the configuration of the HAProxy HTTP stats interface.
"""
if not lb_config:
lb_config = client.get_config()
# Stats URI is optional
try:
stats_uri = lb_config['defaults']['stats_uri']
except KeyError:
return None, None
else:
stats_port = lb_config['frontend']['front_http_plain']['bind']['port']
return stats_uri, stats_port
def _get_validate_save_flag(cluster_id, req_post):
""" A convenience function for checking we were told to validate & save
a config or was it a request for validating it only.
"""
if 'validate_save' in req_post:
save = True
elif 'validate' in req_post:
save = False
else:
msg = 'Expected a flag indicating what to do with input data. cluster_id:`{}` req.POST:`{}`'
msg = msg.format(cluster_id, req_post)
logger.error(msg)
raise Exception(msg)
return save
def _client_validate_save(req, func, *args):
""" A convenience function for validating or validating & saving a config
file on a remote SSL XML-RPC server.
"""
save = args[1]
has_error = False
try:
func(*args)
except Fault as e:
msg = e.faultString
has_error = True
except Exception:
msg = format_exc()
has_error = True
if has_error:
msg = 'Caught an exception while invoking the load-balancer agent, e:`{}`'.format(msg)
logger.error(msg)
return HttpResponseServerError(msg)
else:
if save:
return HttpResponse('Config validated and saved successfully')
else:
return HttpResponse("Config is valid, it's safe to save it")
@method_allowed('GET', 'POST')
def remote_command(req, cluster_id):
""" Execute a HAProxy command.
"""
cluster = req.zato.odb.query(Cluster).filter_by(id=cluster_id).one()
client = get_lb_client(cluster)
haproxy_alive = _haproxy_alive(client, req.zato.lb_use_tls)
cluster.stats_uri, cluster.stats_port = _haproxy_stat_config(client=client)
# We need to know the HAProxy version before we can build up the select box
# on the form.
commands = haproxy_stats[('1', '3')]
version_info = tuple(client.haproxy_version_info())
if version_info >= ('1', '4'):
commands.update(haproxy_stats[('1', '4')])
if req.method == 'POST':
result = client.execute_command(req.POST['command'], req.POST['timeout'], req.POST.get('extra', ''))
if not result.strip():
result = '(empty result)'
initial={'result':result}
for k, v in req.POST.items():
if k != 'result':
initial[k] = v
form = RemoteCommandForm(commands, initial)
else:
form = RemoteCommandForm(commands)
return_data = {'form':form, 'cluster':cluster, 'haproxy_alive':haproxy_alive, 'lb_use_tls': req.zato.lb_use_tls}
return TemplateResponse(req, 'zato/load_balancer/remote_command.html', return_data)
@method_allowed('GET')
def manage(req, cluster_id):
""" GUI for managing HAProxy configuration.
"""
cluster = req.zato.odb.query(Cluster).filter_by(id=cluster_id).one()
client = get_lb_client(cluster)
lb_start_time = from_utc_to_user(client.get_uptime_info(), req.zato.user_profile)
lb_config = client.get_config()
lb_work_config = client.get_work_config()
lb_work_config['verify_fields'] = ', '.join(['%s=%s' % (k,v) for (k, v) in sorted(iteritems(lb_work_config['verify_fields']))])
form_data = {
'global_log_host': lb_config['global_']['log']['host'],
'global_log_port': lb_config['global_']['log']['port'],
'global_log_level': lb_config['global_']['log']['level'],
'global_log_facility': lb_config['global_']['log']['facility'],
'timeout_connect': lb_config['defaults']['timeout_connect'],
'timeout_client': lb_config['defaults']['timeout_client'],
'timeout_server': lb_config['defaults']['timeout_server'],
'http_plain_bind_address':lb_config['frontend']['front_http_plain']['bind']['address'],
'http_plain_bind_port':lb_config['frontend']['front_http_plain']['bind']['port'],
'http_plain_log_http_requests':lb_config['frontend']['front_http_plain']['log_http_requests'],
'http_plain_maxconn':lb_config['frontend']['front_http_plain']['maxconn'],
'http_plain_monitor_uri':lb_config['frontend']['front_http_plain']['monitor_uri'],
}
backends = {}
for backend_type in lb_config['backend']:
for name in lb_config['backend'][backend_type]:
# Is it a server?
if 'address' in lb_config['backend'][backend_type][name]:
if not name in backends:
backends[name] = {}
backends[name][backend_type] = {}
backends[name][backend_type]['address'] = lb_config['backend'][backend_type][name]['address']
backends[name][backend_type]['port'] = lb_config['backend'][backend_type][name]['port']
backends[name][backend_type]['extra'] = lb_config['backend'][backend_type][name]['extra']
backends = OrderedDict(sorted(backends.items(), key=lambda t: t[0]))
form = ManageLoadBalancerForm(initial=form_data)
haproxy_alive = _haproxy_alive(client, req.zato.lb_use_tls)
cluster.stats_uri, cluster.stats_port = _haproxy_stat_config(lb_config=lb_config)
servers_state = client.get_servers_state()
return_data = {'cluster':cluster, 'lb_start_time':lb_start_time,
'lb_config':lb_config, 'lb_work_config':lb_work_config,
'form':form, 'backends':backends, 'haproxy_alive':haproxy_alive,
'servers_state':servers_state, 'lb_use_tls': req.zato.lb_use_tls}
return TemplateResponse(req, 'zato/load_balancer/manage.html', return_data)
@method_allowed('POST')
def validate_save(req, cluster_id):
""" A common handler for both validating and saving a HAProxy config using
a pretty GUI form.
"""
save = _get_validate_save_flag(cluster_id, req.POST)
cluster = req.zato.odb.query(Cluster).filter_by(id=cluster_id).one()
client = get_lb_client(cluster)
lb_config = Config()
lb_config.global_['log'] = {}
lb_config.frontend['front_http_plain'] = {}
lb_config.frontend['front_http_plain']['bind'] = {}
lb_config.global_['log']['host'] = req.POST['global_log_host']
lb_config.global_['log']['port'] = req.POST['global_log_port']
lb_config.global_['log']['level'] = req.POST['global_log_level']
lb_config.global_['log']['facility'] = req.POST['global_log_facility']
lb_config.defaults['timeout_connect'] = req.POST['timeout_connect']
lb_config.defaults['timeout_client'] = req.POST['timeout_client']
lb_config.defaults['timeout_server'] = req.POST['timeout_server']
lb_config.frontend['front_http_plain']['bind']['address'] = req.POST['http_plain_bind_address']
lb_config.frontend['front_http_plain']['bind']['port'] = req.POST['http_plain_bind_port']
lb_config.frontend['front_http_plain']['log_http_requests'] = req.POST['http_plain_log_http_requests']
lb_config.frontend['front_http_plain']['maxconn'] = req.POST['http_plain_maxconn']
lb_config.frontend['front_http_plain']['monitor_uri'] = req.POST['http_plain_monitor_uri']
for key, value in req.POST.items():
if key.startswith('bck_http'):
for token in('address', 'port', 'extra'):
splitted = key.split(token)
if splitted[0] == key:
continue # We don't have the token in that key.
backend_type, backend_name = splitted
# Get rid of underscores left over from the .split above.
backend_type = backend_type[:-1]
backend_name = backend_name[1:]
lb_config.backend.setdefault(backend_type, {})
lb_config.backend[backend_type].setdefault(backend_name, {})
lb_config.backend[backend_type][backend_name][token] = value
# Invoke the LB agent
return _client_validate_save(req, client.validate_save, lb_config, save)
@method_allowed('GET')
def manage_source_code(req, cluster_id):
""" Source code view for managing HAProxy configuration.
"""
cluster = req.zato.odb.query(Cluster).filter_by(id=cluster_id).one()
client = get_lb_client(cluster)
cluster.stats_uri, cluster.stats_port = _haproxy_stat_config(client=client)
haproxy_alive = _haproxy_alive(client, req.zato.lb_use_tls)
source_code = client.get_config_source_code()
form = ManageLoadBalancerSourceCodeForm(initial={'source_code':source_code})
return_data = {'form': form, 'haproxy_alive':haproxy_alive, 'cluster':cluster, 'lb_use_tls': req.zato.lb_use_tls}
return TemplateResponse(req, 'zato/load_balancer/manage_source_code.html', return_data)
@method_allowed('POST')
def validate_save_source_code(req, cluster_id):
""" A common handler for both validating and saving a HAProxy config using
the raw HAProxy config file's view.
"""
cluster = req.zato.odb.query(Cluster).filter_by(id=cluster_id).one()
save = _get_validate_save_flag(cluster_id, req.POST)
# Invoke the LB agent
client = get_lb_client(cluster)
return _client_validate_save(req, client.validate_save_source_code, req.POST['source_code'], save)
@method_allowed('GET')
def get_addresses(req, cluster_id):
""" Return JSON-formatted addresses known to HAProxy.
"""
cluster = req.zato.odb.query(Cluster).filter_by(id=cluster_id).one()
client = get_lb_client(cluster)
addresses = {}
addresses['cluster'] = {'lb_host': cluster.lb_host, 'lb_agent_port':cluster.lb_agent_port}
try:
lb_config = client.get_config()
except Exception:
msg = 'Could not get load balancer\'s config, client:`{!r}`, e:`{}'.format(client, format_exc())
logger.error(msg)
lb_config = None
addresses['cluster']['lb_config'] = lb_config
return HttpResponse(dumps(addresses))
| 11,758
|
Python
|
.py
| 242
| 41.900826
| 131
| 0.662157
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,715
|
twilio.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/sms/twilio.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
from traceback import format_exc
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.forms.sms.twilio import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.json_internal import dumps
from zato.common.odb.model import SMSTwilio
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'sms-twilio'
template = 'zato/sms/twilio/index.html'
service_name = 'zato.sms.twilio.get-list'
output_class = SMSTwilio
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'account_sid', 'auth_token')
output_optional = ('default_from', 'default_to')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'account_sid', 'auth_token')
input_optional = ('default_from', 'default_to')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {} the SMS Twilio connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'sms-twilio-create'
service_name = 'zato.sms.twilio.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'sms-twilio-edit'
form_prefix = 'edit-'
service_name = 'zato.sms.twilio.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'sms-twilio-delete'
error_message = 'Could not delete the SMS Twilio connection'
service_name = 'zato.sms.twilio.delete'
# ################################################################################################################################
@method_allowed('GET')
def send_message(req, cluster_id, conn_id, name_slug):
response = req.zato.client.invoke('zato.sms.twilio.get', {
'cluster_id': cluster_id,
'id': conn_id,
})
if not response.ok:
raise Exception(response.details)
return_data = {
'cluster_id': cluster_id,
'name_slug': name_slug,
'item': response.data,
'conn_id': conn_id
}
return TemplateResponse(req, 'zato/sms/twilio/send-message.html', return_data)
# ################################################################################################################################
@method_allowed('POST')
def send_message_action(req, cluster_id, conn_id, name_slug):
try:
request = {
'cluster_id': req.zato.cluster_id,
'id': req.POST['id'],
'from_': req.POST['from_'],
'to': req.POST['to'],
'body': req.POST['body'],
}
response = req.zato.client.invoke('zato.sms.twilio.send-message', request)
if response.ok:
return HttpResponse(dumps({'msg': 'OK, message sent successfully.'}), content_type='application/javascript')
else:
raise Exception(response.details)
except Exception:
msg = 'Caught an exception, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
| 4,596
|
Python
|
.py
| 97
| 41.742268
| 130
| 0.486898
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,716
|
microsoft_365.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cloud/microsoft_365.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# Zato
from zato.admin.web.forms.cloud.microsoft_365 import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.api import GENERIC, generic_attrs
from zato.common.model.microsoft_365 import Microsoft365ConfigObject
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'cloud-microsoft-365'
template = 'zato/cloud/microsoft-365.html'
service_name = 'zato.generic.connection.get-list'
output_class = Microsoft365ConfigObject
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name', 'is_active', 'client_id', 'secret_value', 'scopes', 'tenant_id'
output_optional = generic_attrs
output_repeated = True
# ################################################################################################################################
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'id', 'name', 'is_active', 'client_id', 'secret_value', 'scopes', 'tenant_id'
output_required = 'id', 'name'
# ################################################################################################################################
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.CLOUD_MICROSOFT_365
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outgoing'] = True
initial_input_dict['is_outconn'] = False
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['recv_timeout'] = 250
initial_input_dict['pool_size'] = 20
# ################################################################################################################################
def success_message(self, item):
return 'Successfully {} Microsoft 365 cloud connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'cloud-microsoft-365-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'cloud-microsoft-365-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'cloud-microsoft-365-delete'
error_message = 'Could not delete Microsoft 365 connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def reset_oauth2_scopes(req):
reset_oauth2_scopes_url_step_2 = req.POST['reset_oauth2_scopes_url_step_2']
data = {
'id': req.POST['id'],
'password1': reset_oauth2_scopes_url_step_2,
'password2': reset_oauth2_scopes_url_step_2,
'type_': GENERIC.CONNECTION.TYPE.CLOUD_MICROSOFT_365,
}
return _change_password(req, 'zato.generic.connection.change-password', success_msg='OAuth2 scopes reset', data=data)
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'Microsoft 365 connection')
# ################################################################################################################################
| 5,351
|
Python
|
.py
| 85
| 58.129412
| 130
| 0.398702
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,717
|
confluence.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cloud/confluence.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.cloud.confluence import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.api import GENERIC, generic_attrs
from zato.common.model.atlassian_ import AtlassianConfigObject
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'cloud-confluence'
template = 'zato/cloud/confluence.html'
service_name = 'zato.generic.connection.get-list'
output_class = AtlassianConfigObject
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name', 'is_active', 'is_cloud', 'api_version', 'address', 'username'
output_optional = generic_attrs
output_repeated = True
# ################################################################################################################################
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'id', 'name', 'is_active', 'is_cloud', 'api_version', 'address', 'username'
output_required = 'id', 'name'
# ################################################################################################################################
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.CLOUD_CONFLUENCE
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outgoing'] = True
initial_input_dict['is_outconn'] = False
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['recv_timeout'] = 250
initial_input_dict['pool_size'] = 20
# ################################################################################################################################
def success_message(self, item):
return 'Successfully {} Confluence cloud connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'cloud-confluence-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'cloud-confluence-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'cloud-confluence-delete'
error_message = 'Could not delete Confluence connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.generic.connection.change-password', success_msg='API token updated')
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'Confluence connection')
# ################################################################################################################################
| 5,100
|
Python
|
.py
| 80
| 59.125
| 130
| 0.389067
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,718
|
salesforce.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cloud/salesforce.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# Django
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.forms.cloud.salesforce import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index, invoke_action_handler, method_allowed, \
ping_connection
from zato.common.api import GENERIC, generic_attrs
from zato.common.model.salesforce import SalesforceConfigObject
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'cloud-salesforce'
template = 'zato/cloud/salesforce/index.html'
service_name = 'zato.generic.connection.get-list'
output_class = SalesforceConfigObject
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name', 'is_active', 'is_internal', 'address', 'username', 'api_version', \
'password', 'consumer_key', 'consumer_secret'
output_optional = generic_attrs
output_repeated = True
# ################################################################################################################################
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_internal', 'address', 'username', 'api_version', \
'password', 'consumer_key', 'consumer_secret'
input_optional = ('is_active', 'pool_size') + generic_attrs
output_required = 'id', 'name'
# ################################################################################################################################
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.CLOUD_SALESFORCE
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outgoing'] = True
initial_input_dict['is_outconn'] = False
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['recv_timeout'] = 250
initial_input_dict['pool_size'] = 20
# ################################################################################################################################
def success_message(self, item):
return 'Successfully {} Salesforce cloud connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'cloud-salesforce-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'cloud-salesforce-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'cloud-salesforce-delete'
error_message = 'Could not delete Salesforce connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def invoke(req, conn_id, max_wait_time, conn_name, conn_slug):
return_data = {
'conn_id': conn_id,
'conn_name': conn_name,
'conn_slug': conn_slug,
'conn_type': GENERIC.CONNECTION.TYPE.CLOUD_SALESFORCE,
'timeout': max_wait_time,
'cluster_id': req.zato.cluster_id,
}
return TemplateResponse(req, 'zato/cloud/salesforce/invoke.html', return_data)
# ################################################################################################################################
@method_allowed('POST')
def invoke_action(req, conn_name):
return invoke_action_handler(req, 'zato.generic.connection.invoke', ('conn_name', 'conn_type', 'request_data', 'timeout'))
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'Salesforce connection')
# ################################################################################################################################
| 5,815
|
Python
|
.py
| 95
| 56.263158
| 130
| 0.403234
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,719
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cloud/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
| 238
|
Python
|
.py
| 6
| 38.166667
| 82
| 0.729258
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,720
|
dropbox.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cloud/dropbox.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
# Zato
from zato.common.api import GENERIC
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.cloud.dropbox import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection, slugify
from zato.common.odb.model import GenericConn
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
_sio_required = 'name',
_sio_optional = 'is_active', 'max_retries_on_error', 'max_retries_on_rate_limit', 'timeout', 'oauth2_access_token_expiration', \
'oauth2_access_token', 'default_directory', 'default_scope', 'user_agent', 'http_headers'
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'cloud-dropbox'
template = 'zato/cloud/dropbox.html'
service_name = 'zato.generic.connection.get-list'
output_class = GenericConn
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id', 'type_')
output_required = ('id',) + _sio_required
output_optional = _sio_optional
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(req=self.req),
'edit_form': EditForm(prefix='edit', req=self.req),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = _sio_required + _sio_optional
output_required = ('id', 'name')
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.CLOUD_DROPBOX
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outconn'] = True
initial_input_dict['pool_size'] = 10
initial_input_dict['sec_use_rbac'] = False
def post_process_return_data(self, return_data):
return_data['name_slug'] = slugify(return_data['name'])
return return_data
def success_message(self, item):
return 'Successfully {} Dropbox connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'cloud-dropbox-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'cloud-dropbox-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'cloud-dropbox-delete'
error_message = 'Could not delete Dropbox connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.generic.connection.change-password', success_msg='Token updated')
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'Dropbox connection')
# ################################################################################################################################
| 5,185
|
Python
|
.py
| 86
| 55.77907
| 130
| 0.411045
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,721
|
jira.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cloud/jira.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.cloud.jira import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.api import GENERIC, generic_attrs
from zato.common.model.atlassian_ import AtlassianConfigObject
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'cloud-jira'
template = 'zato/cloud/jira.html'
service_name = 'zato.generic.connection.get-list'
output_class = AtlassianConfigObject
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name', 'is_active', 'is_cloud', 'api_version', 'address', 'username'
output_optional = generic_attrs
output_repeated = True
# ################################################################################################################################
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'id', 'name', 'is_active', 'is_cloud', 'api_version', 'address', 'username'
output_required = 'id', 'name'
# ################################################################################################################################
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.CLOUD_JIRA
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outgoing'] = True
initial_input_dict['is_outconn'] = False
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['recv_timeout'] = 250
initial_input_dict['pool_size'] = 20
# ################################################################################################################################
def success_message(self, item):
return 'Successfully {} Jira cloud connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'cloud-jira-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'cloud-jira-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'cloud-jira-delete'
error_message = 'Could not delete Jira connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.generic.connection.change-password', success_msg='API token updated')
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'Jira connection')
# ################################################################################################################################
| 5,040
|
Python
|
.py
| 80
| 58.375
| 130
| 0.381638
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,722
|
s3.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cloud/aws/s3.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.cloud.aws.s3 import CreateForm, EditForm
from zato.admin.web.views import get_security_id_from_select, CreateEdit, Delete as _Delete, Index as _Index, SecurityList
from zato.common.odb.model import AWSS3
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'cloud-aws-s3'
template = 'zato/cloud/aws/s3.html'
service_name = 'zato.cloud.aws.s3.get-list'
output_class = AWSS3
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'pool_size', 'address', 'debug_level', 'suppr_cons_slashes',
'content_type', 'security_id', 'encrypt_at_rest', 'storage_class')
output_optional = ('metadata_', 'bucket')
output_repeated = True
def handle(self):
if self.req.zato.cluster_id:
sec_list = SecurityList.from_service(self.req.zato.client, self.req.zato.cluster.id, ['aws'])
else:
sec_list = []
return {
'create_form': CreateForm(sec_list),
'edit_form': EditForm(sec_list, prefix='edit'),
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('cluster_id', 'name', 'is_active', 'pool_size', 'address', 'debug_level', 'suppr_cons_slashes',
'content_type', 'security_id', 'encrypt_at_rest', 'storage_class')
input_optional = ('metadata_', 'bucket')
output_required = ('id', 'name')
def on_after_set_input(self):
self.input_dict['security_id'] = get_security_id_from_select(self.input, '', 'security_id')
def success_message(self, item):
return 'AWS S3 connection `{}` {} successfully'.format(item.name, self.verb)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'cloud-aws-s3-create'
service_name = 'zato.cloud.aws.s3.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'cloud-aws-s3-edit'
form_prefix = 'edit-'
service_name = 'zato.cloud.aws.s3.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'cloud-aws-s3-delete'
error_message = 'AWS S3 connection could not be deleted'
service_name = 'zato.cloud.aws.s3.delete'
# ################################################################################################################################
# ################################################################################################################################
| 3,818
|
Python
|
.py
| 67
| 51.835821
| 130
| 0.430142
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,723
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cloud/aws/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
| 238
|
Python
|
.py
| 6
| 38.166667
| 82
| 0.729258
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,724
|
ldap.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/ldap.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.common.api import GENERIC, LDAP
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.ldap import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.odb.model import GenericConn
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-ldap'
template = 'zato/outgoing/ldap.html'
service_name = 'zato.generic.connection.get-list'
output_class = GenericConn
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id', 'type_')
output_required = ('id', 'name', 'is_active', 'get_info', 'ip_mode', 'connect_timeout', 'auto_bind', 'server_list',
'pool_size', 'pool_exhaust_timeout', 'pool_keep_alive', 'pool_max_cycles', 'pool_lifetime', 'pool_ha_strategy',
'username', 'auth_type')
output_optional = ('is_active', 'use_tls', 'pool_name', 'use_sasl_external', 'is_read_only', 'is_stats_enabled',
'should_check_names', 'use_auto_range', 'should_return_empty_attrs', 'is_tls_enabled', 'tls_private_key_file',
'tls_cert_file', 'tls_ca_certs_file', 'tls_version', 'tls_ciphers', 'tls_validate', 'sasl_mechanism')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'get_info', 'ip_mode', 'connect_timeout', 'auto_bind', 'server_list', 'pool_size',
'pool_exhaust_timeout', 'pool_keep_alive', 'pool_max_cycles', 'pool_lifetime', 'pool_ha_strategy', 'username',
'auth_type')
input_optional = ('is_active', 'use_tls', 'pool_name', 'use_sasl_external', 'is_read_only', 'is_stats_enabled',
'should_check_names', 'use_auto_range', 'should_return_empty_attrs', 'is_tls_enabled', 'tls_private_key_file',
'tls_cert_file', 'tls_ca_certs_file', 'tls_version', 'tls_ciphers', 'tls_validate', 'sasl_mechanism')
output_required = ('id', 'name')
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.OUTCONN_LDAP
initial_input_dict['ip_mode'] = LDAP.IP_MODE.IP_SYSTEM_DEFAULT.id
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outconn'] = True
initial_input_dict['sec_use_rbac'] = False
def success_message(self, item):
return 'Successfully {} outgoing LDAP connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'out-ldap-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'out-ldap-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'out-ldap-delete'
error_message = 'Could not delete outgoing LDAP connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.generic.connection.change-password')
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'LDAP connection')
# ################################################################################################################################
| 5,037
|
Python
|
.py
| 83
| 55.108434
| 130
| 0.5137
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,725
|
sftp.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/sftp.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
from traceback import format_exc
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template.response import TemplateResponse
# Zato
from zato.common.api import GENERIC
from zato.common.json_internal import dumps
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.sftp import CommandShellForm, CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index, method_allowed, ping_connection, slugify
from zato.common.odb.model import GenericConn
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
_sio_required = 'name', 'log_level'
_sio_optional = 'is_active', 'host', 'port', 'username', 'password', 'identity_file', \
'ssh_config_file', 'buffer_size', 'is_compression_enabled', 'bandwidth_limit', 'force_ip_type', 'should_flush', \
'should_preserve_meta', 'ssh_options', 'sftp_command', 'ping_command', 'default_directory'
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-sftp'
template = 'zato/outgoing/sftp.html'
service_name = 'zato.generic.connection.get-list'
output_class = GenericConn
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id', 'type_')
output_required = ('id',) + _sio_required
output_optional = _sio_optional
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(req=self.req),
'edit_form': EditForm(prefix='edit', req=self.req),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = _sio_required + _sio_optional
output_required = ('id', 'name')
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.OUTCONN_SFTP
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outconn'] = True
initial_input_dict['pool_size'] = 1
initial_input_dict['sec_use_rbac'] = False
def post_process_return_data(self, return_data):
return_data['name_slug'] = slugify(return_data['name'])
return return_data
def success_message(self, item):
return 'Successfully {} outgoing SFTP connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'out-sftp-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'out-sftp-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'out-sftp-delete'
error_message = 'Could not delete outgoing SFTP connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'SFTP connection')
# ################################################################################################################################
@method_allowed('GET')
def command_shell(req, id, cluster_id, name_slug):
return_data = {
'zato_clusters':req.zato.clusters,
'cluster_id':req.zato.cluster_id,
'req': req,
'conn_id': id,
'name_slug': name_slug,
'conn_name': req.GET['name'],
'form':CommandShellForm(),
}
return TemplateResponse(req, 'zato/outgoing/sftp-command-shell.html', return_data)
# ################################################################################################################################
@method_allowed('POST')
def command_shell_action(req, id, cluster_id, name_slug):
try:
response = req.zato.client.invoke('zato.outgoing.sftp.execute', {
'cluster_id': req.zato.cluster_id,
'id': id,
'data': req.POST['data'],
'log_level': req.POST['log_level'],
})
if response.ok:
data = response.data
return HttpResponse(dumps({
'msg': 'Response time: {} (#{})'.format(data.response_time, data.command_no),
'stdout': data.get('stdout') or '(None)',
'stderr': data.get('stderr') or '(None)',
}), content_type='application/javascript')
else:
raise Exception(response.details)
except Exception:
msg = 'Caught an exception, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
| 6,840
|
Python
|
.py
| 124
| 49.435484
| 130
| 0.445193
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,726
|
sap.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/sap.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Django
from django.http import HttpResponse, HttpResponseServerError
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.sap import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, id_only_service, \
Index as _Index, method_allowed
from zato.common.api import SAP
from zato.common.odb.model import OutgoingSAP
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-sap'
template = 'zato/outgoing/sap.html'
service_name = 'zato.outgoing.sap.get-list'
output_class = OutgoingSAP
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'host', 'sysnr', 'sysid', 'user', 'client', 'router', 'pool_size')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm(),
'default_instance': SAP.DEFAULT.INSTANCE,
'default_pool_size': SAP.DEFAULT.POOL_SIZE,
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'host', 'sysnr', 'user', 'sysid', 'client', 'router', 'pool_size')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {} the outgoing SAP RFC connection [{}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'out-sap-create'
service_name = 'zato.outgoing.sap.create'
class Edit(_CreateEdit):
url_name = 'out-sap-edit'
form_prefix = 'edit-'
service_name = 'zato.outgoing.sap.edit'
class Delete(_Delete):
url_name = 'out-sap-delete'
error_message = 'Could not delete the outgoing SAP RFC connection'
service_name = 'zato.outgoing.sap.delete'
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.outgoing.sap.change-password')
@method_allowed('POST')
def ping(req, id, cluster_id):
ret = id_only_service(req, 'zato.outgoing.sap.ping', id, 'Could not ping the SAP RFC connection, e:`{}`')
if isinstance(ret, HttpResponseServerError):
return ret
return HttpResponse(ret.data.info)
| 2,661
|
Python
|
.py
| 63
| 37.380952
| 120
| 0.691085
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,727
|
sql.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/sql.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
from traceback import format_exc
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.views import change_password as _change_password, parse_response_data
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.sql import CreateForm, EditForm
from zato.admin.web.views import Delete as _Delete, method_allowed
from zato.common.api import engine_display_name
from zato.common.json_internal import dumps
from zato.common.odb.model import SQLConnectionPool
logger = logging.getLogger(__name__)
def _get_edit_create_message(params, prefix=''):
""" Creates a base dictionary which can be used by both 'edit' and 'create' actions.
"""
return {
'id': params.get('id'),
'cluster_id': params['cluster_id'],
'name': params[prefix + 'name'],
'is_active': bool(params.get(prefix + 'is_active')),
'engine': params[prefix + 'engine'],
'host': params[prefix + 'host'],
'port': params[prefix + 'port'],
'db_name': params[prefix + 'db_name'],
'username': params[prefix + 'username'],
'pool_size': params[prefix + 'pool_size'],
'extra': params.get(prefix + 'extra'),
}
def _edit_create_response(verb, id, name, engine_display_name, cluster_id):
""" A common function for producing return data for create and edit actions.
"""
return_data = {'id': id,
'message': 'Successfully {} outgoing SQL connection `{}`'.format(verb, name),
'engine_display_name': engine_display_name,
'cluster_id': cluster_id,
}
return HttpResponse(dumps(return_data), content_type='application/javascript')
@method_allowed('GET')
def index(req):
""" Lists all the SQL connections.
"""
items = []
create_form = CreateForm(req)
edit_form = EditForm(req, prefix='edit')
change_password_form = ChangePasswordForm()
meta = None
if req.zato.cluster_id and req.method == 'GET':
request = {
'cluster_id': req.zato.cluster_id,
'paginate': True,
'cur_page': req.GET.get('cur_page', 1)
}
data, meta = parse_response_data(req.zato.client.invoke('zato.outgoing.sql.get-list', request))
for item in data:
_item = SQLConnectionPool()
for name in('id', 'name', 'is_active', 'engine', 'host', 'port', 'db_name', 'username', 'pool_size', 'engine'):
value = getattr(item, name)
setattr(_item, name, value)
_item.engine_display_name = engine_display_name[_item.engine]
_item.extra = item.extra or ''
items.append(_item)
return_data = {'zato_clusters':req.zato.clusters,
'cluster_id':req.zato.cluster_id,
'search_form':req.zato.search_form,
'items':items,
'create_form':create_form,
'edit_form':edit_form,
'change_password_form': change_password_form,
'paginate':True,
'meta': meta,
'req': req,
}
return TemplateResponse(req, 'zato/outgoing/sql.html', return_data)
@method_allowed('POST')
def create(req):
""" Creates a new SQL connection.
"""
try:
request = _get_edit_create_message(req.POST)
response = req.zato.client.invoke('zato.outgoing.sql.create', request)
return _edit_create_response(
'created', response.data.id, req.POST['name'], response.data.display_name, req.zato.cluster.id)
except Exception:
msg = 'Could not create an outgoing SQL connection, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
@method_allowed('POST')
def edit(req):
""" Updates an SQL connection.
"""
try:
request = _get_edit_create_message(req.POST, 'edit-')
response = req.zato.client.invoke('zato.outgoing.sql.edit', request)
return _edit_create_response(
'updated', req.POST['id'], req.POST['edit-name'], response.data.display_name, req.zato.cluster.id)
except Exception:
msg = 'Could not update the outgoing SQL connection, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
class Delete(_Delete):
url_name = 'out-sql-delete'
error_message = 'Could not delete the SQL connection'
service_name = 'zato.outgoing.sql.delete'
@method_allowed('POST')
def ping(req, cluster_id, id):
""" Pings a database and returns the time it took, in milliseconds.
"""
try:
response = req.zato.client.invoke('zato.outgoing.sql.ping', {
'id':id,
'should_raise_on_error': True,
})
if response.ok:
if not response.data.response_time:
return HttpResponseServerError('No response time received')
else:
return TemplateResponse(req, 'zato/outgoing/sql-ping-ok.html',
{'response_time':'%.3f' % float(response.data.response_time)})
else:
return HttpResponseServerError(response.details)
except Exception:
msg = 'Could not ping the outgoing SQL connection, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.outgoing.sql.change-password')
| 5,671
|
Python
|
.py
| 135
| 34.666667
| 123
| 0.640872
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,728
|
odoo.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/odoo.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Django
from django.http import HttpResponse, HttpResponseServerError
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.odoo import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, id_only_service, \
Index as _Index, method_allowed
from zato.common.api import ODOO
from zato.common.odb.model import OutgoingOdoo
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-odoo'
template = 'zato/outgoing/odoo.html'
service_name = 'zato.outgoing.odoo.get-list'
output_class = OutgoingOdoo
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'host', 'port', 'user', 'database', 'protocol', 'pool_size')
output_repeated = True
def handle(self):
for item in self.items:
for protocol in ODOO.PROTOCOL():
if item.protocol == protocol.id:
item.protocol_name = protocol.name
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm(),
'default_port': ODOO.DEFAULT.PORT,
'default_pool_size': ODOO.DEFAULT.POOL_SIZE,
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'host', 'port', 'user', 'database', 'protocol', 'pool_size')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {} the outgoing Odoo connection [{}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'out-odoo-create'
service_name = 'zato.outgoing.odoo.create'
class Edit(_CreateEdit):
url_name = 'out-odoo-edit'
form_prefix = 'edit-'
service_name = 'zato.outgoing.odoo.edit'
class Delete(_Delete):
url_name = 'out-odoo-delete'
error_message = 'Could not delete the outgoing Odoo connection'
service_name = 'zato.outgoing.odoo.delete'
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.outgoing.odoo.change-password')
@method_allowed('POST')
def ping(req, id, cluster_id):
ret = id_only_service(req, 'zato.outgoing.odoo.ping', id, 'Could not ping the Odoo connection, e:`{}`')
if isinstance(ret, HttpResponseServerError):
return ret
return HttpResponse(ret.data.info)
| 2,852
|
Python
|
.py
| 68
| 36.455882
| 119
| 0.68343
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,729
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,730
|
ftp.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/ftp.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.ftp import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.odb.model import OutgoingFTP
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-ftp'
template = 'zato/outgoing/ftp.html'
service_name = 'zato.outgoing.ftp.get-list'
output_class = OutgoingFTP
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'host', 'user', 'acct', 'timeout', 'port', 'dircache', 'default_directory')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'host', 'user', 'timeout', 'acct', 'port', 'dircache', 'default_directory')
output_required = ('id', 'name')
def success_message(self, item):
return 'Outgoing FTP connection `{}` successfully {}'.format(item.name, self.verb)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'out-ftp-create'
service_name = 'zato.outgoing.ftp.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'out-ftp-edit'
form_prefix = 'edit-'
service_name = 'zato.outgoing.ftp.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'out-ftp-delete'
error_message = 'Outgoing FTP connection could not be deleted'
service_name = 'zato.outgoing.ftp.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.outgoing.ftp.change-password')
# ################################################################################################################################
# ################################################################################################################################
| 4,279
|
Python
|
.py
| 68
| 58.926471
| 132
| 0.346788
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,731
|
wsx.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/wsx.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2023, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
# Zato
from zato.common.api import GENERIC
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.wsx import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import GenericConn
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-wsx'
template = 'zato/outgoing/wsx.html'
service_name = 'zato.generic.connection.get-list'
output_class = GenericConn
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id', 'type_')
output_required = ('id', 'name', 'address', 'address_masked')
output_optional = ('is_active', 'is_zato',
'on_connect_service_id', 'on_connect_service_name', 'on_message_service_id', 'on_message_service_name',
'on_close_service_id', 'on_close_service_name', 'subscription_list', 'security_def', 'has_auto_reconnect',
'data_format', 'ping_interval', 'pings_missed_threshold', 'socket_read_timeout', 'socket_write_timeout')
output_repeated = True
def handle(self):
if self.req.zato.get('client'):
security_list = self.get_sec_def_list('basic_auth').def_items
else:
security_list = []
return {
'create_form': CreateForm(security_list, req=self.req),
'edit_form': EditForm(security_list, prefix='edit', req=self.req),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'is_zato', 'address', 'on_connect_service_name', 'on_message_service_name',
'on_close_service_name', 'subscription_list', 'security_def', 'has_auto_reconnect', 'data_format',
'ping_interval', 'pings_missed_threshold', 'socket_read_timeout', 'socket_write_timeout')
output_required = ('id', 'name')
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.OUTCONN_WSX
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outconn'] = True
initial_input_dict['pool_size'] = 1
initial_input_dict['sec_use_rbac'] = False
def post_process_return_data(self, return_data):
for name in ('connect', 'message', 'close'):
field_name = 'on_{}_service_name'.format(name)
return_data[field_name] = self.input_dict.get(field_name)
return return_data
def success_message(self, item):
return 'Successfully {} outgoing WebSocket connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'out-wsx-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'out-wsx-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'out-wsx-delete'
error_message = 'Could not delete outgoing WebSocket connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
| 4,334
|
Python
|
.py
| 78
| 49.358974
| 130
| 0.52435
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,732
|
jms_wmq.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/jms_wmq.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2021, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
from traceback import format_exc
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template.response import TemplateResponse
# Zato
from zato.admin.settings import delivery_friendly_name
from zato.admin.web.forms.outgoing.jms_wmq import CreateForm, EditForm
from zato.admin.web.views import Delete as _Delete, get_definition_list, method_allowed, parse_response_data
from zato.admin.web.util import get_template_response
from zato.common.json_internal import dumps
from zato.common.odb.model import OutgoingWMQ
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
send_attrs = ('id', 'queue_name', 'data', 'delivery_mode', 'priority', 'expiration', 'reply_to', 'msg_id', 'correl_id')
# ################################################################################################################################
def _get_edit_create_message(params, prefix=''):
""" Creates a base dictionary which can be used by both 'edit' and 'create' actions.
"""
return {
'id': params.get('id'),
'cluster_id': params['cluster_id'],
'name': params[prefix + 'name'],
'is_active': bool(params.get(prefix + 'is_active')),
'def_id': params[prefix + 'def_id'],
'delivery_mode': params[prefix + 'delivery_mode'],
'priority': params[prefix + 'priority'],
'expiration': params.get(prefix + 'expiration'),
}
# ################################################################################################################################
def _edit_create_response(client, verb, id, name, delivery_mode_text, cluster_id, def_id):
response = client.invoke('zato.definition.jms-wmq.get-by-id', {'id':def_id, 'cluster_id':cluster_id})
return_data = {'id': id,
'message': 'Successfully {} outgoing IBM MQ connection `{}`'.format(verb, name),
'delivery_mode_text': delivery_mode_text,
'def_name': response.data.name
}
return HttpResponse(dumps(return_data), content_type='application/javascript')
# ################################################################################################################################
@method_allowed('GET')
def index(req):
items = []
create_form = CreateForm()
edit_form = EditForm(prefix='edit')
meta = None
if req.zato.cluster_id and req.method == 'GET':
def_ids = get_definition_list(req.zato.client, req.zato.cluster, 'jms-wmq')
create_form.set_def_id(def_ids)
edit_form.set_def_id(def_ids)
request = {
'cluster_id': req.zato.cluster_id,
'paginate': True,
'cur_page': req.GET.get('cur_page', 1)
}
data, meta = parse_response_data(req.zato.client.invoke('zato.outgoing.jms-wmq.get-list', request))
for item in data:
_item = OutgoingWMQ(
item.id,
item.name,
item.is_active,
item.delivery_mode,
item.priority,
item.expiration,
item.def_id,
delivery_mode_text=delivery_friendly_name[str(item.delivery_mode)],
def_name=item.def_name
)
items.append(_item)
return_data = {'zato_clusters':req.zato.clusters,
'cluster_id':req.zato.cluster_id,
'search_form':req.zato.search_form,
'items':items,
'create_form':create_form,
'edit_form':edit_form,
'paginate':True,
'meta': meta,
'req': req,
}
return get_template_response(req, 'zato/outgoing/jms-wmq.html', return_data)
# ################################################################################################################################
@method_allowed('POST')
def create(req):
try:
response = req.zato.client.invoke('zato.outgoing.jms-wmq.create', _get_edit_create_message(req.POST))
delivery_mode_text = delivery_friendly_name[str(req.POST['delivery_mode'])]
return _edit_create_response(req.zato.client, 'created', response.data.id,
req.POST['name'], delivery_mode_text, req.POST['cluster_id'], req.POST['def_id'])
except Exception:
msg = 'Could not create outgoing IBM MQ connection, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
@method_allowed('POST')
def edit(req):
try:
request = _get_edit_create_message(req.POST, 'edit-')
req.zato.client.invoke('zato.outgoing.jms-wmq.edit', request)
delivery_mode_text = delivery_friendly_name[str(req.POST['edit-delivery_mode'])]
return _edit_create_response(req.zato.client, 'updated', req.POST['id'], req.POST['edit-name'],
delivery_mode_text, req.POST['cluster_id'], req.POST['edit-def_id'])
except Exception:
msg = 'Could not update outgoing IBM MQ connection, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
class Delete(_Delete):
url_name = 'out-jms-wmq-delete'
error_message = 'Could not delete the outgoing IBM MQ connection'
service_name = 'zato.outgoing.jms-wmq.delete'
# ################################################################################################################################
@method_allowed('GET')
def send_message(req, cluster_id, conn_id, name_slug):
response = req.zato.client.invoke('zato.outgoing.jms-wmq.get', {
'cluster_id': cluster_id,
'id': conn_id,
})
if not response.ok:
raise Exception(response.details)
return_data = {
'cluster_id': cluster_id,
'name_slug': name_slug,
'item': response.data,
'conn_id': conn_id
}
return TemplateResponse(req, 'zato/outgoing/jms-wmq-send-message.html', return_data)
# ################################################################################################################################
@method_allowed('POST')
def send_message_action(req, cluster_id, conn_id, name_slug):
try:
request = {
'cluster_id': req.zato.cluster_id
}
for name in send_attrs:
request[name] = req.POST.get(name, '')
response = req.zato.client.invoke('zato.outgoing.jms-wmq.send-message', request)
if response.ok:
return HttpResponse(dumps({'msg': 'OK, message sent successfully.'}), content_type='application/javascript')
else:
raise Exception(response.details)
except Exception:
msg = 'Caught an exception, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
| 7,539
|
Python
|
.py
| 151
| 42.668874
| 130
| 0.514434
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,733
|
amqp_.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/amqp_.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
from traceback import format_exc
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template.response import TemplateResponse
# Zato
from zato.admin.settings import delivery_friendly_name
from zato.admin.web.forms.outgoing.amqp_ import CreateForm, EditForm
from zato.admin.web.views import Delete as _Delete, get_definition_list, Index as _Index, invoke_action_handler, method_allowed
from zato.common.json_internal import dumps
from zato.common.odb.model import OutgoingAMQP
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
def _get_edit_create_message(params, prefix=''):
""" Creates a base dictionary which can be used by both 'edit' and 'create' actions.
"""
return {
'id': params.get('id'),
'cluster_id': params['cluster_id'],
'name': params[prefix + 'name'],
'is_active': bool(params.get(prefix + 'is_active')),
'def_id': params[prefix + 'def_id'],
'delivery_mode': params[prefix + 'delivery_mode'],
'priority': params[prefix + 'priority'],
'content_type': params.get(prefix + 'content_type'),
'content_encoding': params.get(prefix + 'content_encoding'),
'expiration': params.get(prefix + 'expiration'),
'pool_size': params.get(prefix + 'pool_size'),
'user_id': params.get(prefix + 'user_id'),
'app_id': params.get(prefix + 'app_id'),
}
# ################################################################################################################################
# ################################################################################################################################
def _edit_create_response(client, verb, id, name, delivery_mode_text, def_id, cluster_id):
response = client.invoke('zato.definition.amqp.get-by-id', {'id':def_id, 'cluster_id': cluster_id})
return_data = {'id': id,
'message': 'Successfully {} outgoing AMQP connection `{}`'.format(verb, name),
'delivery_mode_text': delivery_mode_text,
'def_name': response.data.name
}
return HttpResponse(dumps(return_data), content_type='application/javascript')
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-amqp'
template = 'zato/outgoing/amqp.html'
service_name = 'zato.outgoing.amqp.get-list'
output_class = OutgoingAMQP
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'delivery_mode', 'priority', 'content_type', 'content_encoding',
'expiration', 'pool_size', 'user_id', 'app_id', 'delivery_mode_text', 'def_name', 'def_id')
output_repeated = True
def handle(self):
create_form = CreateForm()
edit_form = EditForm(prefix='edit')
if self.req.zato.cluster_id:
def_ids = get_definition_list(self.req.zato.client, self.req.zato.cluster, 'amqp')
create_form.set_def_id(def_ids)
edit_form.set_def_id(def_ids)
for item in self.items:
item.delivery_mode_text = delivery_friendly_name[item.delivery_mode]
return {
'create_form': create_form,
'edit_form': edit_form,
}
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def create(req):
try:
request = _get_edit_create_message(req.POST)
response = req.zato.client.invoke('zato.outgoing.amqp.create', request)
delivery_mode_text = delivery_friendly_name[req.POST['delivery_mode']]
return _edit_create_response(req.zato.client, 'created', response.data.id,
req.POST['name'], delivery_mode_text, req.POST['def_id'], req.POST['cluster_id'])
except Exception:
msg = 'Outgoing AMQP connection could not be created, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def edit(req):
try:
request = _get_edit_create_message(req.POST, 'edit-')
req.zato.client.invoke('zato.outgoing.amqp.edit', request)
delivery_mode_text = delivery_friendly_name[req.POST['edit-delivery_mode']]
return _edit_create_response(req.zato.client, 'updated', req.POST['id'], req.POST['edit-name'],
delivery_mode_text, req.POST['edit-def_id'], req.POST['cluster_id'])
except Exception:
msg = 'Outgoing AMQP connection could not be updated, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'out-amqp-delete'
error_message = 'Could not delete the outgoing AMQP connection'
service_name = 'zato.outgoing.amqp.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def invoke(req, conn_id, conn_name, conn_slug):
return_data = {
'conn_id': conn_id,
'conn_name': conn_name,
'cluster_id': req.zato.cluster_id,
}
return TemplateResponse(req, 'zato/outgoing/amqp-invoke.html', return_data)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def invoke_action(req, conn_name):
return invoke_action_handler(req, 'zato.outgoing.amqp.publish', ('conn_name', 'request_data', 'exchange', 'routing_key'))
# ################################################################################################################################
# ################################################################################################################################
| 7,794
|
Python
|
.py
| 129
| 54.527132
| 130
| 0.435854
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,734
|
mongodb.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/mongodb.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.common.api import GENERIC
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.mongodb import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.odb.model import GenericConn
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-mongodb'
template = 'zato/outgoing/mongodb.html'
service_name = 'zato.generic.connection.get-list'
output_class = GenericConn
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id', 'type_')
output_required = ('id', 'name', 'server_list', 'pool_size_max', 'connect_timeout',
'socket_timeout', 'server_select_timeout', 'wait_queue_timeout', 'max_idle_time', 'hb_frequency')
output_optional = ('is_active', 'username', 'app_name', 'replica_set', 'auth_source', 'auth_mechanism',
'is_tz_aware', 'document_class', 'compressor_list', 'zlib_level', 'write_to_replica', 'write_timeout',
'is_write_journal_enabled', 'is_write_fsync_enabled', 'read_pref_type', 'read_pref_tag_list',
'read_pref_max_stale', 'is_tls_enabled', 'tls_private_key_file', 'tls_cert_file', 'tls_ca_certs_file',
'tls_crl_file', 'tls_version', 'tls_validate', 'tls_pem_passphrase', 'is_tls_match_hostname_enabled',
'tls_ciphers')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'server_list', 'pool_size_max', 'connect_timeout',
'socket_timeout', 'server_select_timeout', 'wait_queue_timeout', 'max_idle_time', 'hb_frequency')
input_optional = ('is_active', 'username', 'app_name', 'replica_set', 'auth_source', 'auth_mechanism',
'is_tz_aware', 'document_class', 'compressor_list', 'zlib_level', 'write_to_replica', 'write_timeout',
'is_write_journal_enabled', 'is_write_fsync_enabled', 'should_retry_write', 'read_pref_type', 'read_pref_tag_list',
'read_pref_max_stale', 'is_tls_enabled', 'tls_private_key_file', 'tls_cert_file', 'tls_ca_certs_file',
'tls_crl_file', 'tls_version', 'tls_validate', 'tls_pem_passphrase', 'is_tls_match_hostname_enabled',
'tls_ciphers')
output_required = 'id', 'name'
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.OUTCONN_MONGODB
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outconn'] = True
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['pool_size'] = 1 # We use pool_size_max from opaque attributes
def on_after_set_input(self):
# Convert to integers, as expected by MongoDB driver
for name in 'hb_frequency', 'max_idle_time', 'write_to_replica', 'read_pref_max_stale', 'zlib_level':
value = self.input.get(name, None)
if value is not None:
self.input[name] = int(value)
def success_message(self, item):
return 'Successfully {} outgoing MongoDB connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'out-mongodb-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'out-mongodb-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'out-mongodb-delete'
error_message = 'Could not delete outgoing MongoDB connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.generic.connection.change-password')
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'MongoDB connection')
# ################################################################################################################################
| 5,742
|
Python
|
.py
| 93
| 55.516129
| 130
| 0.530449
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,735
|
zmq.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/zmq.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.outgoing.zmq import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import OutgoingZMQ
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-zmq'
template = 'zato/outgoing/zmq.html'
service_name = 'zato.outgoing.zmq.get-list'
output_class = OutgoingZMQ
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'address', 'socket_type', 'socket_method')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'address', 'socket_type', 'socket_method')
output_required = ('id',)
def success_message(self, item):
return 'Successfully {0} the outgoing Zero MQ connection [{1}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'out-zmq-create'
service_name = 'zato.outgoing.zmq.create'
class Edit(_CreateEdit):
url_name = 'out-zmq-edit'
form_prefix = 'edit-'
service_name = 'zato.outgoing.zmq.edit'
class Delete(_Delete):
url_name = 'out-zmq-delete'
error_message = 'Could not delete the outgoing Zero MQ connection'
service_name = 'zato.outgoing.zmq.delete'
| 1,833
|
Python
|
.py
| 47
| 34.191489
| 100
| 0.68323
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,736
|
slack.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/im/slack.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.common.api import GENERIC
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.im.slack import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.odb.model import GenericConn
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-im-slack'
template = 'zato/outgoing/im/slack.html'
service_name = 'zato.generic.connection.get-list'
output_class = GenericConn
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name'
output_optional = 'is_active', 'http_proxy_list', 'https_proxy_list'
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name',
input_optional = 'is_active', 'http_proxy_list', 'https_proxy_list'
output_required = 'id', 'name'
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.OUTCONN_IM_SLACK
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outconn'] = True
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['pool_size'] = 1
def success_message(self, item):
return 'Successfully {} outgoing Slack connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'out-im-slack-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'out-im-slack-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'out-im-slack-delete'
error_message = 'Could not delete outgoing Slack connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.generic.connection.change-password', success_msg='Token updated')
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'Slack connection')
# ################################################################################################################################
| 4,017
|
Python
|
.py
| 75
| 48.773333
| 130
| 0.489144
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,737
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/im/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,738
|
telegram.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/im/telegram.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.common.api import GENERIC
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.outgoing.im.telegram import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.odb.model import GenericConn
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'out-im-telegram'
template = 'zato/outgoing/im/telegram.html'
service_name = 'zato.generic.connection.get-list'
output_class = GenericConn
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name', 'address', 'connect_timeout', 'invoke_timeout'
output_optional = 'is_active', 'http_proxy_list', 'https_proxy_list'
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'address', 'connect_timeout', 'invoke_timeout'
input_optional = 'is_active', 'http_proxy_list', 'https_proxy_list'
output_required = 'id', 'name'
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.OUTCONN_IM_TELEGRAM
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outconn'] = True
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['pool_size'] = 1
def success_message(self, item):
return 'Successfully {} outgoing Telegram connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'out-im-telegram-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'out-im-telegram-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'out-im-telegram-delete'
error_message = 'Could not delete outgoing Telegram connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.generic.connection.change-password', success_msg='Token updated')
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'Telegram connection')
# ################################################################################################################################
| 4,142
|
Python
|
.py
| 75
| 50.44
| 130
| 0.498267
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,739
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/redis/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2021, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.forms import ChangePasswordForm, SearchForm
from zato.admin.web.forms.kvdb import CreateForm, EditForm, RemoteCommandForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Index as _Index, method_allowed
from zato.common.exception import ZatoException
from zato.common.json_internal import dumps
from zato.common.model.kvdb import KVDB as KVDBModel
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'kvdb'
template = 'zato/outgoing/redis/index.html'
service_name = 'zato.outgoing.redis.get-list'
output_class = KVDBModel
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
output_required = 'name', 'is_active', 'host', 'port', 'db', 'use_redis_sentinels', 'redis_sentinels', \
'redis_sentinels_master'
output_optional = 'id',
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm(),
'cluster_id': self.input.cluster_id,
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_optional = 'id', 'name', 'is_active', 'host', 'port', 'db', 'use_redis_sentinels', 'redis_sentinels', \
'redis_sentinels_master'
def post_process_return_data(self, return_data):
return_data['id'] = self.input_dict['id']
return return_data
def success_message(self, item):
return 'Outgoing Redis connection {} successfully'.format(self.verb)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'out-redis-create'
service_name = 'kvdb1.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'out-redis-edit'
form_prefix = 'edit-'
service_name = 'zato.outgoing.redis.edit'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.outgoing.redis.change-password')
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def remote_command(req):
return_data = {
'form':RemoteCommandForm(),
'cluster':req.zato.get('cluster'),
'search_form':SearchForm(req.zato.clusters, req.GET),
'zato_clusters':req.zato.clusters,
'cluster_id':req.zato.cluster_id,
}
return TemplateResponse(req, 'zato/kvdb/remote-command.html', return_data)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def remote_command_execute(req):
""" Executes a command against the key/value DB.
"""
try:
response = req.zato.client.invoke('zato.kvdb.remote-command.execute', {'command': req.POST['command']})
if response.has_data:
return HttpResponse(dumps({'message': dumps(response.data.result)}), content_type='application/javascript')
else:
raise ZatoException(msg=response.details)
except Exception as e:
return HttpResponseServerError(e.args[0])
# ################################################################################################################################
# ################################################################################################################################
| 4,925
|
Python
|
.py
| 90
| 49.566667
| 130
| 0.446455
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,740
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/redis/data_dict/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,741
|
impexp.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/redis/data_dict/impexp.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import bz2
import logging
from base64 import b64encode
from datetime import datetime
from traceback import format_exc
# Django
from django.http import HttpResponse, HttpResponseServerError
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.views import method_allowed
from zato.common.json_internal import dumps
from zato.common.util.api import current_host, translation_name
# Python 2/3 compatibility
from zato.common.py23_.past.builtins import unicode
logger = logging.getLogger(__name__)
@method_allowed('GET')
def index(req):
return_data = {
'zato_clusters':req.zato.clusters,
'cluster_id':req.zato.cluster_id,
'search_form':req.zato.search_form,
}
return TemplateResponse(req, 'zato/kvdb/data_dict/impexp.html', return_data)
@method_allowed('POST')
def import_(req, cluster_id):
try:
data = req.read()
if isinstance(data, unicode):
data = data.encode('utf8')
bz2.decompress(data) # A preliminary check to weed out files obviously incorrect
req.zato.client.invoke('zato.kvdb.data-dict.impexp.import', {'data':b64encode(data)})
except Exception:
msg = 'Could not import the data dictionaries, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
else:
return HttpResponse(dumps({'success': True}))
@method_allowed('GET')
def export(req, cluster_id):
def _get_last_id(service):
response = req.zato.client.invoke(service, {})
if response.data:
return response.data.value
def _get_last_dict_id():
return _get_last_id('zato.kvdb.data-dict.dictionary.get-last-id')
def _get_last_translation_id():
return _get_last_id('zato.kvdb.data-dict.translation.get-last-id')
def _get_dict_list():
for item in req.zato.client.invoke('zato.kvdb.data-dict.dictionary.get-list', {}):
yield item.id, item.system, item.key, item.value
def _get_translation_list():
for item in req.zato.client.invoke('zato.kvdb.data-dict.translation.get-list', {}):
yield item.id, item.system1, item.key1, item.value1, item.system2, \
item.key2, item.value2, item.id1, item.id2
return_data = {'meta': {'current_host':current_host(), 'timestamp_utc':datetime.utcnow().isoformat(), 'user':req.user.username}}
return_data['data'] = {'dict_list':[], 'translation_list':[]}
return_data['data']['last_dict_id'] = _get_last_dict_id()
return_data['data']['last_translation_id'] = _get_last_translation_id()
for id, system, key, value in _get_dict_list():
return_data['data']['dict_list'].append({'id':id, 'system':system, 'key':key, 'value':value})
for id, system1, key1, value1, system2, key2, value2, id1, id2 in _get_translation_list():
return_data['data']['translation_list'].append(
{translation_name(system1, key1, value1, system2, key2): {'id':id, 'value2':value2, 'id1':id1, 'id2':id2}})
data = dumps(return_data, indent=4)
if isinstance(data, unicode):
data = data.encode('utf8')
data = bz2.compress(data)
response = HttpResponse(data, content_type='application/x-bzip2')
response['Content-Disposition'] = 'attachment; filename={}'.format('zato-data-dict-export.json.bz2')
return response
| 3,614
|
Python
|
.py
| 77
| 41.311688
| 132
| 0.685844
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,742
|
dictionary.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/redis/data_dict/dictionary.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# Zato
from zato.admin.web.forms.kvdb.data_dict.dictionary import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
class DictItem:
pass
class Index(_Index):
method_allowed = 'GET'
url_name = 'kvdb-data-dict-dictionary'
template = 'zato/kvdb/data_dict/dictionary.html'
service_name = 'zato.kvdb.data-dict.dictionary.get-list'
output_class = DictItem
class SimpleIO(_Index.SimpleIO):
output_required = ('id', 'system', 'key', 'value')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('system', 'key', 'value')
output_required = ('id',)
def success_message(self, item):
return 'Successfully {} the dictionary entry system:[{}], key:[{}], value:[{}]'.format(
self.verb, self.input_dict['system'], self.input_dict['key'], self.input_dict['value'])
class Create(_CreateEdit):
url_name = 'kvdb-data-dict-dictionary-create'
service_name = 'zato.kvdb.data-dict.dictionary.create'
class Edit(_CreateEdit):
url_name = 'kvdb-data-dict-dictionary-edit'
form_prefix = 'edit-'
service_name = 'zato.kvdb.data-dict.dictionary.edit'
class Delete(_Delete):
url_name = 'kvdb-data-dict-dictionary-delete'
error_message = 'Could not delete the data dictionary'
service_name = 'zato.kvdb.data-dict.dictionary.delete'
| 1,843
|
Python
|
.py
| 44
| 36.75
| 99
| 0.683473
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,743
|
translation.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/redis/data_dict/translation.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Django
from django.http import HttpResponse
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.forms.kvdb.data_dict.translation import CreateForm, EditForm, TranslateForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.api import ZATO_NONE
from zato.common.json_internal import dumps
logger = logging.getLogger(__name__)
def _get_systems(client):
systems = []
for item in client.invoke('zato.kvdb.data-dict.dictionary.get-system-list', {}):
systems.append([item.name] * 2)
return systems
class DictItem:
pass
class Index(_Index):
method_allowed = 'GET'
url_name = 'kvdb-data-dict-translation'
template = 'zato/kvdb/data_dict/translation/index.html'
service_name = 'zato.kvdb.data-dict.translation.get-list'
output_class = DictItem
class SimpleIO(_Index.SimpleIO):
output_required = ('id', 'system1', 'key1', 'value1', 'system2', 'key2', 'value2')
output_repeated = True
def handle(self):
systems = _get_systems(self.req.zato.client)
return {
'create_form': CreateForm(systems),
'edit_form': EditForm(systems, prefix='edit'),
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('system1', 'key1', 'value1', 'system2', 'key2', 'value2')
output_required = ('id',)
def success_message(self, item):
return 'Successfully {} the translation between system1:[{}], key1:[{}], value1:[{}] and system2:[{}], key2:[{}], value2:[{}]'.format(
self.verb, self.input_dict['system1'], self.input_dict['key1'], self.input_dict['value1'],
self.input_dict['system2'], self.input_dict['key2'], self.input_dict['value2'])
class Create(_CreateEdit):
url_name = 'kvdb-data-dict-translation-create'
service_name = 'zato.kvdb.data-dict.translation.create'
class Edit(_CreateEdit):
url_name = 'kvdb-data-dict-translation-edit'
form_prefix = 'edit-'
service_name = 'zato.kvdb.data-dict.translation.edit'
class Delete(_Delete):
url_name = 'kvdb-data-dict-translation-delete'
error_message = 'Could not delete the data translation'
service_name = 'zato.kvdb.data-dict.translation.delete'
def _get_key_value_list(req, service_name, input_dict):
return_data = []
for item in req.zato.client.invoke(service_name, input_dict):
return_data.append({'name':item.name})
return HttpResponse(dumps(return_data), content_type='application/javascript')
@method_allowed('GET')
def get_key_list(req):
return _get_key_value_list(req, 'zato.kvdb.data-dict.dictionary.get-key-list', {'system':req.GET['system']})
@method_allowed('GET')
def get_value_list(req):
return _get_key_value_list(req, 'zato.kvdb.data-dict.dictionary.get-value-list', {'system':req.GET['system'], 'key':req.GET['key']})
@method_allowed('GET', 'POST')
def translate(req):
result_names = ('system1', 'key1', 'value1', 'system2', 'key2')
post_data = {}
for name in result_names:
post_data[name] = req.POST.get(name, '')
def _translate():
result = {}
response = req.zato.client.invoke('zato.kvdb.data-dict.translation.translate', post_data)
if response.has_data:
for name in('value2', 'repr', 'hex', 'sha1', 'sha256'):
value = getattr(response.data, name, None)
if value and value != ZATO_NONE:
result[name] = value
return result
if req.zato.get('cluster'):
translate_form = TranslateForm(_get_systems(req.zato.client), req.POST)
else:
translate_form = None
return_data = {
'zato_clusters':req.zato.clusters,
'cluster_id':req.zato.cluster_id,
'search_form':req.zato.search_form,
'translate_form':translate_form,
'postback':post_data,
'translation_result': _translate() if req.method == 'POST' else None,
'show_translation': req.method == 'POST'
}
return TemplateResponse(req, 'zato/kvdb/data_dict/translation/translate.html', return_data)
| 4,456
|
Python
|
.py
| 99
| 39.181818
| 142
| 0.672521
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,744
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/hl7/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 148
|
Python
|
.py
| 5
| 28.2
| 64
| 0.687943
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,745
|
fhir.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/hl7/fhir.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# Django
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.forms.outgoing.hl7.fhir import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
invoke_action_handler, method_allowed, ping_connection, SecurityList
from zato.common.api import GENERIC, generic_attrs, SEC_DEF_TYPE
from zato.common.model.hl7 import HL7FHIRConfigObject
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'outgoing-hl7-fhir'
template = 'zato/outgoing/hl7/fhir.html'
service_name = 'zato.generic.connection.get-list'
output_class = HL7FHIRConfigObject
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name', 'is_active', 'is_internal', 'address', 'security_id', 'sec_tls_ca_cert_id', \
'pool_size', 'sec_def_type_name', 'security_name'
output_optional = ('extra',) + generic_attrs
output_repeated = True
# ################################################################################################################################
def handle(self):
security_list = SecurityList.from_service(
self.req.zato.client,
self.cluster_id,
sec_type = [SEC_DEF_TYPE.BASIC_AUTH, SEC_DEF_TYPE.OAUTH],
needs_def_type_name_label=True
)
return {
'create_form': CreateForm(self.req, security_list),
'edit_form': EditForm(self.req, security_list, prefix='edit'),
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_internal', 'address', 'security_id', 'sec_tls_ca_cert_id', 'pool_size'
input_optional = ('is_active', 'extra') + generic_attrs
output_required = 'id', 'name'
# ################################################################################################################################
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.OUTCONN_HL7_FHIR
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outgoing'] = True
initial_input_dict['is_outconn'] = False
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['recv_timeout'] = 250
# ################################################################################################################################
def pre_process_input_dict(self, input_dict):
input_dict['pool_size'] = int(input_dict['pool_size'])
# ################################################################################################################################
def success_message(self, item):
return 'Successfully {} HL7 FHIR outgoing connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'outgoing-hl7-fhir-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'outgoing-hl7-fhir-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'outgoing-hl7-fhir-delete'
error_message = 'Could not delete HL7 FHIR outgoing connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def invoke(req, conn_id, max_wait_time, conn_name, conn_slug):
return_data = {
'conn_id': conn_id,
'conn_name': conn_name,
'conn_slug': conn_slug,
'conn_type': GENERIC.CONNECTION.TYPE.OUTCONN_HL7_MLLP,
'timeout': max_wait_time,
'cluster_id': req.zato.cluster_id,
}
return TemplateResponse(req, 'zato/outgoing/hl7/fhir-invoke.html', return_data)
# ################################################################################################################################
@method_allowed('POST')
def invoke_action(req, conn_name):
return invoke_action_handler(req, 'zato.generic.connection.invoke', ('conn_name', 'conn_type', 'request_data', 'timeout'))
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.generic.connection.change-password', success_msg='Password updated')
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'HL7 FHIR connection')
# ################################################################################################################################
| 6,638
|
Python
|
.py
| 106
| 57.462264
| 130
| 0.408468
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,746
|
mllp.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/outgoing/hl7/mllp.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# Django
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.forms.outgoing.hl7.mllp import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index, invoke_action_handler, method_allowed
from zato.common.api import GENERIC, generic_attrs
from zato.common.model.hl7 import HL7MLLPConfigObject
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'outgoing-hl7-mllp'
template = 'zato/outgoing/hl7/mllp.html'
service_name = 'zato.generic.connection.get-list'
output_class = HL7MLLPConfigObject
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name', 'is_active', 'is_internal', 'security_name', 'address', 'pool_size'
output_optional = generic_attrs
output_repeated = True
# ################################################################################################################################
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_internal', 'address'
input_optional = ('is_active', 'pool_size') + generic_attrs
output_required = 'id', 'name'
# ################################################################################################################################
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.OUTCONN_HL7_MLLP
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = False
initial_input_dict['is_outgoing'] = True
initial_input_dict['is_outconn'] = False
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['recv_timeout'] = 250
# ################################################################################################################################
def success_message(self, item):
return 'Successfully {} HL7 MLLP outgoing connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'outgoing-hl7-mllp-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'outgoing-hl7-mllp-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'outgoing-hl7-mllp-delete'
error_message = 'Could not delete HL7 MLLP outgoing connection'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('GET')
def invoke(req, conn_id, max_wait_time, conn_name, conn_slug):
return_data = {
'conn_id': conn_id,
'conn_name': conn_name,
'conn_slug': conn_slug,
'conn_type': GENERIC.CONNECTION.TYPE.OUTCONN_HL7_MLLP,
'timeout': max_wait_time,
'cluster_id': req.zato.cluster_id,
}
return TemplateResponse(req, 'zato/outgoing/hl7/mllp-invoke.html', return_data)
# ################################################################################################################################
@method_allowed('POST')
def invoke_action(req, conn_name):
return invoke_action_handler(req, 'zato.generic.connection.invoke', ('conn_name', 'conn_type', 'request_data', 'timeout'))
# ################################################################################################################################
| 5,310
|
Python
|
.py
| 87
| 56.206897
| 130
| 0.393724
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,747
|
cassandra.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/definition/cassandra.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.definition.cassandra import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.api import CASSANDRA
from zato.common.odb.model import CassandraConn
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'def-cassandra'
template = 'zato/definition/cassandra.html'
service_name = 'zato.definition.cassandra.get-list'
output_class = CassandraConn
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'contact_points', 'port', 'exec_size',
'proto_version', 'default_keyspace')
output_optional = ('username', 'cql_version')
output_repeated = True
def handle(self):
return {
'default_port': CASSANDRA.DEFAULT.PORT,
'default_exec_size': CASSANDRA.DEFAULT.EXEC_SIZE,
'default_proto_version': CASSANDRA.DEFAULT.PROTOCOL_VERSION,
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('cluster_id', 'name', 'is_active', 'contact_points', 'port', 'exec_size',
'proto_version', 'default_keyspace')
input_optional = ('username', 'cql_version', 'tls_ca_certs', 'tls_client_cert', 'tls_client_priv_key')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {0} the connection [{1}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'definition-cassandra-create'
service_name = 'zato.definition.cassandra.create'
class Edit(_CreateEdit):
url_name = 'definition-cassandra-edit'
form_prefix = 'edit-'
service_name = 'zato.definition.cassandra.edit'
class Delete(_Delete):
url_name = 'definition-cassandra-delete'
error_message = 'Could not delete the connection'
service_name = 'zato.definition.cassandra.delete'
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.definition.cassandra.change-password')
| 2,688
|
Python
|
.py
| 60
| 39.266667
| 132
| 0.694104
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,748
|
kafka.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/definition/kafka.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.common.api import GENERIC
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.definition.kafka import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.odb.model import GenericConn
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'definition-kafka'
template = 'zato/definition/kafka.html'
service_name = 'zato.generic.connection.get-list'
output_class = GenericConn
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id', 'type_')
output_required = ('id', 'name', 'server_list', 'socket_timeout', 'offset_timeout', 'broker_version', 'server_list')
output_optional = ('is_active', 'should_use_zookeeper', 'should_exclude_internal_topics', 'source_address',
'is_tls_enabled', 'tls_private_key_file', 'tls_cert_file', 'tls_ca_certs_file', 'tls_pem_passphrase')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(req=self.req),
'edit_form': EditForm(prefix='edit', req=self.req),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'server_list', 'socket_timeout', 'offset_timeout', 'broker_version', 'server_list')
input_optional = ('is_active', 'should_use_zookeeper', 'should_exclude_internal_topics', 'source_address',
'is_tls_enabled', 'tls_private_key_file', 'tls_cert_file', 'tls_ca_certs_file', 'tls_pem_passphrase')
output_required = 'id', 'name'
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.DEF_KAFKA
initial_input_dict['is_internal'] = False
# This definition can be used to create connections in both directions
initial_input_dict['is_channel'] = True
initial_input_dict['is_outconn'] = True
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['pool_size'] = 1 # Not used but required on input
def on_after_set_input(self):
pass
def success_message(self, item):
return 'Successfully {} Kafka definition `{}`'.format(self.verb, item.name)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'definition-kafka-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'definition-kafka-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'definition-kafka-delete'
error_message = 'Could not delete outgoing Kafka definition'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.generic.connection.change-password')
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.generic.connection.ping', id, 'Kafka definition')
# ################################################################################################################################
| 4,655
|
Python
|
.py
| 80
| 53.0375
| 130
| 0.516505
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,749
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/definition/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,750
|
jms_wmq.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/definition/jms_wmq.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.definition.jms_wmq import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.odb.model import ConnDefWMQ
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'definition-wmq'
template = 'zato/definition/jms-wmq.html'
service_name = 'zato.definition.jms-wmq.get-list'
output_class = ConnDefWMQ
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'host', 'port', 'queue_manager', 'channel', 'cache_open_send_queues',
'cache_open_receive_queues', 'use_shared_connections', 'ssl', 'ssl_cipher_spec', 'ssl_key_repository',
'needs_mcd', 'max_chars_printed', 'username', 'use_jms')
output_repeated = True
def handle(self):
return {
'change_password_form': ChangePasswordForm(),
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'host', 'port', 'queue_manager', 'channel', 'cache_open_send_queues',
'cache_open_receive_queues', 'use_shared_connections', 'ssl', 'ssl_cipher_spec', 'ssl_key_repository', 'needs_mcd',
'max_chars_printed', 'username', 'use_jms')
output_required = ('id',)
def success_message(self, item):
return 'Successfully {} IBM MQ definition `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'definition-wmq-create'
service_name = 'zato.definition.jms-wmq.create'
class Edit(_CreateEdit):
url_name = 'definition-wmq-edit'
form_prefix = 'edit-'
service_name = 'zato.definition.jms-wmq.edit'
class Delete(_Delete):
url_name = 'definition-wmq-delete'
error_message = 'Could not delete IBM MQ definition'
service_name = 'zato.definition.jms-wmq.delete'
@method_allowed('POST')
def ping(req, id, cluster_id):
return ping_connection(req, 'zato.definition.jms-wmq.ping', id, 'IBM MQ definition')
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.definition.jms-wmq.change-password')
| 2,720
|
Python
|
.py
| 60
| 40.1
| 127
| 0.686341
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,751
|
amqp_.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/definition/amqp_.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.views import change_password as _change_password
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.definition.amqp_ import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.odb.model import ConnDefAMQP
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'def-amqp'
template = 'zato/definition/amqp.html'
service_name = 'zato.definition.amqp.get-list'
output_class = ConnDefAMQP
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'host', 'port', 'vhost', 'username', 'frame_max', 'heartbeat')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'host', 'port', 'vhost', 'username', 'frame_max', 'heartbeat')
output_required = ('id',)
def success_message(self, item):
return 'Successfully {} the AMQP definition `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'def-amqp-create'
service_name = 'zato.definition.amqp.create'
class Edit(_CreateEdit):
url_name = 'def-amqp-edit'
form_prefix = 'edit-'
service_name = 'zato.definition.amqp.edit'
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.definition.amqp.change-password')
class Delete(_Delete):
url_name = 'def-amqp-delete'
error_message = 'Could not delete the AMQP definition'
service_name = 'zato.definition.amqp.delete'
| 2,162
|
Python
|
.py
| 53
| 36.09434
| 103
| 0.695174
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,752
|
sql.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/notif/sql.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
from operator import itemgetter
# Zato
from zato.admin.web.forms.notif.sql import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import NotificationSQL
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
output_class = NotificationSQL
url_name = 'notif-sql'
template = 'zato/notif/sql.html'
service_name = 'zato.notif.sql.get-list'
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'cluster_id', 'is_active', 'def_id', 'interval', 'query', 'service_name')
output_repeated = True
def handle(self):
if self.req.zato.cluster_id:
sql_defs = self.req.zato.client.invoke('zato.outgoing.sql.get-list', {'cluster_id':self.req.zato.cluster_id}).data
sql_defs.sort(key=itemgetter('name'))
else:
sql_defs = []
return {
'create_form': CreateForm(sql_defs=sql_defs, req=self.req),
'edit_form': EditForm(prefix='edit', sql_defs=sql_defs, req=self.req)
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'cluster_id', 'is_active', 'def_id', 'interval', 'query', 'service_name')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {} the SQL notification `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'notif-sql-create'
service_name = 'zato.notif.sql.create'
class Edit(_CreateEdit):
url_name = 'notif-sql-edit'
form_prefix = 'edit-'
service_name = 'zato.notif.sql.edit'
class Delete(_Delete):
url_name = 'notif-sql-delete'
error_message = 'Could not delete the SQL notification'
service_name = 'zato.notif.sql.delete'
| 2,201
|
Python
|
.py
| 53
| 36.132075
| 126
| 0.671985
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,753
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/notif/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
| 238
|
Python
|
.py
| 6
| 38.166667
| 82
| 0.729258
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,754
|
keysight_vision.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/vendors/keysight_vision.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2023, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.vendors.keysight_vision import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed, ping_connection
from zato.common.api import Wrapper_Type
from zato.common.model.keysight_ import KeysightVisionConfigObject
# ################################################################################################################################
# ################################################################################################################################
if 0:
from zato.common.typing_ import any_, strdict
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'vendors-keysight-vision'
template = 'zato/vendors/keysight-vision.html'
service_name = 'zato.generic.rest-wrapper.get-list'
output_class = KeysightVisionConfigObject
paginate = True
wrapper_type = Wrapper_Type.Keysight_Vision
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
output_required = 'id', 'name', 'is_active', 'host', 'username', 'sec_tls_ca_cert_id'
output_repeated = True
# ################################################################################################################################
def handle(self) -> 'strdict':
return {
'create_form': CreateForm(req=self.req),
'edit_form': EditForm(req=self.req, prefix='edit'),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'id', 'name', 'is_active', 'host', 'username', 'sec_tls_ca_cert_id', 'password'
output_required = 'id', 'name'
# ################################################################################################################################
def populate_initial_input_dict(self, initial_input_dict:'strdict') -> 'None':
initial_input_dict['wrapper_type'] = Wrapper_Type.Keysight_Vision
# ################################################################################################################################
def success_message(self, item:'any_') -> 'str':
return f'Successfully {self.verb} Keysight Vision Series connection `{item.name}`'
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'vendors-keysight-vision-create'
service_name = 'zato.generic.rest-wrapper.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'vendors-keysight-vision-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.rest-wrapper.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'vendors-keysight-vision-delete'
error_message = 'Could not delete Keysight Vision Series connection'
service_name = 'zato.generic.rest-wrapper.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def change_password(req:'any_') -> 'any_':
return _change_password(req, 'zato.generic.rest-wrapper.change-password', success_msg='Password updated')
# ################################################################################################################################
@method_allowed('POST')
def ping(req:'any_', id:'int', cluster_id:'int') -> 'any_':
service = 'zato.generic.rest-wrapper.ping'
ping_path = '/api/users'
return ping_connection(req, service, id, 'Keysight Vision Series connection', ping_path=ping_path)
# ################################################################################################################################
| 5,334
|
Python
|
.py
| 79
| 63.43038
| 130
| 0.371724
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,755
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/vendors/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2023, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,756
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/audit_log/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# Zato
from zato.admin.web import from_utc_to_user
from zato.admin.web.forms.cache.builtin import CreateForm, EditForm
from zato.admin.web.views import Index as _Index, invoke_service_with_json_response, \
method_allowed
from zato.common.api import CACHE
from zato.common.model.audit_log import AuditLogEvent
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'audit-log'
template = 'zato/audit-log/index.html'
service_name = 'zato.audit-log.event.get-list'
output_class = AuditLogEvent
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_', 'object_id', 'object_name', 'object_type_label'
output_required = 'server_name', 'server_pid', 'type_', 'object_id', 'conn_id', 'direction', 'data', 'timestamp', \
'timestamp_utc', 'msg_id', 'in_reply_to', 'event_id'
output_optional = 'data',
output_repeated = True
def on_before_append_item(self, item):
# type: (AuditLogEvent)
item.timestamp_utc = item.timestamp
item.timestamp = from_utc_to_user(item.timestamp+'+00:00', self.req.zato.user_profile)
return item
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'default_max_size': CACHE.DEFAULT.MAX_SIZE,
'default_max_item_size': CACHE.DEFAULT.MAX_ITEM_SIZE,
'cluster_id': self.input.cluster_id,
'type_': self.input.type_,
'object_id': self.input.object_id,
'object_name': self.input.object_name,
'object_type_label': self.input.object_type_label,
}
# ################################################################################################################################
@method_allowed('POST')
def clear(req):
return invoke_service_with_json_response(
req, 'zato.audit-log.event.clear',
{
'cluster_id':req.POST['cluster_id'],
'cache_id':req.POST['cache_id']
},
'OK, audit log cleared.', 'Audit log could not be cleared, e:{e}')
# ################################################################################################################################
@method_allowed('GET')
def event_details(req):
pass
# ################################################################################################################################
@method_allowed('GET')
def delete_event(req):
pass
# ################################################################################################################################
| 2,997
|
Python
|
.py
| 63
| 41.412698
| 130
| 0.502399
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,757
|
aws.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/aws.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.security.aws import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.odb.model import AWSSecurity
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'security-aws'
template = 'zato/security/aws.html'
service_name = 'zato.security.aws.get-list'
output_class = AWSSecurity
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'username')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'username')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {} the AWS definition `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-aws-create'
service_name = 'zato.security.aws.create'
class Edit(_CreateEdit):
url_name = 'security-aws-edit'
form_prefix = 'edit-'
service_name = 'zato.security.aws.edit'
class Delete(_Delete):
url_name = 'security-aws-delete'
error_message = 'Could not delete the aws definition'
service_name = 'zato.security.aws.delete'
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.security.aws.change-password', success_msg='Access key updated')
| 2,081
|
Python
|
.py
| 52
| 35.25
| 132
| 0.69697
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,758
|
ntlm.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/ntlm.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.security.ntlm import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.odb.model import NTLM
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'security-ntlm'
template = 'zato/security/ntlm.html'
service_name = 'zato.security.ntlm.get-list'
output_class = NTLM
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'username')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'username')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {0} the NTLM definition [{1}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-ntlm-create'
service_name = 'zato.security.ntlm.create'
class Edit(_CreateEdit):
url_name = 'security-ntlm-edit'
form_prefix = 'edit-'
service_name = 'zato.security.ntlm.edit'
class Delete(_Delete):
url_name = 'security-ntlm-delete'
error_message = 'Could not delete the NTLM definition'
service_name = 'zato.security.ntlm.delete'
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.security.ntlm.change-password')
| 2,054
|
Python
|
.py
| 52
| 34.730769
| 132
| 0.695871
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,759
|
oauth.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/oauth.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.security.oauth import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, \
CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.api import NONCE_STORE
from zato.common.odb.model import OAuth
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'security-oauth'
template = 'zato/security/oauth.html'
service_name = 'zato.security.oauth.get-list'
output_class = OAuth
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'username',
'proto_version', 'sig_method', 'max_nonce_log')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm(),
'default_max_nonce_log': NONCE_STORE.DEFAULT_MAX_LOG,
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'username',
'proto_version', 'sig_method', 'max_nonce_log')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {0} the OAuth definition [{1}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-oauth-create'
service_name = 'zato.security.oauth.create'
class Edit(_CreateEdit):
url_name = 'security-oauth-edit'
form_prefix = 'edit-'
service_name = 'zato.security.oauth.edit'
class Delete(_Delete):
url_name = 'security-oauth-delete'
error_message = 'Could not delete the OAuth definition'
service_name = 'zato.security.oauth.delete'
@method_allowed('POST')
def change_secret(req):
return _change_password(req, 'zato.security.oauth.change-password')
| 2,301
|
Python
|
.py
| 57
| 35.210526
| 89
| 0.688061
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,760
|
basic_auth.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/basic_auth.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.security.basic_auth import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed
from zato.common.odb.model import HTTPBasicAuth
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'security-basic-auth'
template = 'zato/security/basic-auth.html'
service_name = 'zato.security.basic-auth.get-list'
output_class = HTTPBasicAuth
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
output_required = 'id', 'name', 'is_active', 'username', 'realm'
output_optional = 'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def'
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_active', 'username', 'realm'
input_optional = 'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def'
output_required = 'id', 'name'
def success_message(self, item):
return 'Successfully {} HTTP Basic Auth definition `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-basic-auth-create'
service_name = 'zato.security.basic-auth.create'
class Edit(_CreateEdit):
url_name = 'security-basic-auth-edit'
form_prefix = 'edit-'
service_name = 'zato.security.basic-auth.edit'
class Delete(_Delete):
url_name = 'security-basic-auth-delete'
error_message = 'Could not delete the HTTP Basic Auth definition'
service_name = 'zato.security.basic-auth.delete'
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.security.basic-auth.change-password')
| 2,404
|
Python
|
.py
| 55
| 38.763636
| 119
| 0.700814
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,761
|
apikey.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/apikey.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2024, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.security.apikey import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.odb.model import APIKeySecurity
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'security-apikey'
template = 'zato/security/apikey.html'
service_name = 'zato.security.apikey.get-list'
output_class = APIKeySecurity
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
output_required = 'id', 'name', 'is_active', 'username'
output_optional = 'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def', 'header'
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_active', 'username'
input_optional = 'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def'
output_required = 'id', 'name'
def success_message(self, item):
return 'Successfully {} API key `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-apikey-create'
service_name = 'zato.security.apikey.create'
class Edit(_CreateEdit):
url_name = 'security-apikey-edit'
form_prefix = 'edit-'
service_name = 'zato.security.apikey.edit'
class Delete(_Delete):
url_name = 'security-apikey-delete'
error_message = 'Could not delete the API key'
service_name = 'zato.security.apikey.delete'
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.security.apikey.change-password', success_msg='API key updated')
| 2,256
|
Python
|
.py
| 53
| 37.584906
| 132
| 0.696069
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,762
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,763
|
wss.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/wss.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,764
|
jwt.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/jwt.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.security.jwt import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, Index as _Index, \
method_allowed
from zato.common.odb.model import JWT
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'security-jwt'
template = 'zato/security/jwt.html'
service_name = 'zato.security.jwt.get-list'
output_class = JWT
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
output_required = 'id', 'name', 'is_active', 'username', 'ttl'
output_optional = 'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def'
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_active', 'username', 'ttl'
input_optional = 'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def'
output_required = 'id', 'name'
def success_message(self, item):
return 'Successfully {} JWT definition `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-jwt-create'
service_name = 'zato.security.jwt.create'
class Edit(_CreateEdit):
url_name = 'security-jwt-edit'
form_prefix = 'edit-'
service_name = 'zato.security.jwt.edit'
class Delete(_Delete):
url_name = 'security-jwt-delete'
error_message = 'Could not delete the JWT definition'
service_name = 'zato.security.jwt.delete'
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.security.jwt.change-password')
| 2,279
|
Python
|
.py
| 55
| 36.490909
| 119
| 0.69067
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,765
|
xpath.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/xpath.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,766
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/oauth/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,767
|
outconn_client_credentials.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/oauth/outconn_client_credentials.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2023, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.security.oauth.outconn_client_credentials import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, \
CreateEdit, Delete as _Delete, Index as _Index, method_allowed
from zato.common.odb.model import OAuth
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'security-oauth-outconn-client-credentials'
template = 'zato/security/oauth/outconn-client-credentials.html'
service_name = 'zato.security.oauth.get-list'
output_class = OAuth
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
output_required = 'id', 'name', 'is_active', 'username', 'auth_server_url', 'scopes', \
'client_id_field', 'client_secret_field', 'grant_type', 'extra_fields', 'data_format'
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm(),
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_active', 'username', 'auth_server_url', 'scopes', \
'client_id_field', 'client_secret_field', 'grant_type', 'extra_fields', 'data_format'
output_required = 'id', 'name'
def success_message(self, item):
return 'Bearer token definition `{}` {} successfully'.format(item.name, self.verb)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'security-oauth-outconn-client-credentials-create'
service_name = 'zato.security.oauth.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'security-oauth-outconn-client-credentials-edit'
form_prefix = 'edit-'
service_name = 'zato.security.oauth.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'security-oauth-outconn-client-credentials-delete'
error_message = 'Bearer token definition could not be deleted'
service_name = 'zato.security.oauth.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def change_secret(req):
return _change_password(req, 'zato.security.oauth.change-password', success_msg='Secret updated')
# ################################################################################################################################
# ################################################################################################################################
| 4,547
|
Python
|
.py
| 70
| 60.642857
| 130
| 0.372923
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,768
|
connection.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/vault/connection.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.security.vault.connection import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import VaultConnection
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
output_class = VaultConnection
url_name = 'security-vault-conn'
template = 'zato/security/vault/connection.html'
service_name = 'zato.security.vault.connection.get-list'
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'url', 'default_auth_method', 'timeout', 'allow_redirects', 'tls_verify')
output_optional = ('token', 'service_id', 'service_name')
output_repeated = True
def on_before_append_item(self, item):
item.token = item.token or ''
item.default_auth_method = item.default_auth_method or ''
return item
def handle(self):
return {
'create_form': CreateForm(self.req),
'edit_form': EditForm(self.req, prefix='edit'),
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('id', 'name', 'is_active', 'url', 'default_auth_method', 'timeout', 'allow_redirects', 'sec_type',
'tls_verify', 'cluster_id')
input_optional = ('token', 'service_id')
output_required = ('id', 'service_name')
def post_process_return_data(self, return_data):
if self.input.service_id:
response = self.req.zato.client.invoke('zato.service.get-by-id', {
'id': self.input.service_id,
'cluster_id': self.req.zato.cluster_id
})
return_data['service_id'] = response.data.id
return_data['service_name'] = response.data.name
return return_data
def success_message(self, item):
return 'Successfully {} Vault connection `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-vault-conn-create'
service_name = 'zato.security.vault.connection.create'
class Edit(_CreateEdit):
url_name = 'security-vault-conn-edit'
form_prefix = 'edit-'
service_name = 'zato.security.vault.connection.edit'
class Delete(_Delete):
url_name = 'security-vault-conn-delete'
error_message = 'Could not delete the role permission'
service_name = 'zato.security.vault.connection.delete'
| 2,784
|
Python
|
.py
| 63
| 37.793651
| 127
| 0.665679
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,769
|
role.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/rbac/role.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.security.rbac.role import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import RBACRole
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
output_class = RBACRole
url_name = 'security-rbac-role'
template = 'zato/security/rbac/role.html'
service_name = 'zato.security.rbac.role.get-list'
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'parent_id', 'parent_name')
output_repeated = True
def handle(self):
items = []
if self.req.zato.cluster_id:
service_name = 'zato.security.rbac.role.get-list'
response = self.req.zato.client.invoke(service_name, {'cluster_id':self.req.zato.cluster_id})
if response.has_data:
items = response.data
return {
'create_form': CreateForm(items),
'edit_form': EditForm(items, prefix='edit')
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'parent_id')
output_required = ('id', 'name', 'parent_id', 'parent_name')
def success_message(self, item):
return 'Successfully {} the role `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-rbac-role-create'
service_name = 'zato.security.rbac.role.create'
class Edit(_CreateEdit):
url_name = 'security-rbac-role-edit'
form_prefix = 'edit-'
service_name = 'zato.security.rbac.role.edit'
class Delete(_Delete):
url_name = 'security-rbac-role-delete'
error_message = 'Could not delete the role'
service_name = 'zato.security.rbac.role.delete'
| 2,112
|
Python
|
.py
| 52
| 34.903846
| 105
| 0.67254
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,770
|
role_permission.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/rbac/role_permission.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.security.rbac.role_permission import CreateForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import RBACRolePermission
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
output_class = RBACRolePermission
url_name = 'security-rbac-role-permission'
template = 'zato/security/rbac/role-permission.html'
service_name = 'zato.security.rbac.role-permission.get-list'
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'role_id', 'role_name', 'service_id', 'service_name', 'perm_id', 'perm_name')
output_repeated = True
def handle(self):
role_id_list = []
service_id_list = []
perm_id_list = []
if self.req.zato.cluster_id:
service_name = 'zato.security.rbac.role.get-list'
response = self.req.zato.client.invoke(service_name, {'cluster_id':self.req.zato.cluster_id})
if response.has_data:
role_id_list = response.data
service_name = 'zato.service.get-list'
response = self.req.zato.client.invoke(service_name, {'cluster_id':self.req.zato.cluster_id, 'name_filter':'*'})
if response.has_data:
service_id_list = response.data
service_name = 'zato.security.rbac.permission.get-list'
response = self.req.zato.client.invoke(service_name, {'cluster_id':self.req.zato.cluster_id})
if response.has_data:
perm_id_list = response.data
return {
'create_form': CreateForm(role_id_list, service_id_list, perm_id_list)
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('cluster_id', 'role_id', 'service_id', 'perm_id')
output_required = ('id', 'role_name', 'service_name', 'perm_name')
def success_message(self, item):
return 'Successfully {} the role permission `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-rbac-role-permission-create'
service_name = 'zato.security.rbac.role-permission.create'
class Delete(_Delete):
url_name = 'security-rbac-role-permission-delete'
error_message = 'Could not delete the role permission'
service_name = 'zato.security.rbac.role-permission.delete'
| 2,751
|
Python
|
.py
| 58
| 40.431034
| 124
| 0.668911
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,771
|
client_role.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/rbac/client_role.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.security.rbac.client_role import CreateForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import RBACRole
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
output_class = RBACRole
url_name = 'security-rbac-client-role'
template = 'zato/security/rbac/client-role.html'
service_name = 'zato.security.rbac.client-role.get-list'
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'client_def', 'client_name', 'role_id', 'role_name')
output_repeated = True
def handle(self):
client_def_list = []
role_id_list = []
if self.req.zato.cluster_id:
service_name = 'zato.security.rbac.client-role.get-client-def-list'
response = self.req.zato.client.invoke(service_name, {'cluster_id':self.req.zato.cluster_id})
if response.has_data:
client_def_list = response.data
service_name = 'zato.security.rbac.role.get-list'
response = self.req.zato.client.invoke(service_name, {'cluster_id':self.req.zato.cluster_id})
if response.has_data:
role_id_list = response.data
return {
'create_form': CreateForm(client_def_list, role_id_list)
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('client_def', 'role_id')
output_required = ('id', 'client_name', 'role_name')
def success_message(self, item):
return 'Successfully {} the client role `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-rbac-client-role-create'
service_name = 'zato.security.rbac.client-role.create'
class Delete(_Delete):
url_name = 'security-rbac-client-role-delete'
error_message = 'Could not delete the client role'
service_name = 'zato.security.rbac.client-role.delete'
| 2,343
|
Python
|
.py
| 53
| 37.792453
| 105
| 0.673272
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,772
|
permission.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/rbac/permission.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.security.rbac.permission import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import RBACPermission
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
output_class = RBACPermission
url_name = 'security-rbac-permission'
template = 'zato/security/rbac/permission.html'
service_name = 'zato.security.rbac.permission.get-list'
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit')
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name',)
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {} the permission `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-rbac-permission-create'
service_name = 'zato.security.rbac.permission.create'
class Edit(_CreateEdit):
url_name = 'security-rbac-permission-edit'
form_prefix = 'edit-'
service_name = 'zato.security.rbac.permission.edit'
class Delete(_Delete):
url_name = 'security-rbac-permission-delete'
error_message = 'Could not delete the permission'
service_name = 'zato.security.rbac.permission.delete'
| 1,838
|
Python
|
.py
| 47
| 34.297872
| 82
| 0.701577
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,773
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/rbac/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
from . import client_role, permission, role, role_permission
# So pyflakes doesn't complain
client_role
permission
role
role_permission
| 376
|
Python
|
.py
| 12
| 29.916667
| 82
| 0.771588
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,774
|
channel.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/tls/channel.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.security.tls.channel import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import TLSChannelSecurity
logger = logging.getLogger(__name__)
class Index(_Index):
output_class = TLSChannelSecurity
url_name = 'security-tls-channel'
template = 'zato/security/tls/channel.html'
service_name = 'zato.security.tls.channel.get-list'
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'value', 'is_active')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'value', 'is_active')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {} the TLS channel security definition [{}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-tls-channel-create'
service_name = 'zato.security.tls.channel.create'
class Edit(_CreateEdit):
url_name = 'security-tls-channel-edit'
form_prefix = 'edit-'
service_name = 'zato.security.tls.channel.edit'
class Delete(_Delete):
url_name = 'security-tls-channel-delete'
error_message = 'Could not delete the TLS channel security definition'
service_name = 'zato.security.tls.channel.delete'
| 1,865
|
Python
|
.py
| 46
| 35.73913
| 102
| 0.698448
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,775
|
ca_cert.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/tls/ca_cert.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.security.tls.ca_cert import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import TLSCACert
logger = logging.getLogger(__name__)
class Index(_Index):
output_class = TLSCACert
url_name = 'security-tls-ca-cert'
template = 'zato/security/tls/ca-cert.html'
service_name = 'zato.security.tls.ca-cert.get-list'
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'value', 'info', 'is_active')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'value', 'is_active')
output_required = ('id', 'name', 'info')
def success_message(self, item):
return 'Successfully {} the TLS CA certificate [{}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-tls-ca-cert-create'
service_name = 'zato.security.tls.ca-cert.create'
class Edit(_CreateEdit):
url_name = 'security-tls-ca-cert-edit'
form_prefix = 'edit-'
service_name = 'zato.security.tls.ca-cert.edit'
class Delete(_Delete):
url_name = 'security-tls-ca-cert-delete'
error_message = 'Could not delete the TLS CA certificate'
service_name = 'zato.security.tls.ca-cert.delete'
| 1,837
|
Python
|
.py
| 46
| 35.130435
| 89
| 0.684685
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,776
|
key_cert.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/tls/key_cert.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.security.tls.key_cert import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import TLSKeyCertSecurity
logger = logging.getLogger(__name__)
class Index(_Index):
output_class = TLSKeyCertSecurity
url_name = 'security-tls-key-cert'
template = 'zato/security/tls/key-cert.html'
service_name = 'zato.security.tls.key-cert.get-list'
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'info', 'auth_data', 'is_active')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'auth_data', 'is_active')
output_required = ('id', 'name', 'info')
def success_message(self, item):
return 'Successfully {} the TLS key/cert pair [{}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'security-tls-key-cert-create'
service_name = 'zato.security.tls.key-cert.create'
class Edit(_CreateEdit):
url_name = 'security-tls-key-cert-edit'
form_prefix = 'edit-'
service_name = 'zato.security.tls.key-cert.edit'
class Delete(_Delete):
url_name = 'security-tls-key-cert-delete'
error_message = 'Could not delete the TLS key/cert pair'
service_name = 'zato.security.tls.key-cert.delete'
| 1,871
|
Python
|
.py
| 46
| 35.869565
| 88
| 0.688398
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,777
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/security/tls/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
| 238
|
Python
|
.py
| 6
| 38.166667
| 82
| 0.729258
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,778
|
file_transfer.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/file_transfer.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# Zato
from zato.admin.web.forms.channel.file_transfer import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, get_outconn_rest_list, Index as _Index
from zato.common.api import FILE_TRANSFER, GENERIC
from zato.common.json_internal import dumps
from zato.common.model.file_transfer import FileTransferChannel
# ################################################################################################################################
# ################################################################################################################################
source_type_ftp = FILE_TRANSFER.SOURCE_TYPE.FTP.id
source_type_local = FILE_TRANSFER.SOURCE_TYPE.LOCAL.id
source_type_sftp = FILE_TRANSFER.SOURCE_TYPE.SFTP.id
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'channel-file-transfer'
template = 'zato/channel/file-transfer.html'
service_name = 'zato.generic.connection.get-list'
output_class = FileTransferChannel
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name', 'is_active', 'source_type', 'pickup_from_list'
output_optional = 'service_list', 'topic_list', 'move_processed_to', 'file_patterns', 'parse_with', \
'should_read_on_pickup', 'should_parse_on_pickup', 'should_delete_after_pickup', 'ftp_source_id', 'sftp_source_id', \
'scheduler_job_id', 'ftp_source_name', 'sftp_source_name', 'is_case_sensitive', 'is_line_by_line', 'is_hot_deploy', \
'binary_file_patterns', 'data_encoding', 'outconn_rest_list'
output_repeated = True
# ################################################################################################################################
def handle(self):
return {
'create_form': CreateForm(req=self.req),
'edit_form': EditForm(prefix='edit', req=self.req),
}
# ################################################################################################################################
def on_before_append_item(self, item):
# type: (FileTransferChannel) -> FileTransferChannel
if item.service_list:
item.service_list = item.service_list if isinstance(item.service_list, list) else [item.service_list]
item.service_list = sorted(item.service_list)
item.service_list_json = dumps(item.service_list)
if item.topic_list:
item.topic_list = item.topic_list if isinstance(item.topic_list, list) else [item.topic_list]
item.topic_list = sorted(item.topic_list)
item.topic_list_json = dumps(item.topic_list)
if item.outconn_rest_list:
# All REST outgoing connections for the cluster
all_outconn_rest_list = get_outconn_rest_list(self.req)
item.outconn_rest_list = item.outconn_rest_list if isinstance(item.outconn_rest_list, list) else \
[item.outconn_rest_list]
item.outconn_rest_list_by_name = sorted(all_outconn_rest_list[int(elem)] for elem in item.outconn_rest_list if elem)
item.outconn_rest_list_json = dumps(item.outconn_rest_list)
return item
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_active', 'source_type', 'pickup_from_list'
input_optional = 'service_list', 'topic_list', 'move_processed_to', 'file_patterns', 'parse_with', 'should_read_on_pickup', \
'should_parse_on_pickup', 'should_delete_after_pickup', 'ftp_source_id', 'sftp_source_id', 'scheduler_job_id', \
'is_case_sensitive', 'is_line_by_line', 'is_hot_deploy', 'binary_file_patterns', 'data_encoding', \
'outconn_rest_list'
output_required = 'id', 'name'
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.CHANNEL_FILE_TRANSFER
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = True
initial_input_dict['is_outconn'] = False
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['pool_size'] = 1
def pre_process_item(self, name, value):
if name in ('service_list', 'topic_list', 'outconn_rest_list'):
if value:
if isinstance(value, list):
value = sorted({elem for elem in value if elem})
else:
value = [value] if value else []
return value
def post_process_return_data(self, return_data):
service_list_html = ''
topic_list_html = ''
outconn_rest_list_html = ''
cluster_id = self.input_dict['cluster_id']
service_list = sorted(set(self.input_dict['service_list'] or []))
topic_list = sorted(set(self.input_dict['topic_list'] or []))
outconn_rest_list = self.input_dict['outconn_rest_list'] or []
if outconn_rest_list:
# All REST outgoing connections for the cluster
all_outconn_rest_list = get_outconn_rest_list(self.req)
outconn_rest_list = outconn_rest_list if isinstance(outconn_rest_list, list) else [outconn_rest_list]
outconn_rest_list = sorted({all_outconn_rest_list[int(elem)] for elem in outconn_rest_list if elem})
#
# Services
#
for service_name in service_list:
if not service_name:
continue
# The list of services as HTML
service_list_html += """
<span class="form_hint">S</span>→
<a href="/zato/service/overview/{service_name}/?cluster={cluster_id}">{service_name}</a>
<br/>
""".format(**{
'service_name': service_name,
'cluster_id': cluster_id
})
#
# Topics
#
for topic_name in topic_list:
if not topic_name:
continue
# The list of topics as HTML
topic_list_html += """
<span class="form_hint">T</span>→
<a href="/zato/pubsub/topic/?cluster={cluster_id}&query={topic_name}">{topic_name}</a>
<br/>
""".format(**{
'topic_name': topic_name,
'cluster_id': cluster_id
})
#
# REST
#
for outconn_name in outconn_rest_list:
if not outconn_name:
continue
# The list of REST outconns as HTML
outconn_rest_list_html += """
<span class="form_hint">R</span>→
<a href="/zato/http-soap/?cluster={cluster_id}&connection=outgoing&transport=plain_http&query={outconn_name}">{outconn_name}</a>
<br/>
""".format(**{
'outconn_name': outconn_name,
'cluster_id': cluster_id
})
# Get human-readable names of the source for this channel
if self.input.source_type == source_type_local:
# Nothing to do in this case
pass
elif self.input.source_type == source_type_ftp:
if self.input.ftp_source_id:
response = self.req.zato.client.invoke('zato.outgoing.ftp.get-by-id', {
'cluster_id': cluster_id,
'id': self.input.ftp_source_id,
})
return_data['ftp_source_name'] = response.data['name']
elif self.input.source_type == source_type_sftp:
raise NotImplementedError()
else:
raise ValueError('Unknown self.input.source_type')
#
# Return data
#
return_data['recipients_html'] = service_list_html + topic_list_html + outconn_rest_list_html
return_data['service_list'] = service_list
return_data['topic_list'] = topic_list
return_data['outconn_rest_list'] = outconn_rest_list
def success_message(self, item):
return 'Successfully {} file transfer channel `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'channel-file-transfer-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'channel-file-transfer-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'channel-file-transfer-delete'
error_message = 'Could not delete file transfer channel'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
| 10,484
|
Python
|
.py
| 186
| 46.951613
| 156
| 0.489788
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,779
|
json_rpc.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/json_rpc.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.channel.json_rpc import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, get_http_channel_security_id, get_security_id_from_select, \
Index as _Index
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
class JSONRPC:
def __init__(self):
self.id = None
self.name = None
self.url_path = None
self.sec_type = None
self.security_id = None
self.service_whitelist = None
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'channel-json-rpc'
template = 'zato/channel/json-rpc.html'
service_name = 'zato.channel.json-rpc.get-list'
output_class = JSONRPC
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
output_required = 'cluster_id', 'id', 'name', 'is_active', 'url_path', 'sec_type', 'sec_use_rbac', 'security_id', \
'service_whitelist'
output_optional = 'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def'
output_repeated = True
def on_before_append_item(self, item):
item.service_whitelist = '\n'.join(item.service_whitelist) if item.service_whitelist else ''
item.security_id = get_http_channel_security_id(item)
return item
def handle(self):
if self.req.zato.cluster_id:
sec_list = self.get_sec_def_list('basic_auth').def_items
sec_list.extend(self.get_sec_def_list('jwt'))
sec_list.extend(self.get_sec_def_list('vault_conn_sec'))
else:
sec_list = []
return {
'create_form': CreateForm(sec_list, req=self.req),
'edit_form': EditForm(sec_list, prefix='edit', req=self.req),
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'cluster_id', 'name', 'is_active', 'url_path', 'security_id', 'service_whitelist'
input_optional = 'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def'
output_required = 'id', 'name'
def on_after_set_input(self):
self.input.security_id = get_security_id_from_select(self.input, '', 'security_id')
self.input.service_whitelist = self.input.service_whitelist.strip().splitlines()
def success_message(self, item):
return 'JSON-RPC channel `{}` successfully {}'.format(item.name, self.verb)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'channel-json-rpc-create'
service_name = 'zato.channel.json-rpc.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'channel-json-rpc-edit'
form_prefix = 'edit-'
service_name = 'zato.channel.json-rpc.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'channel-json-rpc-delete'
error_message = 'Could not delete JSON-RPC channel'
service_name = 'zato.channel.json-rpc.delete'
# ################################################################################################################################
| 4,227
|
Python
|
.py
| 79
| 47.556962
| 130
| 0.495386
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,780
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,781
|
jms_wmq.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/jms_wmq.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
from traceback import format_exc
# Django
from django.http import HttpResponse, HttpResponseServerError
# Zato
from zato.admin.web.forms.channel.jms_wmq import CreateForm, EditForm
from zato.admin.web.views import Delete as _Delete, get_definition_list, Index as _Index, method_allowed
from zato.common.json_internal import dumps
from zato.common.odb.model import ChannelWMQ
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
def _get_edit_create_message(params, prefix=''):
""" Creates a base dictionary which can be used by both 'edit' and 'create' actions.
"""
return {
'id': params.get('id'),
'cluster_id': params['cluster_id'],
'name': params[prefix + 'name'],
'is_active': bool(params.get(prefix + 'is_active')),
'def_id': params[prefix + 'def_id'],
'queue': params[prefix + 'queue'],
'service': params[prefix + 'service'],
'data_format': params.get(prefix + 'data_format'),
}
# ################################################################################################################################
def _edit_create_response(client, verb, id, name, cluster_id, def_id):
response = client.invoke('zato.definition.jms-wmq.get-by-id', {'id':def_id, 'cluster_id': cluster_id})
return_data = {
'id': id,
'message': 'Successfully {} IBM MQ channel `{}`'.format(verb, name),
'def_name': response.data.name
}
return HttpResponse(dumps(return_data), content_type='application/javascript')
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'channel-jms-wmq'
template = 'zato/channel/jms-wmq.html'
service_name = 'zato.channel.jms-wmq.get-list'
output_class = ChannelWMQ
paginate = True
# ################################################################################################################################
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'queue', 'def_name', 'def_id', 'service_name', 'data_format')
output_repeated = True
# ################################################################################################################################
def handle(self):
create_form = CreateForm(req=self.req)
edit_form = EditForm(prefix='edit', req=self.req)
if self.req.zato.cluster_id:
def_ids = get_definition_list(self.req.zato.client, self.req.zato.cluster, 'jms-wmq')
create_form.set_def_id(def_ids)
edit_form.set_def_id(def_ids)
return {
'create_form': create_form,
'edit_form': edit_form,
}
# ################################################################################################################################
@method_allowed('POST')
def create(req):
try:
response = req.zato.client.invoke('zato.channel.jms-wmq.create', _get_edit_create_message(req.POST))
return _edit_create_response(
req.zato.client, 'created', response.data.id, req.POST['name'], req.POST['cluster_id'], req.POST['def_id'])
except Exception:
msg = 'Could not create an IBM MQ channel, e:`{}`'.format(format_exc)
logger.error(msg)
return HttpResponseServerError(msg)
# ################################################################################################################################
@method_allowed('POST')
def edit(req):
try:
req.zato.client.invoke('zato.channel.jms-wmq.edit', _get_edit_create_message(req.POST, 'edit-'))
return _edit_create_response(
req.zato.client, 'updated', req.POST['id'], req.POST['edit-name'], req.POST['cluster_id'], req.POST['edit-def_id'])
except Exception:
msg = 'Could not update IBM MQ channel, e:`{}`'.format(format_exc())
return HttpResponseServerError(msg)
# ################################################################################################################################
class Delete(_Delete):
url_name = 'channel-jms-wmq-delete'
error_message = 'Could not delete IBM MQ channel'
service_name = 'zato.channel.jms-wmq.delete'
# ################################################################################################################################
| 4,984
|
Python
|
.py
| 93
| 47.978495
| 130
| 0.482517
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,782
|
amqp_.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/amqp_.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
from traceback import format_exc
# Django
from django.http import HttpResponse, HttpResponseServerError
# Zato
from zato.admin.web.forms.channel.amqp_ import CreateForm, EditForm
from zato.admin.web.views import Delete as _Delete, get_definition_list, Index as _Index, method_allowed
from zato.common.json_internal import dumps
from zato.common.odb.model import ChannelAMQP
logger = logging.getLogger(__name__)
def _get_edit_create_message(params, prefix=''):
""" Creates a base dictionary which can be used by both 'edit' and 'create' actions.
"""
return {
'id': params.get('id'),
'cluster_id': params['cluster_id'],
'name': params[prefix + 'name'],
'is_active': bool(params.get(prefix + 'is_active')),
'def_id': params[prefix + 'def_id'],
'queue': params[prefix + 'queue'],
'consumer_tag_prefix': params[prefix + 'consumer_tag_prefix'],
'service': params[prefix + 'service'],
'pool_size': params.get(prefix + 'pool_size'),
'ack_mode': params.get(prefix + 'ack_mode'),
'prefetch_count': params.get(prefix + 'prefetch_count'),
'data_format': params.get(prefix + 'data_format'),
}
def _edit_create_response(client, verb, id, name, def_id, cluster_id):
response = client.invoke('zato.definition.amqp.get-by-id', {'id':def_id, 'cluster_id':cluster_id})
return_data = {'id': id,
'message': 'Successfully {} the AMQP channel `{}`'.format(verb, name),
'def_name': response.data.name
}
return HttpResponse(dumps(return_data), content_type='application/javascript')
class Index(_Index):
method_allowed = 'GET'
url_name = 'channel-amqp'
template = 'zato/channel/amqp.html'
service_name = 'zato.channel.amqp.get-list'
output_class = ChannelAMQP
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'queue', 'consumer_tag_prefix', 'def_name', 'def_id', 'service_name',
'pool_size', 'ack_mode','prefetch_count', 'data_format')
output_repeated = True
def handle(self):
create_form = CreateForm(req=self.req)
edit_form = EditForm(prefix='edit', req=self.req)
if self.req.zato.cluster_id:
def_ids = get_definition_list(self.req.zato.client, self.req.zato.cluster, 'amqp')
create_form.set_def_id(def_ids)
edit_form.set_def_id(def_ids)
return {
'create_form': create_form,
'edit_form': edit_form,
}
@method_allowed('POST')
def create(req):
try:
response = req.zato.client.invoke('zato.channel.amqp.create', _get_edit_create_message(req.POST))
return _edit_create_response(req.zato.client, 'created', response.data.id,
req.POST['name'], req.POST['def_id'], req.POST['cluster_id'])
except Exception:
msg = 'Could not create an AMQP channel, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
@method_allowed('POST')
def edit(req):
try:
req.zato.client.invoke('zato.channel.amqp.edit', _get_edit_create_message(req.POST, 'edit-'))
return _edit_create_response(req.zato.client, 'updated', req.POST['id'], req.POST['edit-name'],
req.POST['edit-def_id'], req.POST['cluster_id'])
except Exception:
msg = 'Could not update the AMQP channel, e:`{}`'.format(format_exc())
logger.error(msg)
return HttpResponseServerError(msg)
class Delete(_Delete):
url_name = 'channel-amqp-delete'
error_message = 'Could not delete the AMQP channel'
service_name = 'zato.channel.amqp.delete'
| 4,012
|
Python
|
.py
| 88
| 38.943182
| 123
| 0.650192
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,783
|
zmq.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/zmq.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.channel.zmq import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.odb.model import ChannelZMQ
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'channel-zmq'
template = 'zato/channel/zmq.html'
service_name = 'zato.channel.zmq.get-list'
output_class = ChannelZMQ
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'address', 'socket_type', 'socket_method', 'sub_key',
'service_name', 'pool_strategy', 'service_source', 'data_format')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(req=self.req),
'edit_form': EditForm(prefix='edit', req=self.req),
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'address', 'socket_type', 'socket_method', 'sub_key',
'service', 'pool_strategy', 'service_source', 'data_format')
output_required = ('id', 'name')
def success_message(self, item):
return 'ZeroMQ channel `{}` successfully {}'.format(item.name, self.verb)
class Create(_CreateEdit):
url_name = 'channel-zmq-create'
service_name = 'zato.channel.zmq.create'
class Edit(_CreateEdit):
url_name = 'channel-zmq-edit'
form_prefix = 'edit-'
service_name = 'zato.channel.zmq.edit'
class Delete(_Delete):
url_name = 'channel-zmq-delete'
error_message = 'Could not delete the Zero MQ channel'
service_name = 'zato.channel.zmq.delete'
| 2,016
|
Python
|
.py
| 49
| 36
| 107
| 0.673668
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,784
|
web_socket.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/web_socket.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
# Django
from django.template.response import TemplateResponse
# Zato
from zato.admin.web import from_utc_to_user
from zato.admin.web.forms.channel.web_socket import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index, invoke_action_handler, method_allowed
from zato.common.api import AuditLog, WEB_SOCKET, ZATO_NONE
from zato.common.odb.model import ChannelWebSocket
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
_max_len_messages = AuditLog.Default.max_len_messages
_max_data_stored_per_message = AuditLog.Default.max_data_stored_per_message
_pings_missed_threshold = WEB_SOCKET.DEFAULT.PINGS_MISSED_THRESHOLD
_ping_interval = WEB_SOCKET.DEFAULT.PING_INTERVAL
# ################################################################################################################################
generic_attrs = ('is_audit_log_sent_active', 'is_audit_log_received_active', 'max_len_messages_sent', \
'max_len_messages_received', 'max_bytes_per_message_sent', 'max_bytes_per_message_received',
'ping_interval', 'pings_missed_threshold')
# ################################################################################################################################
class WSXConnection:
def __init__(self):
self.id = None
self.local_address = None
self.peer_address = None
self.peer_fqdn = None
self.pub_client_id = None
self.ext_client_id = None
self.connection_time = None
self.connection_time_utc = None
self.server_name = None
self.server_proc_pid = None
self.ext_client_name = None
self.sub_count = 0
# ################################################################################################################################
class WSXSubKeyData:
def __init__(self):
self.sub_key = None
self.creation_time = None
self.topic_id = None
self.topic_name = None
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'channel-web-socket'
template = 'zato/channel/web-socket.html'
service_name = 'zato.channel.web-socket.get-list'
output_class = ChannelWebSocket
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'address', 'service_name', 'token_format', 'data_format',
'security_id', 'sec_type', 'new_token_wait_time', 'token_ttl')
output_optional = generic_attrs
output_repeated = True
def on_before_append_item(self, item):
if item.security_id:
item.security_id = '{}/{}'.format(item.sec_type, item.security_id)
else:
item.security_id = ZATO_NONE
return item
def handle(self):
if self.req.zato.cluster_id:
sec_list = self.get_sec_def_list('basic_auth').def_items
sec_list.extend(self.get_sec_def_list('jwt'))
sec_list.extend(self.get_sec_def_list('vault_conn_sec'))
else:
sec_list = []
return {
'create_form': CreateForm(sec_list, req=self.req),
'edit_form': EditForm(sec_list, prefix='edit', req=self.req),
'audit_max_len_messages': _max_len_messages,
'audit_max_data_stored_per_message': _max_data_stored_per_message,
'pings_missed_threshold': _pings_missed_threshold,
'ping_interval': _ping_interval,
}
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'address', 'service_name', 'token_format', 'data_format', 'is_internal',
'security_id', 'new_token_wait_time', 'token_ttl')
input_optional = generic_attrs
output_required = ('id', 'name')
def on_after_set_input(self):
if self.input.security_id != ZATO_NONE:
self.input.security_id = int(self.input.security_id.split('/')[1])
else:
self.input.security_id = None
def success_message(self, item):
return 'WebSocket channel `{}` successfully {}'.format(item.name, self.verb)
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'channel-web-socket-create'
service_name = 'zato.channel.web-socket.create'
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'channel-web-socket-edit'
form_prefix = 'edit-'
service_name = 'zato.channel.web-socket.edit'
# ################################################################################################################################
class Delete(_Delete):
url_name = 'channel-web-socket-delete'
error_message = 'Could not delete WebSocket channel'
service_name = 'zato.channel.web-socket.delete'
# ################################################################################################################################
class ConnectionList(_Index):
method_allowed = 'GET'
url_name = 'channel-web-socket-connection-list'
template = 'zato/channel/web-socket-connection-list.html'
service_name = 'zato.channel.web-socket.get-connection-list'
output_class = WSXConnection
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id', 'id', 'channel_name')
output_required = ('local_address', 'peer_address', 'peer_fqdn', 'pub_client_id', 'ext_client_id', 'connection_time',
'server_name', 'server_proc_pid', 'peer_forwarded_for', 'peer_forwarded_for_fqdn')
output_optional = 'ext_client_name', 'sub_count'
output_repeated = True
def handle(self):
return {
'conn_id': self.input.id,
'channel_id': self.input.id,
'channel_name': self.input.channel_name
}
def on_before_append_item(self, item):
item.id = item.pub_client_id.replace('.', '-')
item.connection_time_utc = item.connection_time
item.connection_time = from_utc_to_user(item.connection_time_utc + '+00:00', self.req.zato.user_profile)
if item.ext_client_name:
item.ext_client_name = [elem.strip() for elem in item.ext_client_name.split(';')]
item.ext_client_name = '\n'.join(item.ext_client_name)
return item
# ################################################################################################################################
class DisconnectionConnection(_Delete):
url_name = 'channel-web-socket-connection-disconnect'
error_message = 'Could not disconnect WebSocket connection'
service_name = 'zato.channel.web-socket.disconnect-connection'
def get_input_dict(self):
out = super(DisconnectionConnection, self).get_input_dict()
out['pub_client_id'] = self.req.zato.args.pub_client_id.replace('-', '.')
return out
# ################################################################################################################################
class SubKeyDataList(_Index):
method_allowed = 'GET'
url_name = 'channel-web-socket-connection-sub-key-data-list'
template = 'zato/channel/web-socket-connection-sub-key-data-list.html'
service_name = 'zato.channel.web-socket.get-sub-key-data-list'
output_class = WSXSubKeyData
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id', 'pub_client_id', 'channel_name')
input_optional = ('conn_id',)
output_required = ('sub_id', 'sub_key', 'creation_time', 'topic_id', 'topic_name', 'sub_pattern_matched',
'ext_client_id', 'endpoint_id', 'endpoint_name')
output_repeated = True
def on_after_set_input(self):
self.input['pub_client_id'] = self.input['pub_client_id'].replace('-', '.')
def handle(self):
return {
'conn_id': self.input.conn_id,
'pub_client_id': self.input.pub_client_id,
'pub_client_id_html': self.input.pub_client_id.replace('.', '-'),
'channel_name': self.input.channel_name,
}
def on_before_append_item(self, item):
item.id = item.sub_key.replace('.', '_')
item.creation_time_utc = item.creation_time
item.creation_time = from_utc_to_user(item.creation_time_utc + '+00:00', self.req.zato.user_profile)
return item
# ################################################################################################################################
@method_allowed('GET')
def invoke(req, conn_id, pub_client_id, ext_client_id, ext_client_name, channel_id, channel_name):
return_data = {
'conn_id': conn_id,
'pub_client_id': pub_client_id,
'pub_client_id_html': pub_client_id.replace('.', '-'),
'ext_client_id': ext_client_id,
'ext_client_name': ext_client_name,
'channel_id': channel_id,
'channel_name': channel_name,
'cluster_id': req.zato.cluster_id,
}
return TemplateResponse(req, 'zato/channel/web-socket-invoke.html', return_data)
# ################################################################################################################################
@method_allowed('POST')
def invoke_action(req, pub_client_id):
return invoke_action_handler(req, 'zato.channel.web-socket.invoke-wsx', ('id', 'pub_client_id', 'request_data', 'timeout'))
# ################################################################################################################################
| 10,405
|
Python
|
.py
| 196
| 46.392857
| 130
| 0.519551
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,785
|
rest.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/hl7/rest.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# Zato
from zato.admin.web.forms.channel.hl7.rest import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, extract_security_id, Index as _Index
from zato.common.api import CONNECTION, DATA_FORMAT, generic_attrs, HL7, SEC_DEF_TYPE, SEC_DEF_TYPE_NAME, URL_TYPE, ZATO_NONE
from zato.common.model.hl7 import HL7MLLPConfigObject
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'channel-hl7-rest'
template = 'zato/channel/hl7/rest.html'
service_name = 'zato.http-soap.get-list'
output_class = HL7MLLPConfigObject
paginate = True
def get_initial_input(self):
return {
'connection': CONNECTION.CHANNEL,
'transport': URL_TYPE.PLAIN_HTTP,
'data_format': DATA_FORMAT.HL7
}
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
output_required = 'id', 'name', 'is_active', 'is_internal', 'hl7_version', 'url_path', 'service_name', 'security_name', \
'security_id', 'sec_type', 'sec_type_name', 'data_format',
output_optional = ('json_path', 'should_parse_on_input', 'should_validate', 'should_return_errors') + generic_attrs
output_repeated = True
# ################################################################################################################################
def on_before_append_item(self, item):
if item.security_id and item.security_id != ZATO_NONE:
item.sec_type_name = SEC_DEF_TYPE_NAME[item.sec_type]
return item
# ################################################################################################################################
def handle(self):
security_list = self.get_sec_def_list(SEC_DEF_TYPE.BASIC_AUTH)
return {
'create_form': CreateForm(security_list, req=self.req),
'edit_form': EditForm(security_list, prefix='edit', req=self.req),
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_internal', 'hl7_version', 'url_path', 'service', 'security_id', 'data_format'
input_optional = ('is_active', 'json_path', 'should_parse_on_input', 'should_validate', \
'should_return_errors') + generic_attrs
output_required = 'id', 'name'
# ################################################################################################################################
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['connection'] = CONNECTION.CHANNEL
initial_input_dict['transport'] = URL_TYPE.PLAIN_HTTP
initial_input_dict['should_validate'] = True
initial_input_dict['should_parse_on_input'] = True
initial_input_dict['data_format'] = HL7.Const.Version.v2.id
initial_input_dict['data_encoding'] = 'utf-8'
# ################################################################################################################################
def pre_process_input_dict(self, input_dict):
input_dict['security_id'] = extract_security_id(input_dict)
# ################################################################################################################################
def post_process_return_data(self, return_data):
return_data['sec_def_link'] = self.build_sec_def_link_by_input(self.input)
# ################################################################################################################################
def success_message(self, item):
return 'Successfully {} HL7 REST channel `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'channel-hl7-rest-create'
service_name = 'zato.http-soap.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'channel-hl7-rest-edit'
form_prefix = 'edit-'
service_name = 'zato.http-soap.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'channel-hl7-rest-delete'
error_message = 'Could not delete HL7 REST channel'
service_name = 'zato.http-soap.delete'
# ################################################################################################################################
# ################################################################################################################################
| 5,899
|
Python
|
.py
| 89
| 60.696629
| 130
| 0.400138
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,786
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/hl7/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 148
|
Python
|
.py
| 5
| 28.2
| 64
| 0.687943
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,787
|
mllp.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/channel/hl7/mllp.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# Zato
from zato.admin.web.forms.channel.hl7.mllp import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.api import GENERIC, generic_attrs, HL7
from zato.common.model.hl7 import HL7MLLPConfigObject
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'channel-hl7-mllp'
template = 'zato/channel/hl7/mllp.html'
service_name = 'zato.generic.connection.get-list'
output_class = HL7MLLPConfigObject
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id', 'type_'
output_required = 'id', 'name', 'is_active', 'is_internal', 'service', 'security_name', 'address'
output_optional = ('should_parse_on_input', 'should_validate', 'should_return_errors') + generic_attrs
output_repeated = True
# ################################################################################################################################
def handle(self):
return {
'create_form': CreateForm(req=self.req),
'edit_form': EditForm(prefix='edit', req=self.req),
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_internal', 'service', 'address'
input_optional = ('is_active', 'should_parse_on_input', 'should_validate', 'should_return_errors') + generic_attrs
output_required = 'id', 'name'
# ################################################################################################################################
def populate_initial_input_dict(self, initial_input_dict):
initial_input_dict['type_'] = GENERIC.CONNECTION.TYPE.CHANNEL_HL7_MLLP
initial_input_dict['is_internal'] = False
initial_input_dict['is_channel'] = True
initial_input_dict['is_outconn'] = False
initial_input_dict['sec_use_rbac'] = False
initial_input_dict['pool_size'] = 1
initial_input_dict['should_validate'] = True
initial_input_dict['should_parse_on_input'] = True
initial_input_dict['data_format'] = HL7.Const.Version.v2.id
initial_input_dict['hl7_version'] = HL7.Const.Version.v2.id
initial_input_dict['data_encoding'] = 'utf-8'
# ################################################################################################################################
def pre_process_item(self, name, value):
if name == 'recv_timeout':
return int(value)
else:
return value
# ################################################################################################################################
def success_message(self, item):
return 'Successfully {} HL7 MLLP channel `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'channel-hl7-mllp-create'
service_name = 'zato.generic.connection.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'channel-hl7-mllp-edit'
form_prefix = 'edit-'
service_name = 'zato.generic.connection.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'channel-hl7-mllp-delete'
error_message = 'Could not delete HL7 MLLP channel'
service_name = 'zato.generic.connection.delete'
# ################################################################################################################################
# ################################################################################################################################
| 4,996
|
Python
|
.py
| 79
| 57.936709
| 130
| 0.386879
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,788
|
imap.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/email/imap.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2022, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
# Django
from django.http import HttpResponse, HttpResponseServerError
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.email.imap import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, id_only_service, \
Index as _Index, method_allowed
from zato.common.api import EMAIL
from zato.common.odb.model import IMAP
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'email-imap'
template = 'zato/email/imap.html'
service_name = 'zato.email.imap.get-list'
output_class = IMAP
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
output_required = 'id', 'name', 'is_active', 'host', 'port', 'timeout', 'username', 'debug_level', 'mode', \
'get_criteria', 'server_type', 'server_type_human'
output_optional = 'username', 'tenant_id', 'client_id', 'search_criteria', 'filter_criteria'
output_repeated = True
def handle(self):
return {
'default_debug_level': EMAIL.DEFAULT.IMAP_DEBUG_LEVEL,
'default_get_criteria': EMAIL.DEFAULT.GET_CRITERIA,
'default_filter_criteria': EMAIL.DEFAULT.FILTER_CRITERIA,
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
# ################################################################################################################################
# ################################################################################################################################
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'name', 'is_active', 'host', 'port', 'timeout', 'username', 'debug_level', 'mode', 'get_criteria', \
'server_type', 'tenant_id', 'client_id', 'search_criteria', 'filter_criteria'
output_required = 'id', 'name'
def success_message(self, item):
return 'Successfully {} IMAP connection `{}`'.format(self.verb, item.name)
# ################################################################################################################################
# ################################################################################################################################
class Create(_CreateEdit):
url_name = 'email-imap-create'
service_name = 'zato.email.imap.create'
# ################################################################################################################################
# ################################################################################################################################
class Edit(_CreateEdit):
url_name = 'email-imap-edit'
form_prefix = 'edit-'
service_name = 'zato.email.imap.edit'
# ################################################################################################################################
# ################################################################################################################################
class Delete(_Delete):
url_name = 'email-imap-delete'
error_message = 'Could not delete the IMAP connection'
service_name = 'zato.email.imap.delete'
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def ping(req, id, cluster_id):
ret = id_only_service(req, 'zato.email.imap.ping', id, 'IMAP ping error: {}')
if isinstance(ret, HttpResponseServerError):
return ret
return HttpResponse(ret.data.info)
# ################################################################################################################################
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.email.imap.change-password')
# ################################################################################################################################
| 4,981
|
Python
|
.py
| 83
| 55.39759
| 130
| 0.390189
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,789
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/email/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
| 238
|
Python
|
.py
| 6
| 38.166667
| 82
| 0.729258
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,790
|
smtp.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/email/smtp.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Django
from django.http import HttpResponse, HttpResponseServerError
# Zato
from zato.admin.web.forms import ChangePasswordForm
from zato.admin.web.forms.email.smtp import CreateForm, EditForm
from zato.admin.web.views import change_password as _change_password, CreateEdit, Delete as _Delete, id_only_service, \
Index as _Index, method_allowed
from zato.common.api import EMAIL
from zato.common.odb.model import SMTP
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'email-smtp'
template = 'zato/email/smtp.html'
service_name = 'zato.email.smtp.get-list'
output_class = SMTP
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'host', 'port', 'timeout', 'username', 'is_debug', 'mode', 'ping_address')
output_optional = ('username',)
output_repeated = True
def handle(self):
return {
'default_ping_address': EMAIL.DEFAULT.PING_ADDRESS,
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'change_password_form': ChangePasswordForm()
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'host', 'port', 'timeout', 'username', 'is_debug', 'mode', 'ping_address')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {0} the SMTP connection [{1}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'email-smtp-create'
service_name = 'zato.email.smtp.create'
class Edit(_CreateEdit):
url_name = 'email-smtp-edit'
form_prefix = 'edit-'
service_name = 'zato.email.smtp.edit'
class Delete(_Delete):
url_name = 'email-smtp-delete'
error_message = 'Could not delete the SMTP connection'
service_name = 'zato.email.smtp.delete'
@method_allowed('POST')
def ping(req, id, cluster_id):
ret = id_only_service(req, 'zato.email.smtp.ping', id, 'SMTP ping error: {}')
if isinstance(ret, HttpResponseServerError):
return ret
return HttpResponse(ret.data.info)
@method_allowed('POST')
def change_password(req):
return _change_password(req, 'zato.email.smtp.change-password')
| 2,626
|
Python
|
.py
| 64
| 36.234375
| 128
| 0.689072
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,791
|
cassandra.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/query/cassandra.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.query.cassandra import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, get_definition_list, Index as _Index
from zato.common.odb.model import CassandraQuery
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'query-cassandra'
template = 'zato/query/cassandra.html'
service_name = 'zato.query.cassandra.get-list'
output_class = CassandraQuery
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'value', 'def_id')
output_repeated = True
def handle(self):
create_form = CreateForm()
edit_form = EditForm(prefix='edit')
if self.req.zato.cluster_id:
def_ids = get_definition_list(self.req.zato.client, self.req.zato.cluster, 'cassandra')
create_form.set_def_id(def_ids)
edit_form.set_def_id(def_ids)
return {
'create_form': create_form,
'edit_form': edit_form,
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'value', 'def_id')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {} the Cassandra query [{}]'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'query-cassandra-create'
service_name = 'zato.query.cassandra.create'
class Edit(_CreateEdit):
url_name = 'query-cassandra-edit'
form_prefix = 'edit-'
service_name = 'zato.query.cassandra.edit'
class Delete(_Delete):
url_name = 'query-cassandra-delete'
error_message = 'Could not delete the Cassandra query'
service_name = 'zato.query.cassandra.delete'
| 2,133
|
Python
|
.py
| 53
| 34.679245
| 100
| 0.677983
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,792
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/query/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
| 238
|
Python
|
.py
| 6
| 38.166667
| 82
| 0.729258
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,793
|
ide.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/service/ide.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2024, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
# Django
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.views import BaseCallView, invoke_action_handler, method_allowed
# ################################################################################################################################
# ################################################################################################################################
if 0:
from django.http import HttpRequest, HttpResponse
from zato.common.typing_ import any_
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
class IDE(BaseCallView):
method_allowed = 'GET'
url_name = 'service-ide'
template = 'zato/service/ide.html'
service_name = 'zato.service.ide.service-ide'
def get_input_dict(self):
# This will point either to a service or to a full file name
object_type = self.req.zato.args.object_type
if object_type == 'service':
current_service_name = self.req.zato.args.name
fs_location = ''
else:
current_service_name = ''
fs_location = self.req.zato.args.name
return {
'cluster_id': self.cluster_id,
'service_name': current_service_name,
'fs_location': fs_location,
}
# ################################################################################################################################
def build_http_response(self, response:'any_') -> 'TemplateResponse':
return_data = {
'cluster_id': self.req.zato.cluster_id,
'cluster_name': self.req.zato.cluster.name,
'current_object_name': self.req.zato.args.name,
'current_object_name_url_safe': self.req.zato.args.name.replace('~', '/'),
'data': response.data,
}
return TemplateResponse(self.req, self.template, return_data)
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def get_service(req:'HttpRequest', service_name:'str') -> 'HttpResponse':
return invoke_action_handler(req, 'zato.service.ide.get-service', extra={'service_name': service_name})
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def get_file(req:'HttpRequest', fs_location:'str') -> 'HttpResponse':
if not fs_location:
raise Exception(f'FS location missing on input to get_file "{repr(fs_location)}"')
return invoke_action_handler(req, 'zato.service.ide.get-file', extra={'fs_location': fs_location})
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def create_file(req:'HttpRequest') -> 'HttpResponse':
file_name = req.POST['file_name']
root_directory = req.POST['root_directory']
return invoke_action_handler(req, 'zato.service.ide.create-file', extra={
'root_directory': root_directory,
'file_name': file_name,
})
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def rename_file(req:'HttpRequest') -> 'HttpResponse':
root_directory = req.POST['root_directory']
current_file_name = req.POST['current_file_name']
new_file_name = req.POST['new_file_name']
return invoke_action_handler(req, 'zato.service.ide.rename-file', extra={
'root_directory': root_directory,
'current_file_name': current_file_name,
'new_file_name': new_file_name,
})
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def delete_file(req:'HttpRequest') -> 'HttpResponse':
fs_location = req.POST['fs_location']
return invoke_action_handler(req, 'zato.service.ide.delete-file', extra={
'fs_location': fs_location,
})
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def get_file_list(req:'HttpRequest') -> 'HttpResponse':
return invoke_action_handler(req, 'zato.service.ide.get-file-list')
# ################################################################################################################################
# ################################################################################################################################
@method_allowed('POST')
def get_service_list(req:'HttpRequest') -> 'HttpResponse':
fs_location = req.GET['fs_location']
should_wait_for_services = req.GET.get('should_wait_for_services')
should_convert_pickup_to_work_dir = req.GET.get('should_convert_pickup_to_work_dir')
return invoke_action_handler(req, 'zato.service.ide.service-ide', extra={
'fs_location': fs_location,
'should_wait_for_services': should_wait_for_services,
'should_convert_pickup_to_work_dir': should_convert_pickup_to_work_dir,
})
# ################################################################################################################################
# ################################################################################################################################
| 6,923
|
Python
|
.py
| 111
| 57.279279
| 130
| 0.376366
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,794
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/service/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2024, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
from collections import namedtuple
from datetime import datetime
from http import HTTPStatus
from json import dumps, loads
from traceback import format_exc
# dateutil
from dateutil.relativedelta import relativedelta
# Django
from django.http import HttpRequest, HttpResponse
from django.urls import reverse
from django.template.response import TemplateResponse
# Zato
from zato.admin.web import from_utc_to_user
from zato.admin.web.forms.service import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index, method_allowed, upload_to_server
from zato.admin.middleware import HeadersEnrichedException
from zato.common.api import ZATO_NONE
from zato.common.ext.validate_ import is_boolean
from zato.common.odb.model import Service
# ################################################################################################################################
# ################################################################################################################################
if 0:
from zato.common.typing_ import any_, anylist
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
ExposedThrough = namedtuple('ExposedThrough', ['id', 'name', 'url']) # type: ignore
DeploymentInfo = namedtuple('DeploymentInfo', ['server_name', 'details']) # type: ignore
# ################################################################################################################################
def get_public_wsdl_url(cluster:'any_', service_name:'str') -> 'str':
""" Returns an address under which a service's WSDL is publically available.
"""
return 'http://{}:{}/zato/wsdl?service={}&cluster_id={}'.format(cluster.lb_host,
cluster.lb_port, service_name, cluster.id)
# ################################################################################################################################
def _get_channels(client:'any_', cluster:'any_', id:'str', channel_type:'str') -> 'anylist':
""" Returns a list of channels of a given type for the given service.
"""
input_dict = {
'id': id,
'channel_type': channel_type
}
out = []
for item in client.invoke('zato.service.get-channel-list', input_dict):
if channel_type in ['plain_http']:
url = reverse('http-soap')
url += '?connection=channel&transport={}'.format(channel_type)
url += '&cluster={}'.format(cluster.id)
else:
url = reverse('channel-' + channel_type)
url += '?cluster={}'.format(cluster.id)
url += '&highlight={}'.format(item.id)
channel = ExposedThrough(item.id, item.name, url)
out.append(channel)
return out
# ################################################################################################################################
class Index(_Index):
""" A view for listing the services along with their basic statistics.
"""
method_allowed = 'GET'
url_name = 'service'
template = 'zato/service/index.html'
service_name = 'zato.service.get-list'
output_class = Service
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = 'cluster_id',
input_optional = 'query',
output_required = 'id', 'name', 'is_active', 'is_internal', 'impl_name', 'may_be_deleted', 'usage', 'slow_threshold'
output_optional = 'is_json_schema_enabled', 'needs_json_schema_err_details', 'is_rate_limit_active', \
'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def'
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit')
}
# ################################################################################################################################
@method_allowed('POST')
def create(req:'any_') -> 'None':
pass
# ################################################################################################################################
class Edit(CreateEdit):
method_allowed = 'POST'
url_name = 'service-edit'
form_prefix = 'edit-'
service_name = 'zato.service.edit'
class SimpleIO(CreateEdit.SimpleIO):
input_required = 'id', 'is_active', 'slow_threshold', 'is_json_schema_enabled', 'needs_json_schema_err_details', \
'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', 'rate_limit_check_parent_def'
output_required = 'id', 'name', 'impl_name', 'is_internal', 'usage', 'may_be_deleted'
def success_message(self, item:'any_') -> 'str':
return 'Successfully {} service `{}`'.format(self.verb, item.name)
# ################################################################################################################################
@method_allowed('GET')
def overview(req:'HttpRequest', service_name:'str') -> 'TemplateResponse':
cluster_id = req.GET.get('cluster')
service = None
create_form = CreateForm()
edit_form = EditForm(prefix='edit')
if cluster_id and req.method == 'GET':
input_dict = {
'name': service_name,
'cluster_id': req.zato.cluster_id # type: ignore
}
response = req.zato.client.invoke('zato.service.get-by-name', input_dict) # type: ignore
if response.has_data:
service = Service()
for name in('id', 'name', 'is_active', 'impl_name', 'is_internal',
'usage', 'last_duration', 'usage_min', 'usage_max',
'usage_mean', 'last_timestamp'):
value = getattr(response.data, name, None)
if name in('is_active', 'is_internal'):
value = is_boolean(value)
if name == 'last_timestamp':
if value:
service.last_timestamp_utc = value # type: ignore
service.last_timestamp = from_utc_to_user(value+'+00:00', req.zato.user_profile) # type: ignore
continue
setattr(service, name, value)
now = datetime.utcnow()
start = now+relativedelta(minutes=-60)
response = req.zato.client.invoke( # type: ignore
'zato.stats.get-by-service',
{'service_id':service.id, 'start':start, 'stop':now}
)
if response.has_data:
for name in('mean_trend', 'usage_trend', 'min_resp_time', 'max_resp_time', 'mean', 'usage', 'rate'):
value = getattr(response.data, name, ZATO_NONE)
if not value or value == ZATO_NONE:
value = ''
setattr(service, 'time_{}_1h'.format(name), value)
for channel_type in('plain_http', 'amqp', 'jms-wmq', 'zmq'):
channels = _get_channels(req.zato.client, req.zato.cluster, service.id, channel_type) # type: ignore
getattr(service, channel_type.replace('jms-', '') + '_channels').extend(channels)
deployment_service = 'zato.service.get-deployment-info-list'
deployment_request = {'id': service.id, 'needs_details':True}
for item in req.zato.client.invoke(deployment_service, deployment_request): # type: ignore
service.deployment_info.append(DeploymentInfo(item.server_name, item.details))
response = req.zato.client.invoke('zato.scheduler.job.get-list', {'cluster_id':cluster_id}) # type: ignore
if response.has_data:
for item in response.data:
if item.service_name == service_name:
url = reverse('scheduler')
url += '?cluster={}'.format(cluster_id)
url += '&highlight={}'.format(item.id)
service.scheduler_jobs.append(ExposedThrough(item.id, item.name, url))
return_data = {
'zato_clusters':req.zato.clusters, # type: ignore
'service': service,
'cluster_id':cluster_id,
'search_form':req.zato.search_form, # type: ignore
'create_form':create_form,
'edit_form':edit_form,
}
return TemplateResponse(req, 'zato/service/overview.html', return_data)
# ################################################################################################################################
class Delete(_Delete):
url_name = 'service-delete'
error_message = 'Service could not be deleted'
service_name = 'zato.service.delete'
# ################################################################################################################################
@method_allowed('POST')
def upload(req:'HttpRequest') -> 'any_':
""" Uploads one or more files with services.
"""
client = req.zato.client # type: ignore
payload_name = req.GET['qqfile']
has_post = req.GET.get('has_post')
# This is used by the IDE ..
if has_post:
data = req.POST.get('data-editor') or ''
data = data.encode('utf8')
# .. and this is used by file uploads in the listing of services.
else:
data = req.read()
return upload_to_server(client, data, payload_name)
# ################################################################################################################################
@method_allowed('POST')
def invoke(req:'HttpRequest', name:'str', cluster_id:'str') -> 'HttpResponse':
""" Executes a service directly, even if it isn't exposed through any channel.
"""
# Local variables
status_code = HTTPStatus.BAD_REQUEST
content = {
'response_time_human': '',
}
try:
input_dict = {}
input_dict['payload'] = req.POST.get('data-request', '')
input_dict['to_json'] = True
input_dict['needs_response_time'] = True
response = req.zato.client.invoke(name, **input_dict) # type: ignore
except HeadersEnrichedException as enriched_exc:
content['response_time_human'] = enriched_exc.headers.get('X-Zato-Response-Time-Human')
data = enriched_exc.args
except Exception as e:
msg = 'Service could not be invoked; name:`{}`, cluster_id:`{}`, e:`{}`'.format(name, cluster_id, format_exc())
logger.error(msg)
data = e.args
status_code = HTTPStatus.BAD_REQUEST
else:
try:
content['response_time_human'] = response.inner.headers.get('X-Zato-Response-Time-Human')
if response.ok:
if data := response.inner_service_response:
try:
data = loads(data)
except ValueError as e:
print()
print(111, e)
print()
else:
data = '(None)'
status_code = HTTPStatus.OK
else:
data = response.details
except Exception:
data = response.details
content['data'] = data
content = dumps(content)
headers = {'Content-Type': 'application/json'}
out = HttpResponse()
out.status_code = status_code
out.content = content
out.headers = headers # type: ignore
return out
# ################################################################################################################################
| 12,098
|
Python
|
.py
| 237
| 42.527426
| 130
| 0.503097
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,795
|
memcached_.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cache/memcached_.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
import logging
# Zato
from zato.admin.web.forms.cache.memcached import CreateForm, EditForm
from zato.admin.web.views import CreateEdit, Delete as _Delete, Index as _Index
from zato.common.api import CACHE
from zato.common.odb.model import CacheBuiltin
logger = logging.getLogger(__name__)
class Index(_Index):
method_allowed = 'GET'
url_name = 'cache-memcached'
template = 'zato/cache/memcached/index.html'
service_name = 'zato.cache.memcached.get-list'
output_class = CacheBuiltin
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id',)
output_required = ('id', 'name', 'is_active', 'is_default', 'is_debug', 'servers', 'extra', 'cache_type')
output_repeated = True
def handle(self):
return {
'create_form': CreateForm(),
'edit_form': EditForm(prefix='edit'),
'default_max_size': CACHE.DEFAULT.MAX_SIZE,
'default_max_item_size': CACHE.DEFAULT.MAX_ITEM_SIZE,
}
class _CreateEdit(CreateEdit):
method_allowed = 'POST'
class SimpleIO(CreateEdit.SimpleIO):
input_required = ('name', 'is_active', 'is_default', 'is_debug', 'servers', 'extra', 'cache_type')
output_required = ('id', 'name')
def success_message(self, item):
return 'Successfully {} cache `{}`'.format(self.verb, item.name)
class Create(_CreateEdit):
url_name = 'cache-memcached-create'
service_name = 'zato.cache.memcached.create'
class Edit(_CreateEdit):
url_name = 'cache-memcached-edit'
form_prefix = 'edit-'
service_name = 'zato.cache.memcached.edit'
class Delete(_Delete):
url_name = 'cache-memcached-delete'
error_message = 'Cache could not be deleted'
service_name = 'zato.cache.memcached.delete'
class DetailsIndex(_Index):
method_allowed = 'GET'
url_name = 'cache-memcached-details'
| 2,135
|
Python
|
.py
| 53
| 35.283019
| 113
| 0.683446
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,796
|
redis_.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cache/redis_.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,797
|
__init__.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cache/__init__.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
| 154
|
Python
|
.py
| 5
| 29.4
| 64
| 0.687075
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,798
|
entries.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cache/builtin/entries.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2023, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import logging
from base64 import b64decode, b64encode
# Bunch
from bunch import Bunch
# Zato
from zato.admin.web import from_utc_to_user
from zato.admin.web.views import Delete as _Delete, Index as _Index
# ################################################################################################################################
# ################################################################################################################################
if 0:
from zato.common.typing_ import any_, strdict
# ################################################################################################################################
# ################################################################################################################################
logger = logging.getLogger(__name__)
# ################################################################################################################################
# ################################################################################################################################
class CacheEntry:
def __init__(self, cache_id=None, key=None, value=None, last_read=None, prev_read=None, prev_write=None, expiry_op=None,
expires_at=None, hits=None, position=None, server=None):
self.cache_id = cache_id
self.key = key
self._value = value
self.last_read = last_read
self.prev_read = prev_read
self.prev_write = prev_write
self.expiry_op = expiry_op
self.expires_at = expires_at
self.hits = hits
self.position = position
self.server = server
@property
def value(self):
if isinstance(self._value, Bunch):
return self._value.toDict()
else:
return self._value
@value.setter
def value(self, value):
self._value = value
# ################################################################################################################################
class Index(_Index):
method_allowed = 'GET'
url_name = 'cache-builtin-get-entries'
template = 'zato/cache/builtin/entries.html'
service_name = 'zato.cache.builtin.entry.get-list'
output_class = CacheEntry
paginate = True
class SimpleIO(_Index.SimpleIO):
input_required = ('cluster_id', 'cache_id')
output_required = ('cache_id', 'key', 'value', 'position', 'hits', 'expiry_op', 'expiry_left', 'expires_at',
'last_read', 'prev_read', 'last_write', 'prev_write', 'chars_omitted', 'server')
output_repeated = True
def handle(self) -> 'strdict':
return {
'cluster_id': self.cluster_id,
'cache_id': self.input.cache_id,
'show_search_form': True,
'cache_name': self.req.zato.client.invoke('zato.cache.builtin.get', {
'cluster_id': self.cluster_id,
'cache_id': self.input.cache_id
}).data.response.name
}
def on_before_append_item(self, item, _to_user_dt=('expires_at', 'last_read', 'prev_read', 'last_write', 'prev_write')):
if item.key is not None:
item_key:'any_' = item.key
else:
item_key = ''
item.key_escaped = item_key.encode('utf8') if isinstance(item_key, str) else item_key
item.key_escaped = b64encode(item.key_escaped)
item.key_escaped = item.key_escaped.decode('utf8')
chars_omitted = getattr(item, 'chars_omitted', 0)
item.chars_omitted = int(chars_omitted)
for name in _to_user_dt:
value = getattr(item, name)
if value:
setattr(item, name, from_utc_to_user(value, self.req.zato.user_profile))
return item
# ################################################################################################################################
class Delete(_Delete):
url_name = 'cache-builtin-delete-entry'
error_message = 'Could not delete key'
service_name = 'zato.cache.builtin.entry.delete'
def get_input_dict(self, *args, **kwargs):
return {
'cache_id': self.req.POST['cache_id'],
'key': b64decode(self.req.POST['key']),
'cluster_id': self.cluster_id
}
# ################################################################################################################################
| 4,576
|
Python
|
.py
| 95
| 41.031579
| 130
| 0.455097
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|
9,799
|
entry.py
|
zatosource_zato/code/zato-web-admin/src/zato/admin/web/views/cache/builtin/entry.py
|
# -*- coding: utf-8 -*-
"""
Copyright (C) 2019, Zato Source s.r.o. https://zato.io
Licensed under AGPLv3, see LICENSE.txt for terms and conditions.
"""
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
from base64 import b64decode, b64encode
# Bunch
from bunch import Bunch, bunchify
# Django
from django.template.response import TemplateResponse
# Zato
from zato.admin.web.views import invoke_service_with_json_response, method_allowed
from zato.admin.web.forms.cache.builtin.entry import CreateForm, EditForm
from zato.common.api import CACHE
# Python 2/3 compatibility
from zato.common.py23_.past.builtins import unicode
# ################################################################################################################################
def _create_edit(req, action, cache_id, cluster_id, _KV_DATATYPE=CACHE.BUILTIN_KV_DATA_TYPE):
out = {}
if action == 'create':
form = CreateForm()
else:
key = b64decode(req.GET['key'])
key = key.decode('utf8')
entry = bunchify(req.zato.client.invoke('zato.cache.builtin.entry.get', {
'cluster_id': req.zato.cluster_id,
'cache_id': cache_id,
'key': key
}).data.response)
if isinstance(entry.value, Bunch):
entry.value = entry.value.toDict()
form = EditForm({
'key': key,
'old_key': key,
'value': entry.value,
'key_data_type': _KV_DATATYPE.INT.id if entry.is_key_integer else _KV_DATATYPE.STR.id,
'value_data_type': _KV_DATATYPE.INT.id if entry.is_value_integer else _KV_DATATYPE.STR.id,
'expiry': entry.expiry if entry.expiry else 0,
})
out.update({
'zato_clusters': req.zato.clusters,
'cluster_id': req.zato.cluster_id,
'form': form,
'form_action': 'cache-builtin-{}-entry-action'.format(action),
'action': action,
'cache_id': cache_id,
'cache': req.zato.client.invoke('zato.cache.builtin.get', {
'cluster_id': req.zato.cluster_id,
'cache_id': cache_id,
}).data.response
})
return TemplateResponse(req, 'zato/cache/builtin/entry.html', out)
# ################################################################################################################################
@method_allowed('GET')
def create(req, cache_id, cluster_id):
return _create_edit(req, 'create', cache_id, cluster_id)
# ################################################################################################################################
@method_allowed('GET')
def edit(req, cache_id, cluster_id):
return _create_edit(req, 'edit', cache_id, cluster_id)
# ################################################################################################################################
def _create_edit_action_message(action, post, cache_id, cluster_id):
message = {
'cache_id': cache_id,
'cluster_id': cluster_id,
}
# Common request elements
for name in ('key', 'value', 'replace_existing', 'key_data_type', 'value_data_type', 'expiry'):
message[name] = post.get(name)
# Edit will possibly rename the key
if action == 'edit':
message['old_key'] = post['old_key']
return message
# ################################################################################################################################
@method_allowed('POST')
def create_action(req, cache_id, cluster_id):
return invoke_service_with_json_response(
req, 'zato.cache.builtin.entry.create', _create_edit_action_message('create', req.POST, cache_id, cluster_id),
'OK, entry created successfully.', 'Entry could not be created, e:{e}')
# ################################################################################################################################
@method_allowed('POST')
def edit_action(req, cache_id, cluster_id):
key = req.POST['key']
key = key.encode('utf8') if isinstance(key, unicode) else key
key_encoded = b64encode(key).decode('utf8')
new_path = '{}?key={}'.format(req.path.replace('action/', ''), key_encoded)
extra = {'new_path': new_path}
return invoke_service_with_json_response(
req, 'zato.cache.builtin.entry.update', _create_edit_action_message('edit', req.POST, cache_id, cluster_id),
'OK, entry updated successfully.', 'Entry could not be updated, e:{e}', extra=extra)
# ################################################################################################################################
| 4,673
|
Python
|
.py
| 93
| 43.989247
| 130
| 0.519481
|
zatosource/zato
| 1,096
| 239
| 0
|
AGPL-3.0
|
9/5/2024, 5:10:54 PM (Europe/Amsterdam)
|