def search_list(request):
try:
lists = dict()
lists['delete_form'] = DeleteForm()
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
# Get all environments from NetworkAPI
env_list = client.create_ambiente().list_all()
# Get all equipment types from NetworkAPI
type_equip_list = client.create_tipo_equipamento().listar()
# Get all groups from NetworkAPI
group_list = client.create_grupo_equipamento().listar()
search_form = SearchEquipmentForm(
env_list, type_equip_list, group_list)
lists['search_form'] = search_form
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def ajax_view_real_shared(request, id_equip, lists):
try:
lists['equip_id'] = id_equip
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
# Get reals related
vips_reals = client.create_equipamento().get_real_related(id_equip)
lists['vips'] = [vips_reals.get('vips'), ] if type(
vips_reals.get('vips')) is dict else vips_reals.get('vips')
lists['equip_name'] = vips_reals.get('equip_name')
# Returns HTML
response = HttpResponse(loader.render_to_string(
EQUIPMENT_VIEW_AJAX, lists, context_instance=RequestContext(request)))
response.status_code = 200
return response
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def ajax_modelo_equip(request, id_marca):
try:
lists = dict()
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
marca = int(id_marca)
if marca > 0:
modelos = client.create_modelo().listar_por_marca(marca)
lists['modelos'] = modelos.get('model')
# Returns HTML
response = HttpResponse(loader.render_to_string(
EQUIPMENT_MODELO, lists, context_instance=RequestContext(request)))
# Send response status with error
response.status_code = 200
return response
else:
# Returns HTML
response = HttpResponse(loader.render_to_string(
EQUIPMENT_MODELO, lists, context_instance=RequestContext(request)))
# Send response status with error
response.status_code = 200
return response
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def healthcheck_expect_form(request):
lists = dict()
try:
auth = AuthSession(request.session)
client = auth.get_clientFactory()
ambientes = client.create_ambiente().list_all()
if request.method == 'POST':
form = HealthckeckExpectForm(ambientes, request.POST)
lists['form'] = form
if form.is_valid():
match_list = form.cleaned_data['match_list']
expect_string = form.cleaned_data['expect_string']
environment_id = form.cleaned_data['environment']
client.create_ambiente().add_healthcheck_expect(
environment_id, expect_string, match_list)
messages.add_message(
request, messages.SUCCESS, healthcheck_messages.get('success_create'))
lists['form'] = HealthckeckExpectForm(ambientes)
# GET METHOD
else:
lists['form'] = HealthckeckExpectForm(ambientes)
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def ajax_acl_name_suggest(request):
lists = dict()
try:
nome = request.GET['nome']
id_ambiente = request.GET['id_ambiente']
auth = AuthSession(request.session)
client = auth.get_clientFactory()
environment = client.create_ambiente().buscar_por_id(
id_ambiente).get('ambiente')
suggest_name = str(
nome + environment['nome_ambiente_logico']).replace(" ", "")
lists['suggest_name'] = suggest_name
# Returns HTML
response = HttpResponse(loader.render_to_string(
AJAX_SUGGEST_NAME, lists, context_instance=RequestContext(request)))
# Send response status with error
response.status_code = 200
return response
except:
lists['suggest_name'] = ''
# Returns HTML
response = HttpResponse(loader.render_to_string(
AJAX_SUGGEST_NAME, lists, context_instance=RequestContext(request)))
# Send response status with error
response.status_code = 200
return response
def show_form(request):
try:
if request.method == "POST":
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
# Um form com os dados de POST
form = ScriptTypeForm(request.POST)
if form.is_valid():
tipo = form.cleaned_data['script_type']
descricao = form.cleaned_data['description']
try:
client.create_tipo_roteiro().inserir(
tipo, descricao)
messages.add_message(
request, messages.SUCCESS, script_type_messages.get("success_insert"))
return redirect('script.type.list')
except NomeTipoRoteiroDuplicadoError, e:
messages.add_message(
request, messages.ERROR, script_type_messages.get("error_equal_name") % tipo)
else:
def search_list_param(request, id_equip):
lists = dict()
try:
auth = AuthSession(request.session)
client = auth.get_clientFactory()
equip = client.create_equipamento().listar_por_id(id_equip)
name_equip = equip.get('equipamento').get('nome')
# recuperando lista de equipamentos de acesso
equip_access_list = client.create_equipamento_acesso().list_by_equip(
name_equip)
access_type = client.create_tipo_acesso().listar()
lists['form'] = SearchEquipForm(initial={"equip_name": name_equip})
lists['delete_form'] = DeleteForm(
initial={"equip_name": name_equip, "equip_id": id_equip})
equip_access_list = replace_id_to_name(equip_access_list[
"equipamento_acesso"], access_type["tipo_acesso"], "tipo_acesso", "id", "protocolo")
lists['equip_access_list'] = equip_access_list
return render_to_response(EQUIPMENTACESS_SEARCH_LIST, lists, context_instance=RequestContext(request))
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def add_form(request):
try:
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
# Enviar listas para formar os Selects do formulário
forms_aux = dict()
# Get all script_types from NetworkAPI
forms_aux['tipo_roteiro'] = client.create_tipo_roteiro().listar()
forms_aux['modelos'] = client.create_modelo().listar().get('model')
# If form was submited
if request.method == 'POST':
form = ScriptForm(forms_aux, request.POST)
if form.is_valid():
name = form.cleaned_data['name']
script_type = form.cleaned_data['script_type']
modelo = form.cleaned_data['model']
description = form.cleaned_data['description']
try:
client.create_roteiro().inserir(script_type, name, modelo, description)
messages.add_message(request, messages.SUCCESS, script_messages.get("success_insert"))
return redirect('script.list')
except NomeRoteiroDuplicadoError, e:
messages.add_message(request, messages.ERROR, e)
else:
def edit_form(request, id_vip):
"""
Method to call edit_form_shared
"""
auth = AuthSession(request.session)
client_api = auth.get_clientFactory()
return facade.edit_form_shared(request, id_vip, client_api)
def list_all(request):
try:
filter_list = dict()
# Get user
auth = AuthSession(request.session)
filter_client = auth.get_clientFactory().create_filter()
# Get all filters from NetworkAPI
filter_list = filter_client.list_all()
for filter_ in filter_list['filter']:
filter_['is_more'] = str(False)
if filter_.get('equip_types') is not None:
if type(filter_['equip_types']) is dict:
filter_['equip_types'] = [filter_['equip_types']]
if len(filter_['equip_types']) > 3:
filter_['is_more'] = str(True)
filter_list['form'] = DeleteForm()
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def delete_individ_perms_of_object(request):
try:
if request.method == 'POST':
auth = AuthSession(request.session)
client = auth.get_clientFactory()
form = DeletePermsForm(request.POST)
if form.is_valid():
ids_perms = split_to_array(form.cleaned_data['ids_perms'])
id_ugroup = form.cleaned_data['id_ugroup']
id_type_obj = form.cleaned_data['id_type_obj']
client.create_api_object_group_permission().delete(ids_perms)
messages.add_message(
request, messages.SUCCESS, object_group_perm_messages.
get('success_delete'))
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def insert_vrf(request):
try:
lists = {}
auth = AuthSession(request.session)
client = auth.get_clientFactory()
lists["form_vrf"] = VrfForm() # TODO Alterar depois de edit pra ""
if request.method == 'POST':
# Set data in form
vrf_form = VrfForm(request.POST)
# Return data to form in case of error
lists["form_vrf"] = vrf_form
# Validate
if vrf_form.is_valid():
vrf = vrf_form.cleaned_data["vrf"]
internal_name = vrf_form.cleaned_data["internal_name"]
list_vrf = [{
"vrf": vrf,
"internal_name": internal_name
}]
client.create_api_vrf().create(list_vrf)
messages.add_message(
request, messages.SUCCESS, vrf_messages.get("success_insert"))
return redirect('vrf.list')
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def save_pool(request):
"""
Method to call shared_save_pool
"""
auth = AuthSession(request.session)
client = auth.get_clientFactory()
return facade.shared_save_pool(request, client)
def search_list(request, id_vlan='0', sf_number='0', sf_name='0', sf_environment='0', sf_nettype='0', sf_subnet='0', sf_ipversion='0', sf_network='0', sf_iexact='0', sf_acl='0'):
try:
lists = dict()
lists["delete_form"] = DeleteForm()
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
# Get all environments from NetworkAPI
env_list = client.create_ambiente().list_all()
# Get all network types from NetworkAPI
net_list = client.create_tipo_rede().listar()
lists["search_form"] = SearchVlanForm(env_list, net_list)
lists['search_var'] = id_vlan
lists['sf_number'] = sf_number
lists['sf_name'] = sf_name
lists['sf_environment'] = sf_environment
lists['sf_nettype'] = sf_nettype
lists['sf_subnet'] = sf_subnet
lists['sf_ipversion'] = sf_ipversion
lists['sf_network'] = sf_network
lists['sf_iexact'] = sf_iexact
lists['sf_acl'] = sf_acl
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def ajax_popular_environment(request):
"""
Method to call popular_environment_shared
"""
auth = AuthSession(request.session)
client_api = auth.get_clientFactory()
return facade.popular_environment_shared(request, client_api)
def remove_environment(request):
if request.method == 'POST':
auth = AuthSession(request.session)
client = auth.get_clientFactory()
ids = request.POST.getlist('ids[]')
error_not_found = list()
error_associated = list()
have_errors = False
try:
client.create_api_environment().delete_environment(';'.join(str(id) for id in ids))
except DetailedEnvironmentError, e:
# Detailed message for VLAN errors
logger.error(e)
have_errors = True
messages.add_message(request, messages.ERROR, e)
except AmbienteNaoExisteError, e:
# Environment doesn't exist.
logger.error(e)
have_errors = True
error_not_found.append(id_env)
def dissociate_channel_interface(request, channel_id, interface_id):
auth = AuthSession(request.session)
client = auth.get_clientFactory()
fields_get = ['id',
'protected',
'type__details',
'native_vlan',
'equipment__details',
'front_interface__basic',
'back_interface',
'channel__basic']
data = dict()
data["start_record"] = 0
data["end_record"] = 50
data["extends_search"] = []
data["asorting_cols"] = []
data["searchable_columns"] = ["channel__id"]
data["custom_search"] = channel_id
try:
sw_ids = list()
interfaces = client.create_api_interface_request().search(search=data, fields=fields_get).get('interfaces')
interface_obj = interfaces[0]
for i in interfaces:
sw_ids.append(int(i.get('id')))
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.WARNING, 'Erro ao buscar o channel de Id %s.' % channel_id)
url = request.META.get('HTTP_REFERER') if request.META.get('HTTP_REFERER') else reverse('interface.list')
return HttpResponseRedirect(url)
def ajax_ldap_users_by_group(request, ldap_group, id_user):
try:
lists = dict()
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
exclude_list = []
user_list = client.create_usuario().listar().get('usuario')
for usr in user_list:
if usr['user_ldap'] is not None and usr['user_ldap'] != '' and usr['id'] != id_user:
exclude_list.append(usr['user_ldap'])
ldap_users = Ldap(auth).get_users_group(ldap_group, exclude_list)
lists['ldap_users'] = ldap_users
# Returns HTML
response = HttpResponse(loader.render_to_string(
AJAX_LDAP_USERS_BY_GROUP, lists, context_instance=RequestContext(request)))
response.status_code = 200
return response
except LDAPError:
lists[
'error'] = 'O LDAP não está disponível, não será possível associar o usuário CadVlan a um usuário do LDAP.'
# Returns HTML
response = HttpResponse(loader.render_to_string(
AJAX_LDAP_USERS_BY_GROUP, lists, context_instance=RequestContext(request)))
# Send response status with error
response.status_code = 278
return response
def add_form(request):
try:
if request.method == "POST":
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
form = GroupUserForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
read = PERMISSION.get(form.cleaned_data['read'])
write = PERMISSION.get(form.cleaned_data['write'])
edition = PERMISSION.get(form.cleaned_data['edition'])
delete = PERMISSION.get(form.cleaned_data['delete'])
try:
client.create_grupo_usuario().inserir(
name, read, write, edition, delete)
messages.add_message(
request, messages.SUCCESS, group_user_messages.get("success_insert"))
return redirect('group-user.list')
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
else:
def access_type_form(request):
lists = dict()
try:
auth = AuthSession(request.session)
client = auth.get_clientFactory()
if request.method == 'POST':
form = TipoAcessoForm(request.POST)
lists['form'] = form
if form.is_valid():
protocolo = form.cleaned_data['nome']
client.create_tipo_acesso().inserir(protocolo)
messages.add_message(
request, messages.SUCCESS, access_type_messages.get('success_create'))
lists['form'] = TipoAcessoForm()
# GET METHOD
else:
lists['form'] = TipoAcessoForm()
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def add_form(request):
"""
Method to call add_form_shared
"""
auth = AuthSession(request.session)
client_api = auth.get_clientFactory()
return facade.add_form_shared(request, client_api)
def edit_right(request, id_egroup, id_right):
lists = dict()
lists['id_egroup'] = id_egroup
try:
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
user_group = client.create_grupo_usuario().listar()
if request.method == 'POST':
form = UserEquipGroupForm(user_group, request.POST)
lists['ugroup_form'] = form
if form.is_valid():
update = convert_boolean_to_int(form.cleaned_data['update'])
delete = convert_boolean_to_int(form.cleaned_data['delete'])
read = convert_boolean_to_int(form.cleaned_data['read'])
write = convert_boolean_to_int(form.cleaned_data['write'])
client.create_direito_grupo_equipamento().alterar(
id_right, read, write, update, delete)
messages.add_message(request, messages.SUCCESS, equip_group_messages.get(
"sucess_group_user_equip_edit"))
# Redirect to list_all action
return redirect('equip-group.list', id_egroup, 1)
else:
lists['open_form'] = "True"
# Get Requisition
else:
# Get Group Equipament by ID from NetworkAPI
egroup = client.create_grupo_equipamento().search(
id_egroup)['group_equipament']
right = client.create_direito_grupo_equipamento().buscar_por_id(
id_right).get('direito_grupo_equipamento')
write = convert_int_to_boolean(right.get('escrita'))
update = convert_int_to_boolean(right.get('alterar_config'))
read = convert_int_to_boolean(right.get('leitura'))
delete = convert_int_to_boolean(right.get('exclusao'))
lists['ugroup_form'] = UserEquipGroupForm(user_group, initial={"id_egroup": id_egroup,
"egroup": egroup.get('nome'),
"delete": delete,
"update": update,
"write": write,
"read": read,
'ugroup': right.get("id_grupo_usuario")})
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def edit_form(request, id_group_user):
try:
lists = dict()
lists['form'] = GroupUserForm()
if request.method == 'POST':
auth = AuthSession(request.session)
client = auth.get_clientFactory()
id_group = int(id_group_user)
form = GroupUserForm(request.POST)
lists['form'] = form
lists['action'] = reverse("group-user.edit", args=[id_group])
if form.is_valid():
id_group_user = form.cleaned_data['id_group_user']
name = form.cleaned_data['name']
read = PERMISSION.get(form.cleaned_data['read'])
write = PERMISSION.get(form.cleaned_data['write'])
edition = PERMISSION.get(form.cleaned_data['edition'])
delete = PERMISSION.get(form.cleaned_data['delete'])
try:
client.create_grupo_usuario().alterar(
id_group_user, name, read, write, edition, delete)
messages.add_message(
request, messages.SUCCESS, group_user_messages.get("success_edit"))
return redirect('group-user.list')
except NetworkAPIClientError, e:
messages.add_message(request, messages.ERROR, e)
return render_to_response(GROUPUSER_FORM, lists, context_instance=RequestContext(request))
id_group = int(id_group_user)
auth = AuthSession(request.session)
client = auth.get_clientFactory()
group_user = client.create_grupo_usuario().search(id_group)
if group_user is None:
messages.add_message(
request, messages.ERROR, group_user_messages.get("invalid_group_user"))
return redirect('group-user.list')
group_user = group_user.get('user_group')
# Set Group User data
initial = {'id_group_user': group_user.get('id'), 'name': group_user.get('nome'), 'read': get_permission(group_user.get('leitura')), 'write': get_permission(
group_user.get('escrita')), 'edition': get_permission(group_user.get('edicao')), 'delete': get_permission(group_user.get('exclusao'))}
form = GroupUserForm(initial=initial)
lists['form'] = form
lists['action'] = reverse("group-user.edit", args=[id_group])
def add_form(request):
lists = dict()
try:
if request.method == 'GET':
auth = AuthSession(request.session)
client = auth.get_clientFactory()
if not request.GET.__contains__('equip_name'):
form = SearchEquipForm()
else:
form = SearchEquipForm(request.GET)
if form.is_valid():
name_equip = form.cleaned_data['equip_name']
equip = client.create_equipamento().listar_por_nome(name_equip)
id_equip = equip.get('equipamento').get('id')
protocol_list = client.create_tipo_acesso().listar()
lists['formCad'] = formCad = EquipAccessForm(protocol_list)
formCad.fields['id_equip'].initial = id_equip
formCad.fields['name_equip'].initial = name_equip
lists['form'] = form
return render_to_response(EQUIPMENTACESS_FORM, lists, context_instance=RequestContext(request))
if request.method == 'POST':
auth = AuthSession(request.session)
client = auth.get_clientFactory()
form = SearchEquipForm()
form.fields['equip_name'].initial = request.POST['name_equip']
protocol_list = client.create_tipo_acesso().listar()
formCad = EquipAccessForm(protocol_list, request.POST)
if formCad.is_valid():
user = formCad.cleaned_data['user']
host = formCad.cleaned_data['host']
password = formCad.cleaned_data['password']
second_password = formCad.cleaned_data['second_password']
equip = formCad.cleaned_data['id_equip']
protocol = formCad.cleaned_data['protocol']
try:
client.create_equipamento_acesso().inserir(
equip, host, user, password, protocol, second_password)
messages.add_message(
request, messages.SUCCESS, equip_access_messages.get("success_insert"))
return search_list_param(request, equip)
except EquipamentoAcessoError, e:
messages.add_message(
request, messages.ERROR, equip_access_messages.get("already_association"))
except NetworkAPIClientError, e:
messages.add_message(request, messages.ERROR, e)
def change_password(request):
lists = dict()
if request.method == 'GET':
lists['change_pass_form'] = ChangePassForm()
return render_to_response_ajax(AJAX_NEW_PASS, lists, context_instance=RequestContext(request))
if request.method == 'POST':
change_pass_form = ChangePassForm()
try:
change_pass_form = ChangePassForm(request.POST)
if change_pass_form.is_valid():
auth = AuthSession(request.session)
client = auth.get_clientFactory()
new_password = change_pass_form.cleaned_data['new_pass']
user = auth.get_user()
user_id = user.get_id()
user_current_password = user.get_password()
client.create_usuario().change_password(
user_id, user_current_password, new_password)
user.set_password(new_password)
messages.add_message(
request, messages.SUCCESS, auth_messages.get("pass_change_sucess"))
# Returns HTML
response = HttpResponse(loader.render_to_string(
AJAX_NEW_PASS, lists, context_instance=RequestContext(request)))
# Send response status with error
response.status_code = 200
return response
else:
lists['change_pass_form'] = change_pass_form
# Returns HTML
response = HttpResponse(loader.render_to_string(
AJAX_NEW_PASS, lists, context_instance=RequestContext(request)))
# Send response status with error
response.status_code = 412
return response
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
lists['change_pass_form'] = change_pass_form
return render_to_response_ajax(AJAX_NEW_PASS, lists, context_instance=RequestContext(request))
def login(request):
modal_auto_open = "false"
if request.method == 'POST':
form = LoginForm(request.POST)
form_pass = PassForm()
if form.is_valid():
try:
client = ClientFactory(
NETWORK_API_URL, NETWORK_API_USERNAME, NETWORK_API_PASSWORD)
user = client.create_usuario().authenticate(form.cleaned_data[
'username'], form.cleaned_data['password'], form.cleaned_data['is_ldap_user'])
if user is None:
messages.add_message(
request, messages.ERROR, auth_messages.get("user_invalid"))
else:
request.session.set_expiry(SESSION_EXPIRY_AGE)
auth = AuthSession(request.session)
user = user.get('user')
if user.get('permission') is None:
messages.add_message(
request, messages.ERROR, auth_messages.get("nogroup_error"))
return render_to_response(templates.LOGIN, {'form': form, 'form_pass': form_pass, 'modal': modal_auto_open}, context_instance=RequestContext(request))
auth.login(User(user.get('id'), user.get('user'), user.get('nome'), user.get(
'email'), user.get('pwd'), user.get('permission'), user.get('ativo'), user.get('user_ldap')))
if form.cleaned_data['redirect'] != "":
return HttpResponseRedirect(form.cleaned_data['redirect'])
return HttpResponseRedirect(URL_HOME)
except InvalidParameterError, e:
logger.error(e)
messages.add_message(
request, messages.ERROR, auth_messages.get("user_invalid"))
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
except LDAPNotFoundError, e:
logger.error(e)
messages.add_message(
request, messages.ERROR, auth_messages.get("user_ldap_not_found"))
def handler500(request):
auth = AuthSession(request.session)
messages.add_message(request, messages.ERROR, auth_messages.get("500"))
if auth.is_authenticated():
return HttpResponseRedirect(URL_HOME)
return HttpResponseRedirect(URL_LOGIN)
def delete_channel(request, channel_id=None):
auth = AuthSession(request.session)
client = auth.get_clientFactory()
try:
client.create_api_interface_request().remove_channel([channel_id])
messages.add_message(request, messages.SUCCESS, equip_interface_messages.get("success_remove_channel"))
except ValueError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def disconnect(request, id_interface, back_or_front, equip_name, id_interf_edit):
try:
auth = AuthSession(request.session)
client = auth.get_clientFactory()
client.create_api_interface_request().remove_connection(id_interface, back_or_front)
messages.add_message(request, messages.SUCCESS, equip_interface_messages.get("success_disconnect"))
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def ajax_view_env(request, env_id):
try:
auth = AuthSession(request.session)
client = auth.get_clientFactory()
lists = dict()
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def delete_channel(request, channel_id=None):
auth = AuthSession(request.session)
client = auth.get_clientFactory()
try:
client.create_api_interface_request().remove_channel([channel_id])
messages.add_message(
request, messages.SUCCESS,
equip_interface_messages.get("success_remove_channel"))
except ValueError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def rule_edit_form(request, id_env, id_rule):
# Get User
auth = AuthSession(request.session)
client = auth.get_clientFactory()
try:
# Get rule
rule = client.create_ambiente().get_rule_by_pk(id_rule).get('rule')
initial = {'name': rule['name']}
lists = {}
lists['form'] = EnvironmentRules(initial=initial)
lists['action'] = reverse("block.rules.edit", args=[id_env, id_rule])
lists['env'] = client.create_ambiente().buscar_por_id(
id_env).get('ambiente')
blocks = client.create_ambiente().get_blocks(id_env)
lists['blocks'] = blocks.get('blocks') if blocks else []
lists['contents'] = __mount_content_rules_form(
rule['rule_contents'], rule['rule_blocks'])
lists['id_env'] = id_env
if request.method == "POST":
form = EnvironmentRules(request.POST)
blocks = request.POST.getlist('blocks')
contents = request.POST.getlist('content')
rule_contents = request.POST.getlist('rule_content')
if form.is_valid() and __is_valid_contents(contents, request):
client.create_ambiente().update_rule(form.cleaned_data['name'],
id_env,
contents,
rule_contents,
id_rule)
messages.add_message(
request, messages.SUCCESS, rule_messages.get('success_edit'))
return redirect('block.rules.list', id_env)
else:
# Return form with errors
lists['form'] = form
lists['contents'] = __mount_content_rules_form(
contents, rule_contents)
return render_to_response(TAB_RULES_FORM, lists, context_instance=RequestContext(request))
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
return redirect('block.rules.list', id_env)
def edit_form_perm(request, id_ugroup, id_perm):
try:
lists = dict()
lists['edit_perms'] = True
lists['action_edit_perms'] = reverse(
"user-group-perm.edit", args=[id_ugroup, id_perm])
# Get user
auth = AuthSession(request.session)
client_perm = auth.get_clientFactory(
).create_permissao_administrativa()
# Get Group User by ID from NetworkAPI
lists['ugroup'] = auth.get_clientFactory().create_grupo_usuario().search(
id_ugroup).get('user_group')
function_list = validates_dict(
auth.get_clientFactory().create_permission().list_all(), 'perms')
perm = client_perm.search(id_perm).get("perm")
if request.method == "POST":
form = PermissionGroupForm(function_list, request.POST)
lists['form_perms'] = form
if form.is_valid():
id_perm = form.cleaned_data['id_group_perms']
function = form.cleaned_data['function']
read = convert_boolean_to_int(form.cleaned_data['read'])
write = convert_boolean_to_int(form.cleaned_data['write'])
client_perm.alterar(id_perm, function, read, write, id_ugroup)
messages.add_message(
request, messages.SUCCESS, perm_group_messages.get("success_edit"))
return redirect('user-group.list', id_ugroup, 1)
# GET
else:
initial = {"id_group_perms": perm.get("id"), "function": perm.get("permission"), "read": convert_string_to_boolean(
perm.get("leitura")), "write": convert_string_to_boolean(perm.get("escrita"))}
lists['form_perms'] = PermissionGroupForm(
function_list, initial=initial)
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def add_logic_environment(request):
auth = AuthSession(request.session)
client = auth.get_clientFactory()
if request.method == 'POST':
env = dict(name=request.POST.get('logicName'))
client.create_api_environment_logic().create([env])
messages.add_message(request,
messages.SUCCESS,
environment_messages.get("success_insert"))
return HttpResponseRedirect(reverse("environment.add"))
def version_checks(request):
# Get user auth
auth = AuthSession(request.session)
client = auth.get_clientFactory()
# Show versions
lists = dict()
lists['version_cadvlan'] = CADVLAN_VERSION
lists['version_client'] = CLIENT_VERSION
lists['version_api'] = client.create_log().get_version().get('api_version')
return render_to_response(VERSION_HTML,
lists,
context_instance=RequestContext(request))
def add_channel_(request):
auth = AuthSession(request.session)
client = auth.get_clientFactory()
lists = dict()
if request.method == "POST":
data = dict()
data["start_record"] = 0
data["end_record"] = 30000
data["asorting_cols"] = []
data["searchable_columns"] = []
data["custom_search"] = ""
data["extends_search"] = []
envs = client.create_api_environment().search(fields=["name", "id"], search=data)
env_id = None
envs_vlans = list()
for e, v in zip(request.POST.getlist('environment'), request.POST.getlist('rangevlan')):
for obj in envs.get('environments'):
if obj.get('name') in e:
env_id = obj.get('id')
if env_id:
group = dict(env=env_id, vlans=v)
envs_vlans.append(group)
channel = {
'name': request.POST.get('channelnumber'),
'lacp': True if int(request.POST.get('lacp_yes')) else False,
'int_type': "Access" if int(request.POST.get('access')) else "Trunk",
'vlan': int(request.POST.get('channelvlan')),
'interfaces': request.POST.getlist('switchInt'),
'envs_vlans': envs_vlans
}
try:
channel_obj = client.create_api_interface_request().create_channel([channel])
channel_id = channel_obj[0].get('id')
messages.add_message(request, messages.SUCCESS, "O channel foi criado com sucesso!")
except NetworkAPIClientError as e:
logger.error(e)
messages.add_message(request, messages.ERROR, "Erro ao criar o channel. %s" % e)
return render_to_response(NEW_CHANNEL, lists, RequestContext(request))
return HttpResponseRedirect(reverse("edit.channel", args=[channel_id]))
return render_to_response(NEW_CHANNEL, lists, RequestContext(request))
def list_vrf(request):
try:
lists = {}
auth = AuthSession(request.session)
client = auth.get_clientFactory()
vrfs = client.create_api_vrf().search()["vrfs"]
lists['vrfs'] = vrfs
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def delete_interface(request, interface_id=None):
auth = AuthSession(request.session)
equip_interface = auth.get_clientFactory().create_api_interface_request()
try:
equip_interface.remove([interface_id])
messages.add_message(request, messages.SUCCESS,
equip_interface_messages.get("success_remove"))
except NetworkAPIClientError, e:
message = str(
error_messages.get("can_not_remove_error")) + " " + str(e)
logger.error(e)
messages.add_message(request, messages.WARNING, message)
def delete_all(request):
equip_nam = request.POST['equip_name']
if request.method == 'POST':
form = DeleteForm(request.POST)
if form.is_valid():
# Get user
auth = AuthSession(request.session)
equip_script = auth.get_clientFactory().create_equipamento_roteiro(
)
# All ids to be deleted
ids = split_to_array(form.cleaned_data['ids'])
equipment = form.cleaned_data['equip_id']
equip_nam = form.cleaned_data['equip_name']
# Control others exceptions
have_errors = False
# For each script selected to remove
for id_es in ids:
try:
# Execute in NetworkAPI
equip_script.remover(equipment, id_es)
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
have_errors = True
break
# If all has ben removed
if have_errors == False:
messages.add_message(
request, messages.SUCCESS,
equip_script_messages.get("success_remove"))
else:
messages.add_message(
request, messages.WARNING,
error_messages.get("can_not_remove_error"))
else:
messages.add_message(request, messages.ERROR,
error_messages.get("select_one"))
def edit_channel_(request, channel_id=None):
auth = AuthSession(request.session)
client = auth.get_clientFactory()
lists = dict()
lists['channel_id'] = channel_id
fields = ['id', 'front_interface__id']
fields_get = ['id',
'interface',
'description',
'protected',
'type__details',
'native_vlan',
'equipment__basic',
'front_interface__basic',
'back_interface',
'channel__basic']
search = {
"start_record": 0,
"end_record": 50,
"asorting_cols": [],
"searchable_columns": ["channel__id"],
"custom_search": channel_id,
"extends_search": []
}
try:
sw_ids = []
server_ids = []
interfaces = client.create_api_interface_request().search(
search=search, fields=fields).get('interfaces')
for i in interfaces:
sw_ids.append(i.get('id'))
server_ids.append(i.get('front_interface'))
sw_interfaces = client.create_api_interface_request().get(
sw_ids, fields=fields_get).get('interfaces')
server_interfaces = client.create_api_interface_request().get(server_ids,
fields=fields_get)
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.WARNING,
'Erro ao buscar o channel de Id %s.' % channel_id)
url = request.META.get('HTTP_REFERER') if request.META.get(
'HTTP_REFERER') else reverse('interface.list')
return HttpResponseRedirect(url)
def load_list(request, lists, id_egroup, tab):
try:
equipament_list = lists
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
equipament_list['equipments'] = validates_dict(
client.create_equipamento().list_by_group(id_egroup), 'equipments')
equipament_list['form'] = DeleteForm()
equipament_list['egroup'] = client.create_grupo_equipamento().search(
id_egroup)['group_equipament']
equipament_list['tab'] = '0' if tab == '0' else '1'
group_equipment_perm = client.create_direito_grupo_equipamento(
).listar_por_grupo_equipamento(id_egroup).get(
"direito_grupo_equipamento")
equipament_list['ugroups'] = group_equipment_perm
equipament_list['form_ugroup'] = DeleteFormAux()
if not 'ugroup_form' in equipament_list:
ugroups = client.create_grupo_usuario().listar()
egroup = client.create_grupo_equipamento().search(
id_egroup)['group_equipament']
equipament_list['ugroup_form'] = UserEquipGroupForm(
ugroups,
initial={
"id_egroup": id_egroup,
"egroup": egroup.get('nome')
})
if not 'url_form' in equipament_list:
lists['url_form'] = reverse("equip-user-group.form",
args=[id_egroup])
if not 'open_form' in equipament_list:
lists['open_form'] = 'False'
if not 'url_edit' in equipament_list:
lists['edit'] = 'False'
else:
lists['edit'] = 'True'
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def edit_form(request, id_script):
try:
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
lists = dict()
list_models = []
forms_aux = dict()
script = client.create_roteiro().get_by_id(id_script)
script = script.get('script')
forms_aux['tipo_roteiro'] = client.create_tipo_roteiro().listar()
forms_aux['modelos'] = client.create_modelo().listar().get('model')
modelos = client.create_modelo().get_by_script_id(id_script)
modelos = modelos.get('model')
if modelos is not []:
for i in modelos:
list_models.append(i.get('id'))
lists['id'] = id_script
if request.method == 'GET':
form = ScriptForm(forms_aux,
initial={
'name': script.get('roteiro'),
'script_type': script.get('tipo_roteiro'),
'model': list_models,
'description': script.get('descricao')
})
if request.method == 'POST':
form = ScriptForm(forms_aux, request.POST)
if form.is_valid():
nome = form.cleaned_data['name']
tipo = form.cleaned_data['script_type']
modelo = form.cleaned_data['model']
descricao = form.cleaned_data['description']
client.create_roteiro().alterar(id_script, tipo, nome,
descricao, modelo)
messages.add_message(request, messages.SUCCESS,
script_messages.get("success_edit"))
lists['form'] = form
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def ajax_autocomplete_equips(request):
try:
equip_list = dict()
# Get user auth
auth = AuthSession(request.session)
equipment = auth.get_clientFactory().create_equipamento()
# Get list of equipments from cache
equip_list = cache_list_equipment(equipment)
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def ajax_autocomplete_users(request):
try:
user_list = dict()
# Get user auth
auth = AuthSession(request.session)
user = auth.get_clientFactory().create_usuario()
# Get list of equipments from cache
user_list = list_users(user)
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def ajax_autocomplete_acl_path(request):
try:
# Get user auth
auth = AuthSession(request.session)
environment = auth.get_clientFactory().create_ambiente()
path_list = {}
paths = environment.list_acl_path().get(
"acl_paths") if environment.list_acl_path() else list()
path_list['list'] = paths
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def delete_equipment(request, id_equip):
"""
Method called from modal of equipment's reals
"""
# Get user
auth = AuthSession(request.session)
client_equip = auth.get_clientFactory().create_equipamento()
delete_equipments_shared(request, client_equip, [
id_equip,
])
# Redirect to list_all action
return redirect('equipment.search.list')
def _decorated(request, *args, **kwargs):
auth = AuthSession(request.session)
if auth.is_authenticated():
return view_func(request, *args, **kwargs)
else:
if request.is_ajax():
response = HttpResponseRedirect(URL_LOGIN)
response.status_code = 278
response.content = error_messages.get('login_required')
return response
else:
return HttpResponseRedirect(URL_LOGIN + '?redirect=' +
request.path)
def disconnect_interfaces(request, interface_a=None, interface_b=None):
auth = AuthSession(request.session)
client = auth.get_clientFactory()
try:
client.create_api_interface_request().disconnecting_interfaces(
[interface_a, interface_b])
messages.add_message(request, messages.SUCCESS, 'Conexão removida.')
except NetworkAPIClientError as e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
except Exception as e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
return HttpResponseRedirect(reverse("interface.edit", args=[interface_a]))
def list_variables(request):
try:
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
lists = dict()
if request.method == 'GET':
lists['variables'] = list_all_variables(client)
lists['delete_form'] = DeleteForm()
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def add_interface(request, equipment=None):
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
url = request.META.get('HTTP_REFERER') if request.META.get('HTTP_REFERER') else reverse('interface.list')
try:
search_equipment = client.create_api_equipment().get(ids=[equipment],
kind='details',
fields=['id', 'name', 'environments'])
equips = search_equipment.get('equipments')[0]
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
return HttpResponseRedirect(url)
def add_group_form(request):
try:
lists = dict()
ldap = Ldap(AuthSession(request.session).get_user().get_username())
users_list = get_users(ldap)
if request.method == "POST":
form = GroupForm(users_list, request.POST)
if form.is_valid():
cn = str(form.cleaned_data['cn'])
gidNumber = str(form.cleaned_data['gidNumber'])
member_uid = form.cleaned_data['member_uid']
if valid_form_group(ldap, request, cn, gidNumber):
ldap.add_group(cn, gidNumber, member_uid)
messages.add_message(
request, messages.SUCCESS, ldap_messages.get("success_insert_group"))
return redirect('ldap.group.list')
else:
form = GroupForm(
users_list, initial={'gidNumber': gidNumber_suggest(ldap)})
except LDAPError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def remove_draft(request):
try:
auth = AuthSession(request.session)
client = auth.get_clientFactory()
id_vlan = request.GET.get('id_vlan')
type_acl = request.GET.get('type_acl')
client.create_api_vlan().acl_remove_draft(id_vlan, type_acl)
return HttpResponse()
except NetworkAPIClientError, exception:
logger.error(exception)
return HttpResponse(exception, status=203)
def ajax_ldap_pop_name_mail(request, cn):
try:
lists = dict()
# Get user
auth = AuthSession(request.session)
ldap_user = Ldap(auth).get_user(cn)
lists['ldap_name'] = ldap_user['givenName'] + ' ' + \
ldap_user['initials'] + ' ' + ldap_user['sn']
lists['ldap_email'] = ldap_user['mail']
lists['error'] = ' '
response = HttpResponse(
loader.render_to_string(AJAX_LDAP_USER_POP_NAME_MAIL,
lists,
context_instance=RequestContext(request)))
#render_to_response_ajax(AJAX_LDAP_USER_POP_NAME_MAIL, lists, context_instance=RequestContext(request))
response.status_code = 200
return response
except LDAPError, e:
logger.error("LDAP Error on ajax_ldap_pop_name_mail %s" % e)
lists['ldap_name'] = ' '
lists['ldap_email'] = ' '
lists[
'error'] = 'O LDAP não está disponível, não será possível associar o usuário CadVlan a um usuário do LDAP.'
def render(self, context):
auth = AuthSession(context['request'].session)
user = auth.get_user()
if self.write == "None":
self.write = None
if self.read == "None":
self.read = None
if user.has_perm_menu(self.write, self.read):
context["has_perm"] = True
else:
context["has_perm"] = False
return u""
def delete_all(request):
if request.method == 'POST':
form = DeleteForm(request.POST)
if form.is_valid():
auth = AuthSession(request.session)
client = auth.get_clientFactory()
ids = split_to_array(form.cleaned_data['ids'])
error_list = list()
have_errors = False
for id_var in ids:
try:
client.create_system().delete_all(id_var)
except VariableError:
error_list.append(id_var)
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
have_errors = True
break
if len(error_list) == len(ids):
messages.add_message(request, messages.ERROR,
error_messages.get("can_not_remove_all"))
elif len(error_list) > 0:
msg = ""
for id_error in error_list:
msg = msg + id_error + ", "
msg = error_messages.get("can_not_remove") % msg[:-2]
messages.add_message(request, messages.WARNING, msg)
elif have_errors == False:
messages.add_message(
request, messages.SUCCESS,
system_variable_messages.get("success_delete"))
else:
messages.add_message(
request, messages.SUCCESS,
error_messages.get("can_not_remove_error"))
else:
messages.add_message(request, messages.ERROR,
error_messages.get("select_one"))
def rule_add_form(request, id_env):
try:
lists = dict()
lists['form'] = EnvironmentRules()
lists['action'] = reverse("block.rules.form", args=[id_env])
lists['contents'] = list()
lists['id_env'] = id_env
# Get User
auth = AuthSession(request.session)
client = auth.get_clientFactory()
lists['env'] = client.create_ambiente().buscar_por_id(
id_env).get('ambiente')
blocks = client.create_ambiente().get_blocks(id_env)
lists['blocks'] = blocks.get('blocks') if blocks else []
if request.method == "POST":
form = EnvironmentRules(request.POST)
blocks = request.POST.getlist('blocks')
contents = request.POST.getlist('content')
rule_contents = request.POST.getlist('rule_content')
if form.is_valid() and __is_valid_contents(contents, request):
client.create_ambiente().save_rule(form.cleaned_data['name'],
id_env,
contents,
rule_contents)
messages.add_message(
request, messages.SUCCESS, rule_messages.get('success_insert'))
return redirect('block.rules.list', id_env)
else:
lists['form'] = form
lists['contents'] = __mount_content_rules_form(
contents, rule_contents)
else:
lists['contents'].append(ContentRulesForm())
return render_to_response(TAB_RULES_FORM, lists, context_instance=RequestContext(request))
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
return redirect('block.rules.list', id_env)
def list_all(request):
try:
option_vip_list = dict()
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
# Get all option vips from NetworkAPI
option_vip_list = client.create_option_vip().get_all()
option_vip_list['form'] = DeleteForm()
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def tab_pools(request, id_vip):
lists = dict()
lists['idt'] = id_vip
lists['status_form'] = DeleteForm()
try:
auth = AuthSession(request.session)
client_api = auth.get_clientFactory()
vip = client_api.create_api_vip_request().get(
ids=[id_vip], kind='details')['vips'][0]
lists['vip'] = vip
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def connect_interfaces(request,
id_interface=None,
front_or_back=None,
all_interfaces=None):
auth = AuthSession(request.session)
client = auth.get_clientFactory()
lists = dict()
lists['id_interface'] = id_interface
lists['front_or_back'] = front_or_back
if request.method == "GET":
if request.GET.__contains__('search_equip'):
equipment_name = request.GET.get('search_equip')
logger.debug(equipment_name)
else:
try:
int(all_interfaces)
return render_to_response(NEW_INTERFACE_CONNECT_FORM, lists,
RequestContext(request))
except Exception:
equipment_name = all_interfaces
data = dict()
data["start_record"] = 0
data["end_record"] = 1000
data["asorting_cols"] = ["id"]
data["searchable_columns"] = ["nome"]
data["custom_search"] = equipment_name
data["extends_search"] = []
equipment = list()
try:
search_equipment = client.create_api_equipment().search(
search=data)
equipment = search_equipment.get('equipments')
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
except Exception, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
def list_all(request):
try:
script_type_list = dict()
# Get user
auth = AuthSession(request.session)
client = auth.get_clientFactory()
# Get all script_types from NetworkAPI
script_type_list = client.create_tipo_roteiro().listar()
script_type_list['form'] = DeleteForm()
except NetworkAPIClientError, e:
logger.error(e)
messages.add_message(request, messages.ERROR, e)
