def get_data(schedule_type):
if schedule_type == 1:
return request.form.get('data_date_utc', '')
elif schedule_type == 2:
return strings.to_json({
'weeks':
request.form.get('interval_weeks', None),
'days':
request.form.get('interval_days', None),
'hours':
request.form.get('interval_hours', None),
'minutes':
request.form.get('interval_minutes', None),
'seconds':
request.form.get('interval_seconds', None)
})
elif schedule_type == 3:
return strings.to_json({
'second':
request.form.get('cron_second', None),
'minute':
request.form.get('cron_minute', None),
'hour':
request.form.get('cron_hour', None),
'day':
request.form.get('cron_day', None),
'month':
request.form.get('cron_month', None),
'day_of_week':
request.form.get('cron_day_of_week', None),
'year':
request.form.get('cron_year', None),
})
else:
return None
def fetch(self, raw=False):
if raw:
sql_arr = [self._sql]
else:
sql_arr = ["select _page.* from (", self._sql, ") _page"]
if strings.is_not_blank(self._order_by_clause):
sql_arr.append("order by")
sql_arr.append(self._order_by_clause)
if self._fetch_rows >= 0:
sql_arr.append("limit " + str(self._start) + "," +
str(self._fetch_rows))
try:
self._context.begin()
cursor = self._build_cursor_sql(" ".join(sql_arr))
fetchall = cursor.fetchall()
logger.debug(" ".join(sql_arr), DAO_LOGGER)
logger.debug(strings.to_json(self._params), DAO_LOGGER)
self._context.commit()
return list(
map(lambda o: dict(zip([k.lower() for k in cursor.keys()], o)),
fetchall))
except Exception as e:
self._context.rollback()
raise e
def get():
uid = request.form.get("id")
if strings.is_not_blank(uid):
func = get_function(uid)
if func is not None:
return strings.to_json(func)
return "failed"
def get():
uid = request.form.get("id")
if strings.is_not_blank(uid):
menu = get_menu(uid)
if menu is not None:
return strings.to_json(menu)
return "failed"
def groups_save():
dn = request.form.get('dn')
ret = {'success': False, 'error_msg': None}
try:
if strings.is_blank(dn):
response = models.add_group(
cn=request.form.get('cn'),
gid_number=request.form.get('gid'),
)
else:
response = models.modify_group(
cn=request.form.get('cn'),
gid_number=request.form.get('gid'),
)
if not response:
ret['error_msg'] = '添加失败，请查询 slapd.server 日志'
else:
ret['success'] = True
except LDAPBindError:
ret['error_msg'] = '授权错误'
return ret
except Exception as e:
logger.error_traceback(LOGGER_NAME)
ret['error_msg'] = str(e)
return strings.to_json(ret, True)
def wrapper(*args, **kwargs):
from raphael.utils.dao.query import DaoQuery
from collections import Iterable, Sized
g.params = json.loads(request.form.get("params"))
get_result = f(*args, **kwargs)
if isinstance(get_result, DaoQuery):
page_index = int(request.form.get("page_index"))
page_size = int(request.form.get("page_size"))
order_by = request.form.get("order_by")
if strings.is_not_blank(order_by):
get_result.order_by(order_by)
if page_size > 0:
res = get_result.pagination((page_index - 1) * page_size,
page_size).fetch()
else:
res = get_result.fetch()
# call batch
if hasattr(g, 'table_batch'):
res = g.table_batch(res)
result = {"res": res, "count": get_result.count()}
elif isinstance(get_result, (Iterable, Sized)):
result = {"res": list(get_result), "count": len(get_result)}
else:
raise ValueError("get_result is not in reason.")
return strings.to_json(result)
def profile():
user = webutils.curr_user()
if not user or user.get('loginid') == 'guest':
return {'msg': "failed", 'user': '******'}
user = copy.deepcopy(user)
user.pop('password', None)
user.pop('salt', None)
return render_template('um/profile.html', **{'msg': 'success', 'user': strings.to_json(user, True)})
def get():
uid = request.form.get("id")
if strings.is_not_blank(uid):
user = um.get_user_byid(uid)
if user is not None:
user.pop('password', None)
user.pop('salt', None)
return strings.to_json(user)
return "failed"
def users_reset_passwrod(cn):
ret = {'success': False, 'new_password': None}
try:
new_password = strings.random_str(12)
models.reset_password(cn, new_password)
ret['success'] = True
ret['new_password'] = new_password
except:
logger.error_traceback(LOGGER_NAME)
return strings.to_json(ret, True)
def execute(self, sql, **params):
from sqlalchemy import text
try:
self.begin()
self.session.connection().execute(text(sql), **params)
logger.debug(str(sql), DAO_LOGGER)
logger.debug(strings.to_json(params), DAO_LOGGER)
self.commit()
except Exception as e:
self.rollback()
raise e
def first(self):
try:
self._context.begin()
cursor = self._build_cursor()
first = cursor.first()
logger.debug('FIRST ' + str(self._sql), DAO_LOGGER)
logger.debug(strings.to_json(self._params), DAO_LOGGER)
keys = cursor.keys()
self._context.commit()
return None if first is None else dict(
zip([o.lower() for o in keys], first))
except Exception as e:
self._context.rollback()
raise e
def count(self):
try:
self._context.begin()
count = 0
sql_arr = ["select count(*) from (", self._sql, ") _count"]
result = self._build_cursor_sql("".join(sql_arr)).fetchall()
logger.debug(''.join(sql_arr), DAO_LOGGER)
logger.debug(strings.to_json(self._params), DAO_LOGGER)
if len(result) > 0:
count = result[0][0]
self._context.commit()
return count
except Exception as e:
self._context.rollback()
raise e
def setting_save():
result = {
'success': False,
'message': None,
'newsettings': None,
}
attr_map = {
'openldap.shadow.min': 'shadow_min',
'openldap.shadow.max': 'shadow_max',
'openldap.shadow.inactive': 'shadow_inactive',
'openldap.shadow.warning': 'shadow_warning',
}
other_attrs = {}
for s in json.loads(request.form.get('settings')):
setting_models.CmSettingCache.save_obj({
'id': s['id'],
'name': s['name'],
'value': s['value'],
})
if s['name'].find('openldap.shadow.') >= 0:
other_attrs[attr_map[s['name']]] = s['value']
# change user shadow attributes
if len(other_attrs) > 0:
try:
for user_cn in models.list_users():
models.modify_user(user_cn, **other_attrs)
except:
result['success'] = False
result['message'] = '更改用户属性时错误'
return strings.to_json(result, True)
result['success'] = True
result['newsettings'] = setting_models.find_settings(
namelikeleft='openldap.').fetch()
return strings.to_json(result, True)
def users_save():
dn = request.form.get('dn')
ret = {'success': False, 'error_msg': None, 'new_password': None}
try:
if strings.is_blank(dn):
response = models.add_user(
cn=request.form.get('cn'),
sn=request.form.get('sn'),
uid_number=request.form.get('uid'),
gid_number=request.form.get('gid'),
gecos=request.form.get('gecos'),
mail=request.form.get('mail'),
display_name=request.form.get('displayName'),
)
if not response:
ret['error_msg'] = '添加失败，请查询 slapd.server 日志'
else:
# new password
new_password = strings.random_str(12)
models.reset_password(request.form.get('cn'), new_password)
ret['success'] = True
ret['new_password'] = new_password
else:
response = models.modify_user(
cn=request.form.get('cn'),
sn=request.form.get('sn'),
uid_number=request.form.get('uid'),
gid_number=request.form.get('gid'),
gecos=request.form.get('gecos'),
mail=request.form.get('mail'),
display_name=request.form.get('displayName'),
)
if not response:
ret['error_msg'] = '添加失败，请查询 slapd.server 日志'
else:
ret['success'] = True
except LDAPBindError:
ret['error_msg'] = '授权错误'
return ret
except Exception as e:
logger.error_traceback(LOGGER_NAME)
ret['error_msg'] = str(e)
return strings.to_json(ret, True)
def hosts_import():
ret = {
'success_count': 0,
'fail_count': 0,
'error_items': [],
}
hosts_text = request.form.get('hosts')
for host_item in hosts_text.split('\n'):
if strings.is_blank(host_item):
continue
parts = host_item.split()
if len(parts) <= 1:
ret['error_items'].append(host_item)
ret['fail_count'] += 1
continue
response = models.add_host(parts[1], parts[2:], parts[0])
if response:
ret['success_count'] += 1
else:
ret['error_items'].append(host_item)
ret['fail_count'] += 1
return strings.to_json(ret, True)
def services_get(cn):
return strings.to_json(models.get_service(cn), True)
def command_groups_get(cn):
return strings.to_json(models.get_command_group(cn), True)
def host_groups_get(cn):
return strings.to_json(models.get_host_group(cn), True)
def get():
schedule = models.get_schedule(request.form.get('id', None))
return strings.to_json(schedule) if schedule else 'failed'
def get(oid):
o = get_setting(oid)
return strings.to_json(o)
