def user_get(org_id, user_id=None, page=None):
if settings.app.demo_mode and user_id:
resp = utils.demo_get_cache()
if resp:
return utils.jsonify(resp)
org = organization.get_by_id(org_id)
if not org:
return flask.abort(404)
if user_id:
resp = org.get_user(user_id).dict()
if settings.app.demo_mode:
utils.demo_set_cache(resp)
return utils.jsonify(resp)
page = flask.request.args.get('page', page)
page = int(page) if page else page
search = flask.request.args.get('search', None)
limit = int(flask.request.args.get('limit', settings.user.page_count))
otp_auth = False
dns_mapping = False
server_count = 0
servers = []
if settings.app.demo_mode:
resp = utils.demo_get_cache(page, search, limit)
if resp:
return utils.jsonify(resp)
for svr in org.iter_servers(fields=('name', 'otp_auth', 'dns_mapping',
'groups')):
servers.append(svr)
server_count += 1
if svr.otp_auth:
otp_auth = True
if svr.dns_mapping:
dns_mapping = True
users = []
users_id = []
users_data = {}
users_servers = {}
fields = (
'organization',
'organization_name',
'name',
'email',
'groups',
'pin',
'type',
'auth_type',
'otp_secret',
'disabled',
'bypass_secondary',
'client_to_client',
'dns_servers',
'dns_suffix',
'port_forwarding',
)
for usr in org.iter_users(page=page,
search=search,
search_limit=limit,
fields=fields):
users_id.append(usr.id)
user_dict = usr.dict()
user_dict['gravatar'] = settings.user.gravatar
user_dict['audit'] = settings.app.auditing == ALL
user_dict['status'] = False
user_dict['sso'] = settings.app.sso
user_dict['otp_auth'] = otp_auth
if dns_mapping:
user_dict['dns_mapping'] = (
'%s.%s.vpn' % (usr.name.split('@')[0], org.name)).lower()
else:
user_dict['dns_mapping'] = None
user_dict['network_links'] = []
users_data[usr.id] = user_dict
users_servers[usr.id] = {}
server_data = []
for svr in servers:
if not svr.check_groups(usr.groups):
continue
data = {
'id': svr.id,
'name': svr.name,
'status': False,
'server_id': svr.id,
'device_name': None,
'platform': None,
'real_address': None,
'virt_address': None,
'virt_address6': None,
'connected_since': None
}
server_data.append(data)
users_servers[usr.id][svr.id] = data
user_dict['servers'] = sorted(server_data, key=lambda x: x['name'])
users.append(user_dict)
clients_collection = mongo.get_collection('clients')
for doc in clients_collection.find({
'user_id': {
'$in': users_id
},
}):
server_data = users_servers[doc['user_id']].get(doc['server_id'])
if not server_data:
continue
users_data[doc['user_id']]['status'] = True
if server_data['status']:
server_data = {
'name': server_data['name'],
}
append = True
else:
append = False
virt_address6 = doc.get('virt_address6')
if virt_address6:
server_data['virt_address6'] = virt_address6.split('/')[0]
server_data['id'] = doc['_id']
server_data['status'] = True
server_data['server_id'] = server_data['id']
server_data['device_name'] = doc['device_name']
server_data['platform'] = doc['platform']
server_data['real_address'] = doc['real_address']
server_data['virt_address'] = doc['virt_address'].split('/')[0]
server_data['connected_since'] = doc['connected_since']
if append:
svrs = users_data[doc['user_id']]['servers']
svrs.append(server_data)
users_data[doc['user_id']]['servers'] = sorted(
svrs, key=lambda x: x['name'])
net_link_collection = mongo.get_collection('users_net_link')
for doc in net_link_collection.find({
'user_id': {
'$in': users_id
},
}):
users_data[doc['user_id']]['network_links'].append(doc['network'])
ip_addrs_iter = server.multi_get_ip_addr(org_id, users_id)
for user_id, server_id, addr, addr6 in ip_addrs_iter:
server_data = users_servers[user_id].get(server_id)
if server_data:
if not server_data['virt_address']:
server_data['virt_address'] = addr
if not server_data['virt_address6']:
server_data['virt_address6'] = addr6
if page is not None:
resp = {
'page': page,
'page_total': org.page_total,
'server_count': server_count,
'users': users,
}
elif search is not None:
resp = {
'search': search,
'search_more': limit < org.last_search_count,
'search_limit': limit,
'search_count': org.last_search_count,
'search_time': round((time.time() - flask.g.start), 4),
'server_count': server_count,
'users': users,
}
else:
resp = users
if settings.app.demo_mode and not search:
utils.demo_set_cache(resp, page, search, limit)
return utils.jsonify(resp)
def user_get(org_id, user_id=None, page=None):
org = organization.get_by_id(org_id)
if user_id:
return utils.jsonify(org.get_user(user_id).dict())
page = flask.request.args.get('page', None)
page = int(page) if page else page
search = flask.request.args.get('search', None)
limit = int(flask.request.args.get('limit', settings.user.page_count))
otp_auth = False
server_count = 0
servers = []
for svr in org.iter_servers(fields=('name', 'otp_auth')):
servers.append(svr)
server_count += 1
if svr.otp_auth:
otp_auth = True
users = []
users_id = []
users_data = {}
users_servers = {}
fields = (
'organization',
'organization_name',
'name',
'email',
'type',
'otp_secret',
'disabled',
)
for usr in org.iter_users(page=page, search=search,
search_limit=limit, fields=fields):
users_id.append(usr.id)
user_dict = usr.dict()
user_dict['status'] = False
user_dict['otp_auth'] = otp_auth
user_dict['network_links'] = []
users_data[usr.id] = user_dict
users_servers[usr.id] = {}
server_data = []
for svr in servers:
data = {
'id': svr.id,
'name': svr.name,
'status': False,
'server_id': svr.id,
'device_name': None,
'platform': None,
'real_address': None,
'virt_address': None,
'virt_address6': None,
'connected_since': None
}
server_data.append(data)
users_servers[usr.id][svr.id] = data
user_dict['servers'] = sorted(server_data, key=lambda x: x['name'])
users.append(user_dict)
clients_collection = mongo.get_collection('clients')
for doc in clients_collection.find({
'user_id': {'$in': users_id},
}):
server_data = users_servers[doc['user_id']].get(doc['server_id'])
if not server_data:
continue
users_data[doc['user_id']]['status'] = True
if server_data['status']:
server_data = {
'name': server_data['name'],
}
append = True
else:
append = False
virt_address6 = doc.get('virt_address6')
if virt_address6:
server_data['virt_address6'] = virt_address6.split('/')[0]
server_data['id'] = doc['_id']
server_data['status'] = True
server_data['server_id'] = server_data['id']
server_data['device_name'] = doc['device_name']
server_data['platform'] = doc['platform']
server_data['real_address'] = doc['real_address']
server_data['virt_address'] = doc['virt_address'].split('/')[0]
server_data['connected_since'] = doc['connected_since']
if append:
svrs = users_data[doc['user_id']]['servers']
svrs.append(server_data)
users_data[doc['user_id']]['servers'] = sorted(
svrs, key=lambda x: x['name'])
net_link_collection = mongo.get_collection('users_net_link')
for doc in net_link_collection.find({
'user_id': {'$in': users_id},
}):
users_data[doc['user_id']]['network_links'].append(doc['network'])
ip_addrs_iter = server.multi_get_ip_addr(org_id, users_id)
for user_id, server_id, addr, addr6 in ip_addrs_iter:
server_data = users_servers[user_id].get(server_id)
if server_data:
if not server_data['virt_address']:
server_data['virt_address'] = addr
if not server_data['virt_address6']:
server_data['virt_address6'] = addr6
if page is not None:
return utils.jsonify({
'page': page,
'page_total': org.page_total,
'server_count': server_count,
'users': users,
})
elif search is not None:
return utils.jsonify({
'search': search,
'search_more': limit < org.last_search_count,
'search_limit': limit,
'search_count': org.last_search_count,
'search_time': round((time.time() - flask.g.start), 4),
'server_count': server_count,
'users': users,
})
else:
return utils.jsonify(users)
def user_get(org_id, user_id=None, page=None):
org = organization.get_org(id=org_id)
if user_id:
return utils.jsonify(org.get_user(user_id).dict())
page = flask.request.args.get('page', None)
page = int(page) if page else page
search = flask.request.args.get('search', None)
limit = int(flask.request.args.get('limit', settings.user.page_count))
otp_auth = False
search_more = True
server_count = 0
clients = {}
servers = []
fields = (
'name',
'clients',
'otp_auth',
)
for svr in org.iter_servers(fields=fields):
servers.append(svr)
server_count += 1
if svr.otp_auth:
otp_auth = True
server_clients = svr.clients
for client, client_id in server_clients.iteritems():
if client_id not in clients:
clients[client_id] = {}
clients[client_id][svr.id] = client
users = []
users_id = []
users_server_data = collections.defaultdict(dict)
fields = (
'organization',
'organization_name',
'name',
'email',
'type',
'otp_secret',
'disabled',
)
for user in org.iter_users(page=page, search=search,
search_limit=limit, fields=fields):
user_id = user.id
users_id.append(user_id)
is_client = user_id in clients
user_dict = user.dict()
user_dict['status'] = is_client
user_dict['otp_auth'] = otp_auth
server_data = []
for svr in servers:
server_id = svr.id
user_status = is_client and server_id in clients[user_id]
data = {
'id': server_id,
'name': svr.name,
'status': user_status,
'local_address': None,
'remote_address': None,
'real_address': None,
'virt_address': None,
'bytes_received': None,
'bytes_sent': None,
'connected_since': None,
}
users_server_data[user_id][server_id] = data
if user_status:
data.update(clients[user_id][server_id])
server_data.append(data)
user_dict['servers'] = server_data
users.append(user_dict)
ip_addrs_iter = server.multi_get_ip_addr(org_id, users_id)
for user_id, server_id, local_addr, remote_addr in ip_addrs_iter:
user_server_data = users_server_data[user_id].get(server_id)
if user_server_data:
if not user_server_data['local_address']:
user_server_data['local_address'] = local_addr
if not user_server_data['remote_address']:
user_server_data['remote_address'] = remote_addr
if page is not None:
return utils.jsonify({
'page': page,
'page_total': org.page_total,
'server_count': server_count,
'users': users,
})
elif search is not None:
return utils.jsonify({
'search': search,
'search_more': limit < org.last_search_count,
'search_limit': limit,
'search_count': org.last_search_count,
'search_time': round((time.time() - flask.g.start), 4),
'server_count': server_count,
'users': users,
})
else:
return utils.jsonify(users)
def user_get(org_id, user_id=None, page=None):
org = organization.get_by_id(org_id)
if user_id:
return utils.jsonify(org.get_user(user_id).dict())
page = flask.request.args.get('page', None)
page = int(page) if page else page
search = flask.request.args.get('search', None)
limit = int(flask.request.args.get('limit', settings.user.page_count))
otp_auth = False
search_more = True
server_count = 0
clients = collections.defaultdict(lambda: collections.defaultdict(list))
servers = []
fields = (
'name',
'instances',
'otp_auth',
)
for svr in org.iter_servers(fields=fields):
servers.append(svr)
server_count += 1
if svr.otp_auth:
otp_auth = True
for instance in svr.instances:
for client in instance['clients']:
clients[client['id']][svr.id].append(client)
users = []
users_server_data = collections.defaultdict(dict)
fields = (
'organization',
'organization_name',
'name',
'email',
'type',
'otp_secret',
'disabled',
)
for user in org.iter_users(page=page,
search=search,
search_limit=limit,
fields=fields):
user_id = user.id
is_client = user_id in clients
user_dict = user.dict()
user_dict['status'] = is_client
user_dict['otp_auth'] = otp_auth
server_data = []
for svr in servers:
server_id = svr.id
if clients[user_id][server_id]:
for device in clients[user_id][server_id]:
device['id'] = device.pop('device_id', server_id)
device['name'] = svr.name
device['status'] = True
device['virt_address'] = device['virt_address'].split(
'/')[0]
server_data.append(device)
else:
data = {
'id': server_id,
'name': svr.name,
'status': False,
'type': None,
'client_id': None,
'device_name': None,
'platform': None,
'real_address': None,
'virt_address': None,
'connected_since': None
}
server_data.append(data)
users_server_data[user_id][server_id] = data
user_dict['servers'] = sorted(server_data, key=lambda x: x['name'])
users.append(user_dict)
ip_addrs_iter = server.multi_get_ip_addr(org_id, users_server_data.keys())
for user_id, server_id, ip_add in ip_addrs_iter:
user_server_data = users_server_data[user_id].get(server_id)
if user_server_data:
if not user_server_data['virt_address']:
user_server_data['virt_address'] = ip_add
if page is not None:
return utils.jsonify({
'page': page,
'page_total': org.page_total,
'server_count': server_count,
'users': users,
})
elif search is not None:
return utils.jsonify({
'search':
search,
'search_more':
limit < org.last_search_count,
'search_limit':
limit,
'search_count':
org.last_search_count,
'search_time':
round((time.time() - flask.g.start), 4),
'server_count':
server_count,
'users':
users,
})
else:
return utils.jsonify(users)
def user_get(org_id, user_id=None, page=None):
org = organization.get_by_id(org_id)
if user_id:
return utils.jsonify(org.get_user(user_id).dict())
page = flask.request.args.get('page', None)
page = int(page) if page else page
search = flask.request.args.get('search', None)
limit = int(flask.request.args.get('limit', settings.user.page_count))
otp_auth = False
server_count = 0
clients = collections.defaultdict(lambda: collections.defaultdict(list))
servers = []
fields = (
'name',
'instances',
'otp_auth',
)
for svr in org.iter_servers(fields=fields):
servers.append(svr)
server_count += 1
if svr.otp_auth:
otp_auth = True
for instance in svr.instances:
for client in instance['clients']:
clients[client['id']][svr.id].append(client)
users = []
users_server_data = collections.defaultdict(dict)
fields = (
'organization',
'organization_name',
'name',
'email',
'type',
'otp_secret',
'disabled',
)
for user in org.iter_users(page=page, search=search,
search_limit=limit, fields=fields):
user_id = user.id
is_client = user_id in clients
user_dict = user.dict()
user_dict['status'] = is_client
user_dict['otp_auth'] = otp_auth
server_data = []
for svr in servers:
server_id = svr.id
if clients[user_id][server_id]:
for device in clients[user_id][server_id]:
device['id'] = device.pop('device_id', server_id)
device['name'] = svr.name
device['status'] = True
device['virt_address'] = device['virt_address'].split(
'/')[0]
server_data.append(device)
else:
data = {
'id': server_id,
'name': svr.name,
'status': False,
'type': None,
'client_id': None,
'device_name': None,
'platform': None,
'real_address': None,
'virt_address': None,
'connected_since': None
}
server_data.append(data)
users_server_data[user_id][server_id] = data
user_dict['servers'] = sorted(server_data, key=lambda x: x['name'])
users.append(user_dict)
ip_addrs_iter = server.multi_get_ip_addr(org_id, users_server_data.keys())
for user_id, server_id, ip_add in ip_addrs_iter:
user_server_data = users_server_data[user_id].get(server_id)
if user_server_data:
if not user_server_data['virt_address']:
user_server_data['virt_address'] = ip_add
if page is not None:
return utils.jsonify({
'page': page,
'page_total': org.page_total,
'server_count': server_count,
'users': users,
})
elif search is not None:
return utils.jsonify({
'search': search,
'search_more': limit < org.last_search_count,
'search_limit': limit,
'search_count': org.last_search_count,
'search_time': round((time.time() - flask.g.start), 4),
'server_count': server_count,
'users': users,
})
else:
return utils.jsonify(users)
def user_get(org_id, user_id=None, page=None):
if settings.app.demo_mode and user_id:
resp = utils.demo_get_cache()
if resp:
return utils.jsonify(resp)
org = organization.get_by_id(org_id)
if not org:
return flask.abort(404)
if user_id:
resp = org.get_user(user_id).dict()
if settings.app.demo_mode:
utils.demo_set_cache(resp)
return utils.jsonify(resp)
page = flask.request.args.get('page', page)
page = int(page) if page else page
search = flask.request.args.get('search', None)
limit = int(flask.request.args.get('limit', settings.user.page_count))
otp_auth = False
dns_mapping = False
server_count = 0
servers = []
if settings.app.demo_mode:
resp = utils.demo_get_cache(page, search, limit)
if resp:
return utils.jsonify(resp)
for svr in org.iter_servers(fields=('name', 'otp_auth', 'dns_mapping')):
servers.append(svr)
server_count += 1
if svr.otp_auth:
otp_auth = True
if svr.dns_mapping:
dns_mapping = True
users = []
users_id = []
users_data = {}
users_servers = {}
fields = (
'organization',
'organization_name',
'name',
'email',
'pin',
'type',
'auth_type',
'otp_secret',
'disabled',
'bypass_secondary',
'client_to_client',
'dns_servers',
'dns_suffix',
'port_forwarding',
)
for usr in org.iter_users(page=page, search=search,
search_limit=limit, fields=fields):
users_id.append(usr.id)
user_dict = usr.dict()
user_dict['gravatar'] = settings.user.gravatar
user_dict['audit'] = settings.app.auditing == ALL
user_dict['status'] = False
user_dict['sso'] = settings.app.sso
user_dict['otp_auth'] = otp_auth
if dns_mapping:
user_dict['dns_mapping'] = ('%s.%s.vpn' % (
usr.name.split('@')[0], org.name)).lower()
else:
user_dict['dns_mapping'] = None
user_dict['network_links'] = []
users_data[usr.id] = user_dict
users_servers[usr.id] = {}
server_data = []
for svr in servers:
data = {
'id': svr.id,
'name': svr.name,
'status': False,
'server_id': svr.id,
'device_name': None,
'platform': None,
'real_address': None,
'virt_address': None,
'virt_address6': None,
'connected_since': None
}
server_data.append(data)
users_servers[usr.id][svr.id] = data
user_dict['servers'] = sorted(server_data, key=lambda x: x['name'])
users.append(user_dict)
clients_collection = mongo.get_collection('clients')
for doc in clients_collection.find({
'user_id': {'$in': users_id},
}):
server_data = users_servers[doc['user_id']].get(doc['server_id'])
if not server_data:
continue
users_data[doc['user_id']]['status'] = True
if server_data['status']:
server_data = {
'name': server_data['name'],
}
append = True
else:
append = False
virt_address6 = doc.get('virt_address6')
if virt_address6:
server_data['virt_address6'] = virt_address6.split('/')[0]
server_data['id'] = doc['_id']
server_data['status'] = True
server_data['server_id'] = server_data['id']
server_data['device_name'] = doc['device_name']
server_data['platform'] = doc['platform']
server_data['real_address'] = doc['real_address']
server_data['virt_address'] = doc['virt_address'].split('/')[0]
server_data['connected_since'] = doc['connected_since']
if append:
svrs = users_data[doc['user_id']]['servers']
svrs.append(server_data)
users_data[doc['user_id']]['servers'] = sorted(
svrs, key=lambda x: x['name'])
net_link_collection = mongo.get_collection('users_net_link')
for doc in net_link_collection.find({
'user_id': {'$in': users_id},
}):
users_data[doc['user_id']]['network_links'].append(doc['network'])
ip_addrs_iter = server.multi_get_ip_addr(org_id, users_id)
for user_id, server_id, addr, addr6 in ip_addrs_iter:
server_data = users_servers[user_id].get(server_id)
if server_data:
if not server_data['virt_address']:
server_data['virt_address'] = addr
if not server_data['virt_address6']:
server_data['virt_address6'] = addr6
if page is not None:
resp = {
'page': page,
'page_total': org.page_total,
'server_count': server_count,
'users': users,
}
elif search is not None:
resp = {
'search': search,
'search_more': limit < org.last_search_count,
'search_limit': limit,
'search_count': org.last_search_count,
'search_time': round((time.time() - flask.g.start), 4),
'server_count': server_count,
'users': users,
}
else:
resp = users
if settings.app.demo_mode and not search:
utils.demo_set_cache(resp, page, search, limit)
return utils.jsonify(resp)