def delete_vrf(vrf_id):
"""
Delete environment
:param env: dict
"""
Vrf.remove(None, vrf_id)
def delete_vrf(vrf_id):
"""
Delete vrf
:param vrf_id: int
"""
Vrf.remove(vrf_id)
def delete_vrf(vrf_id):
"""
Delete vrf
:param vrf_id: int
"""
Vrf.remove(vrf_id)
def create_vrf(vrf):
"""
Create vrf
:param env: dict
"""
vrf_obj = Vrf()
vrf_obj.vrf = vrf.get('vrf')
vrf_obj.internal_name = vrf.get('internal_name')
vrf_obj.create(None)
return vrf_obj
def update_vrf(vrf):
"""
Update vrf
:param vrf: dict
"""
vrf_obj = get_vrf_by_id(vrf.get('id'))
Vrf.update(
None,
vrf_obj.id,
vrf=vrf.get('vrf'),
internal_name=vrf.get('internal_name'),
)
return vrf_obj
def update_vrf(vrf):
"""
Update vrf
:param env: dict
"""
vrf_obj = get_vrf_by_id(vrf.get('id'))
Vrf.update(
None,
vrf_obj.id,
vrf=vrf.get('vrf'),
internal_name=vrf.get('internal_name'),
)
return vrf_obj
def create_vrf(vrf):
"""
Create vrf
:param env: dict
"""
vrf_obj = Vrf()
vrf_obj.vrf = vrf.get('vrf')
vrf_obj.internal_name = vrf.get('internal_name')
vrf_obj.create(None)
return vrf_obj
def handle_post(self, request, user, *args, **kwargs):
"""Trata as requisições de POST para criar Informações de Acesso a Equipamentos.
URL: /equipamentoacesso
"""
# Obtém dados do request e verifica acesso
try:
# Obtém os dados do xml do request
xml_map, attrs_map = loads(request.raw_post_data)
# Obtém o mapa correspondente ao root node do mapa do XML
# (networkapi)
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(
3,
u'Não existe valor para a tag networkapi do XML de requisição.'
)
# Verifica a existência do node "equipamento_acesso"
equipamento_acesso_map = networkapi_map.get('equipamento_acesso')
if equipamento_acesso_map is None:
return self.response_error(
3,
u'Não existe valor para a tag equipamento_acesso do XML de requisição.'
)
# Verifica a existência do valor "id_equipamento"
id_equipamento = equipamento_acesso_map.get('id_equipamento')
# Valid ID Equipment
if not is_valid_int_greater_zero_param(id_equipamento):
self.log.error(
u'The id_equipamento parameter is not a valid value: %s.',
id_equipamento)
raise InvalidValueError(None, 'id_equipamento', id_equipamento)
try:
id_equipamento = int(id_equipamento)
except (TypeError, ValueError):
self.log.error(u'Valor do id_equipamento inválido: %s.',
id_equipamento)
return self.response_error(117, id_equipamento)
# Após obtenção do id_equipamento podemos verificar a permissão
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION, None,
id_equipamento,
AdminPermission.EQUIP_WRITE_OPERATION):
return self.not_authorized()
# Verifica a existência do valor "fqdn"
fqdn = equipamento_acesso_map.get('fqdn')
# Valid fqdn
if not is_valid_string_maxsize(
fqdn, 100) or not is_valid_string_minsize(fqdn, 4):
self.log.error(u'Parameter fqdn is invalid. Value: %s', fqdn)
raise InvalidValueError(None, 'fqdn', fqdn)
# Verifica a existência do valor "user"
username = equipamento_acesso_map.get('user')
# Valid username
if not is_valid_string_maxsize(
username, 20) or not is_valid_string_minsize(username, 3):
self.log.error(u'Parameter username is invalid. Value: %s',
username)
raise InvalidValueError(None, 'username', username)
# Verifica a existência do valor "pass"
password = equipamento_acesso_map.get('pass')
# Valid password
if not is_valid_string_maxsize(
password, 150) or not is_valid_string_minsize(password, 3):
self.log.error(u'Parameter password is invalid.')
raise InvalidValueError(None, 'password', '****')
# Verifica a existência do valor "id_tipo_acesso"
id_tipo_acesso = equipamento_acesso_map.get('id_tipo_acesso')
# Valid ID Equipment
if not is_valid_int_greater_zero_param(id_tipo_acesso):
self.log.error(
u'The id_tipo_acesso parameter is not a valid value: %s.',
id_tipo_acesso)
raise InvalidValueError(None, 'id_tipo_acesso', id_tipo_acesso)
try:
id_tipo_acesso = int(id_tipo_acesso)
except (TypeError, ValueError):
self.log.error(u'Valor do id_tipo_acesso inválido: %s.',
id_tipo_acesso)
return self.response_error(171, id_tipo_acesso)
# Obtém o valor de "enable_pass"
enable_pass = equipamento_acesso_map.get('enable_pass')
# Valid enable_pass
if not is_valid_string_maxsize(enable_pass,
150) or not is_valid_string_minsize(
enable_pass, 3):
self.log.error(u'Parameter enable_pass is invalid.')
raise InvalidValueError(None, 'enable_pass', '****')
# Obtém o valor de "vrf"
vrf = equipamento_acesso_map.get('vrf')
vrf_obj = None
if vrf:
# Valid enable_pass
if not is_valid_int_greater_zero_param(vrf):
self.log.error(
u'The vrf parameter is not a valid value: %s.', vrf)
raise InvalidValueError(None, 'vrf', vrf)
vrf_obj = Vrf(int(vrf))
# Cria acesso ao equipamento conforme dados recebidos no XML
equipamento_acesso = EquipamentoAcesso(
equipamento=Equipamento(id=id_equipamento),
fqdn=fqdn,
user=username,
password=password,
tipo_acesso=TipoAcesso(id=id_tipo_acesso),
enable_pass=enable_pass,
vrf=vrf_obj)
equipamento_acesso.create(user)
# Monta dict para response
networkapi_map = dict()
equipamento_acesso_map = dict()
equipamento_acesso_map['id'] = equipamento_acesso.id
networkapi_map['equipamento_acesso'] = equipamento_acesso_map
return self.response(dumps_networkapi(networkapi_map))
except InvalidValueError as e:
return self.response_error(269, e.param, e.value)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisição.')
return self.response_error(3, x)
def handle_post(self, request, auth, *args, **kwargs):
"""Handles POST requests to update Equipment Access by id.
URLs: /equipmentaccess/edit/
"""
self.log.info('Update EquipmentAccess by id')
try:
# Commons Validations
# Business Validations
# Load XML data
xml_map, attrs_map = loads(request.raw_post_data)
# XML data format
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
msg = u'There is no value to the networkapi tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
equipmentaccess_map = networkapi_map.get('equipamento_acesso')
if equipmentaccess_map is None:
msg = u'There is no value to the equipamento_acesso tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
# Get XML data
user = equipmentaccess_map.get('user')
password = equipmentaccess_map.get('pass')
fqdn = equipmentaccess_map.get('fqdn')
enable_pass = equipmentaccess_map.get('enable_pass')
type_access = equipmentaccess_map.get('id_tipo_acesso')
equip_access = equipmentaccess_map.get('id_equip_acesso')
vrf = equipmentaccess_map.get('vrf')
# Password must NOT be none and 20 is the maxsize and 3 is the
# minsize
if not is_valid_string_maxsize(
password, 150) or not is_valid_string_minsize(password, 3):
self.log.error(u'Parameter pass is invalid.')
raise InvalidValueError(None, 'pass', '****')
# Enable Pass must NOT be none and 20 is the maxsize and 3 is the
# minsize
if not is_valid_string_maxsize(enable_pass,
150) or not is_valid_string_minsize(
enable_pass, 3):
self.log.error(u'Parameter enable_pass is invalid.')
raise InvalidValueError(None, 'enable_pass', '****')
# User must NOT be none and 20 is the maxsize and 3 is the minsize
if not is_valid_string_maxsize(
user, 20) or not is_valid_string_minsize(user, 3):
self.log.error(u'Parameter user is invalid. Value: %s.', user)
raise InvalidValueError(None, 'user', user)
# Host must NOT be none and 100 is the maxsize and 4 is the minsize
if not is_valid_string_maxsize(
fqdn, 100) or not is_valid_string_minsize(fqdn, 4):
self.log.error(u'Parameter fqdn is invalid. Value: %s.', fqdn)
raise InvalidValueError(None, 'fqdn', fqdn)
# Type Access
# Valid type access ID
if not is_valid_int_greater_zero_param(type_access):
self.log.error(
u'Parameter type_access_id is invalid. Value: %s.',
type_access)
raise InvalidValueError(None, 'type_access_id', type_access)
# Valid vrf id
vrf_obj = None
if vrf:
if not is_valid_int_greater_zero_param(vrf):
self.log.error(
u'The vrf parameter is not a valid value: %s.', vrf)
raise InvalidValueError(None, 'vrf', vrf)
vrf_obj = Vrf(int(vrf))
type_access = TipoAcesso.get_by_pk(type_access)
# Business Rules
equip_access = EquipamentoAcesso.get_by_pk(equip_access)
# User permission
if not has_perm(auth, AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION, None,
equip_access.equipamento.id,
AdminPermission.EQUIP_WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
return self.not_authorized()
with distributedlock(LOCK_EQUIPMENT_ACCESS % type_access.id):
# valid duplicate association
if not (int(type_access.id) == int(
equip_access.tipo_acesso.id)):
if EquipamentoAcesso.objects.filter(
equipamento=equip_access.equipamento,
tipo_acesso=type_access).count() > 0:
raise EquipamentoAccessDuplicatedError(
None,
u'Já existe esta associação de equipamento e tipo de acesso cadastrada.'
)
equip_access.__dict__.update(fqdn=fqdn,
user=user,
password=password,
enable_pass=enable_pass)
equip_access.tipo_acesso = type_access
# Compatibility
# If there is no 'vrf' field in equipmentaccess_map, keep the actual
# cleans (insert null) if vrf = ''
if vrf is not None:
equip_access.vrf = vrf_obj
equip_access.save(auth)
# update
equipmentaccess_map = dict()
equipmentaccess_map['equipamento_acesso'] = model_to_dict(
equip_access)
# Return XML
return self.response(dumps_networkapi(equipmentaccess_map))
except InvalidValueError as e:
return self.response_error(269, e.param, e.value)
except EquipamentoAccessNotFoundError as e:
return self.response_error(303)
except EquipamentoAccessDuplicatedError as e:
return self.response_error(242, equip_access.equipamento.id,
type_access.id)
except AccessTypeNotFoundError as e:
return self.response_error(304)
except (TipoAcessoError, EquipamentoError):
return self.response_error(1)
except XMLError, x:
self.log.error(u'Error reading the XML request.')
return self.response_error(3, x)