def handle_get(self, request, user, *args, **kwargs):
        '''Trata as requisições de GET para listar Roteiros.

        URLs: roteiro/$
              roteiro/tiporoteiro/<id_tipo_roteiro>/
              roteiro/equipamento/<id_equip>/
        '''

        try:
            map_list = []

            equipment_id = kwargs.get('id_equip')
            if equipment_id is None:
                if not has_perm(user, AdminPermission.SCRIPT_MANAGEMENT, AdminPermission.READ_OPERATION):
                    return self.not_authorized()

                scripts = Roteiro.search(kwargs.get('id_tipo_roteiro'))
                for script in scripts:
                    script_map = dict()
                    script_map['id'] = script.id
                    script_map['nome'] = script.roteiro
                    script_map['descricao'] = script.descricao
                    script_map['id_tipo_roteiro'] = script.tipo_roteiro_id

                    map_list.append(script_map)

            else:
                if not has_perm(user,
                                AdminPermission.EQUIPMENT_MANAGEMENT,
                                AdminPermission.READ_OPERATION,
                                None,
                                equipment_id,
                                AdminPermission.EQUIP_READ_OPERATION):
                    return self.not_authorized()

                equipment_scripts = EquipamentoRoteiro.search(
                    None, equipment_id)
                for equipment_script in equipment_scripts:
                    script_map = dict()
                    script_map['id'] = equipment_script.roteiro.id
                    script_map['nome'] = equipment_script.roteiro.roteiro
                    script_map[
                        'descricao'] = equipment_script.roteiro.descricao
                    script_map[
                        'id_tipo_roteiro'] = equipment_script.roteiro.tipo_roteiro.id
                    script_map[
                        'nome_tipo_roteiro'] = equipment_script.roteiro.tipo_roteiro.tipo
                    script_map[
                        'descricao_tipo_roteiro'] = equipment_script.roteiro.tipo_roteiro.descricao

                    map_list.append(script_map)

            return self.response(dumps_networkapi({'roteiro': map_list}))

        except EquipamentoNotFoundError:
            return self.response_error(117, equipment_id)
        except (RoteiroError, GrupoError, EquipamentoError):
            return self.response_error(1)

    def handle_get(self, request, user, *args, **kwargs):
        """Treat requests GET to list all Environments.

        URL: /ambiente/equip/id_equip
        """

        try:

            # Commons Validations

            # User permission

            if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
                return self.not_authorized()
            if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
                return self.not_authorized()

            id_equip = kwargs.get('id_equip')

            if not is_valid_int_greater_zero_param(id_equip):
                raise InvalidValueError(None, 'id_equip', id_equip)

            # Business Rules
            equip = Equipamento.get_by_pk(id_equip)
            environments_list = EquipamentoAmbiente.get_by_equipment(equip.id)

            # Get all environments in DB
            lists_aux = []
            for environment in environments_list:
                env = Ambiente.get_by_pk(environment.ambiente.id)
                env_map = model_to_dict(env)
                env_map['grupo_l3_name'] = env.grupo_l3.nome
                env_map['ambiente_logico_name'] = env.ambiente_logico.nome
                env_map['divisao_dc_name'] = env.divisao_dc.nome
                env_map['is_router'] = environment.is_router

                try:
                    env_map['range'] = str(
                        env.min_num_vlan_1) + ' - ' + str(env.max_num_vlan_1)
                    if env.min_num_vlan_1 != env.min_num_vlan_2:
                        env_map['range'] = env_map[
                            'range'] + '; ' + str(env.min_num_vlan_2) + ' - ' + str(env.max_num_vlan_2)
                except:
                    env_map['range'] = 'Nao definido'

                if env.filter is not None:
                    env_map['filter_name'] = env.filter.name

                lists_aux.append(env_map)
            # Return XML
            environment_list = dict()
            environment_list['ambiente'] = lists_aux
            return self.response(dumps_networkapi(environment_list))

        except InvalidValueError, e:
            self.log.error(
                u'Parameter %s is invalid. Value: %s.', e.param, e.value)
            return self.response_error(269, e.param, e.value)

    def create_vlan(self, user, vlan_id):

        if not has_perm(user, AdminPermission.VLAN_MANAGEMENT, AdminPermission.WRITE_OPERATION):
            return self.not_authorized()

        vlan = Vlan().get_by_pk(vlan_id)

        # Check permission group equipments
        equips_from_ipv4 = Equipamento.objects.filter(
            ipequipamento__ip__networkipv4__vlan=vlan_id, equipamentoambiente__is_router=1)
        equips_from_ipv6 = Equipamento.objects.filter(
            ipv6equipament__ip__networkipv6__vlan=vlan_id, equipamentoambiente__is_router=1)
        for equip in equips_from_ipv4:
            # User permission
            if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.WRITE_OPERATION, None, equip.id, AdminPermission.EQUIP_WRITE_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                return self.not_authorized()
        for equip in equips_from_ipv6:
            # User permission
            if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.WRITE_OPERATION, None, equip.id, AdminPermission.EQUIP_WRITE_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                return self.not_authorized()

        if vlan.ativada:
            return self.response_error(122)

        command = settings.VLAN_CREATE % (vlan.id)

        code, stdout, stderr = exec_script(command)
        if code == 0:
            vlan.activate(user)

            success_map = dict()
            success_map['codigo'] = '%04d' % code
            success_map['descricao'] = {'stdout': stdout, 'stderr': stderr}

            map = dict()
            map['sucesso'] = success_map

            # Send to Queue
            queue_manager = QueueManager()

            serializer = VlanSerializer(vlan)
            data_to_queue = serializer.data
            data_to_queue.update({'description': queue_keys.VLAN_CREATE})
            queue_manager.append({'action': queue_keys.VLAN_CREATE,'kind': queue_keys.VLAN_KEY,'data': data_to_queue})

            queue_manager.send()

            return self.response(dumps_networkapi(map))
        else:
            return self.response_error(2, stdout + stderr)

    def handle_delete(self, request, user, *args, **kwargs):
        """Treat DELETE requests to remove Group User.

        URL: ugroup/<id_ugroup>/
        """
        try:

            self.log.info('Remove Group User')

            # User permission
            if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.WRITE_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                raise UserNotAuthorizedError(None)

            id_ugroup = kwargs.get('id_ugroup')

            # Valid Group User ID
            if not is_valid_int_greater_zero_param(id_ugroup):
                self.log.error(
                    u'The id_ugroup parameter is not a valid value: %s.', id_ugroup)
                raise InvalidValueError(None, 'id_ugroup', id_ugroup)

            # Find Group User by ID to check if it exist
            ugroup = UGrupo.get_by_pk(id_ugroup)

            with distributedlock(LOCK_GROUP_USER % id_ugroup):

                ugroup.delete()
                return self.response(dumps_networkapi({}))

        except InvalidValueError, e:
            return self.response_error(269, e.param, e.value)

    def handle_get(self, request, user, *args, **kwargs):
        """Treat requests GET to list all Equipment Type.

        URL: equipmenttype/all
        """
        try:

            self.log.info("GET to list all Equipment Type")

            # User permission
            if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                raise UserNotAuthorizedError(None)

            map_list = []
            for equipment_type in TipoEquipamento.objects.all():
                eq_tp = {
                    'id': equipment_type.id, 'nome': equipment_type.tipo_equipamento}
                map_list.append(eq_tp)

            return self.response(dumps_networkapi({'equipment_type': map_list}))

        except UserNotAuthorizedError:
            return self.not_authorized()

        except EquipamentoError:
            return self.response_error(1)

    def handle_get(self, request, user, *args, **kwargs):
        """Trata as requisições GET para consulta de HealthCheckExpects por id.

        Lista as informações de um HealthCheckExpect por id.

        URL:  /healthcheckexpect/get/<id_healthcheck_expect>/
        """
        try:
            if not has_perm(user,
                            AdminPermission.HEALTH_CHECK_EXPECT,
                            AdminPermission.READ_OPERATION):
                return self.not_authorized()

            id_healthcheck = kwargs.get('id_healthcheck')

            if not is_valid_int_greater_zero_param(id_healthcheck):
                self.log.error(
                    u'The id_healthcheck parameter is not a valid value: %s.', id_healthcheck)
                raise InvalidValueError(None, 'id_healthcheck', id_healthcheck)

            heal = HealthcheckExpect.get_by_pk(id_healthcheck)

            healthcheckexpect_map = model_to_dict(heal)

            return self.response(dumps_networkapi({'healthcheck_expect': healthcheckexpect_map}))

        except InvalidValueError, e:
            return self.response_error(269, e.param, e.value)

    def handle_post(self, request, user, *args, **kwargs):
        """Treat requests POST to create the configuration file.

        URL: rack/gerar-arq-config/id_rack
        """
        try:
            self.log.info("CONFIG")

            # User permission
            if not has_perm(user, AdminPermission.SCRIPT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
                self.log.error(u'User does not have permission to perform the operation.')
                raise UserNotAuthorizedError(None)

            rack_id = kwargs.get('id_rack')
            rack = Rack()
            rack = rack.get_by_pk(rack_id)
            var = False

            #Chama o script para gerar os arquivos de configuracao
            var = gera_config(rack)

            rack.__dict__.update(id=rack_id, config=var)
            rack.save()

            success_map = dict()
            success_map['rack_conf'] = var
            map = dict()
            map['sucesso'] = success_map
                        
            return self.response(dumps_networkapi(map))


        except RackConfigError, e:
            return self.response_error(382, e.param, e.value)

    def handle_get(self, request, user, *args, **kwargs):
        """Handles GET requests to find all Racks
        URLs: /rack/find/
        """

        self.log.info('List all Racks')

        try:

            # User permission
            if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT , AdminPermission.READ_OPERATION):
                self.log.error( u'User does not have permission to perform the operation.')

                return self.not_authorized()

            rack_list = []
            for rack in Rack.objects.all():
                rack_list.append(model_to_dict(rack))

            return self.response(dumps_networkapi({'rack': rack_list}))

        except UserNotAuthorizedError:
            return self.not_authorized()

        except RackError:
            return self.response_error(379)

    def handle_get(self, request, user, *args, **kwargs):
        """Treat requests GET to get User by the identifier.

        URL: user/get/<id_user>/
        """
        try:

            self.log.info("Get User by the identifier")

            # User permission
            if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.READ_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                raise UserNotAuthorizedError(None)

            id_user = kwargs.get('id_user')

            # Valid User ID
            if not is_valid_int_greater_zero_param(id_user):
                self.log.error(
                    u'The id_user parameter is not a valid value: %s.', id_user)
                raise InvalidValueError(None, 'id_user', id_user)

            # Find User by ID to check if it exist
            usr = Usuario.get_by_pk(id_user)

            user_map = dict()
            user_map['usuario'] = model_to_dict(usr)
            user_map['usuario']['grupos'] = user_map['usuario']['grupos'] if user_map['usuario'][
                'grupos'] is not None and len(user_map['usuario']['grupos']) > 0 else [None]

            return self.response(dumps_networkapi(user_map))

        except InvalidValueError, e:
            return self.response_error(269, e.param, e.value)

    def handle_get(self, request, user, *args, **kwargs):
        """Treat GET requests list all Filters.

        URL: filter/all/
        """

        try:

            self.log.info("List all Filters")
            # Commons Validations

            # User permission
            if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                return self.not_authorized()

            # Business Rules
            filters = Filter.objects.all()

            filter_list = []
            for filter_ in filters:
                filter_dict = model_to_dict(filter_)
                filter_dict['equip_types'] = list()

                for fil_equip_type in filter_.filterequiptype_set.all():
                    filter_dict['equip_types'].append(
                        model_to_dict(fil_equip_type.equiptype))

                filter_list.append(filter_dict)

            return self.response(dumps_networkapi({'filter': filter_list}))

        except BaseException, e:
            return self.response_error(1)

    def handle_get(self, request, user, *args, **kwargs):
        """
        Handles GET requests to list all the VIPs.

        URL: vip/all/
        """

        try:
            if not has_perm(user,
                            AdminPermission.VIPS_REQUEST,
                            AdminPermission.READ_OPERATION):
                return self.not_authorized()

            request_vips = RequisicaoVips.get_all()
            vips = {}

            for vip in request_vips:
                request_vip_map = vip.variables_to_map()
                request_vip_map['id'] = vip.id
                request_vip_map['validado'] = vip.validado
                request_vip_map['vip_criado'] = vip.vip_criado
                request_vip_map['id_ip'] = vip.ip_id
                request_vip_map['id_ipv6'] = vip.ipv6_id
                request_vip_map[
                    'id_healthcheck_expect'] = vip.healthcheck_expect_id
                vips['vip_%s' % (vip.id)] = request_vip_map

            return self.response(dumps_networkapi(vips))

        except (RequisicaoVipsNotFoundError):
            return self.response_error(152)
        except (RequisicaoVipsError, GrupoError):
            return self.response_error(1)

    def handle_get(self, request, user, *args, **kwargs):
        """Treat GET requests to get a Filter by id.

        URL: filter/get/<id_filter>/
        """

        try:

            self.log.info("Get Filter by id")
            # Commons Validations

            # User permission
            if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
                self.log.error(u"User does not have permission to perform the operation.")
                return self.not_authorized()

            if not is_valid_int_greater_zero_param(kwargs["id_filter"]):
                self.log.error(u"Parameter id_filter is invalid. Value: %s.", kwargs["id_filter"])
                raise InvalidValueError(None, "id_filter", kwargs["id_filter"])
            else:
                # Check existence
                fil = Filter().get_by_pk(kwargs["id_filter"])

            filter_dict = model_to_dict(fil)
            filter_dict["equip_types"] = list()
            for fil_equip_type in fil.filterequiptype_set.all():
                filter_dict["equip_types"].append(model_to_dict(fil_equip_type.equiptype))

            return self.response(dumps_networkapi({"filter": filter_dict}))

        except InvalidValueError, e:
            return self.response_error(269, e.param, e.value)

    def handle_get(self, request, user, *args, **kwargs):
        """Handles GET requests to find EnvironmentInterface.

        URLs: int/get-env-by-interface/<id_interface>
        """
        self.log.info('buscando os ambientes associados a uma interface')

        try:

            # User permission
            if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT , AdminPermission.READ_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                return self.not_authorized()

            # Get XML data
            interface = kwargs.get('id_interface')

            int_ambiente = EnvironmentInterface.get_by_interface(int(interface))

            ambiente_map = []

            for ids in int_ambiente:
                ambiente_map.append(self.get_environment_map(ids.ambiente))

            return self.response(dumps_networkapi({'ambiente': ambiente_map}))

        except InvalidValueError, e:
            return self.response_error(269, e.param, e.value)

    def handle_get(self, request, user, *args, **kwargs):
        """Handles GET requests to list all equipment.

        URLs: equipament/list/
        """

        try:

            # User permission
            if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                return self.not_authorized()

            equip_list = Equipamento.objects.all()

            map_dicts = []
            for equip in equip_list:
                map_dicts.append(model_to_dict(equip))

            equip_map = dict()
            equip_map['equipamentos'] = map_dicts

            # Return XML
            return self.response(dumps_networkapi(equip_map))

        except (EquipamentoError, GrupoError):
            return self.response_error(1)
        except XMLError, x:
            self.log.error(u'Error reading the XML request.')
            return self.response_error(3, x)

    def handle_get(self, request, user, *args, **kwargs):
        """Handles GET requests to find all Racks

        URLs: /rack/find/
        """

        self.log.info('Find all Racks')

        try:

            # User permission
            if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT , AdminPermission.READ_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                return self.not_authorized()

            nome = kwargs.get('rack_name')
            rack = Rack()
            rack = rack.get_by_name(nome)
            rack = model_to_dict(rack)

            return self.response(dumps_networkapi({'rack': rack}))

        except UserNotAuthorizedError:
            return self.not_authorized()

        except RackError:
            return self.response_error(379)

    def handle_post(self, request, user, *args, **kwargs):
        """Trata as requisições de POST para inserir um grupo de equipamento.

        URL: egrupo/
        """
        try:
            if not has_perm(user, AdminPermission.EQUIPMENT_GROUP_MANAGEMENT, AdminPermission.WRITE_OPERATION):
                return self.not_authorized()

            xml_map, attrs_map = loads(request.raw_post_data)
            self.log.debug('XML_MAP: %s', xml_map)

            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.')

            egroup_map = networkapi_map.get('grupo')
            if egroup_map is None:
                return self.response_error(3, u'Não existe valor para a tag grupo do XML de requisição.')

            name = egroup_map.get('nome')
            if not is_valid_string_maxsize(name, 100):
                self.log.error(u'Parameter name is invalid. Value: %s', name)
                raise InvalidValueError(None, 'name', name)

            egroup = EGrupo()
            egroup.nome = name
            egroup.create(user)

            return self.response(dumps_networkapi({'grupo': {'id': egroup.id}}))

        except InvalidValueError, e:
            return self.response_error(269, e.param, e.value)

    def handle_get(self, request, user, *args, **kwargs):
        """Treat GET requests list all Environment VIP.

        URL: environmentvip/all/
        """

        try:

            self.log.info('List all Environment VIP')

            # Commons Validations

            # User permission
            if not has_perm(user, AdminPermission.ENVIRONMENT_VIP, AdminPermission.READ_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                return self.not_authorized()

            # Business Rules

            evips = EnvironmentVip.objects.all()

            evip_list = []

            for evip in evips:
                evip_list.append(model_to_dict(evip))

            return self.response(dumps_networkapi({'environment_vip': evip_list}))

        except (EnvironmentVipError, GrupoError), e:
            self.log.error(e)
            return self.response_error(1)

    def handle_get(self, request, user, *args, **kwargs):
        try:
            self.log.info('Get rules in Environment')

            # User permission
            if not has_perm(user, AdminPermission.VIP_VALIDATION, AdminPermission.WRITE_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                raise UserNotAuthorizedError(None)

            id_env = kwargs.get('id_env')

            if not is_valid_int_greater_zero_param(id_env):
                self.log.error(
                    u'The id_env parameter is not a valid value: %s.', id_env)
                raise InvalidValueError(None, 'id_env', id_env)

            Ambiente.objects.get(pk=id_env)
            rules = Rule.objects.filter(environment=id_env, vip=None)
            rule_list = []
            for rule in rules:
                rule_list.append(model_to_dict(rule))
            return self.response(dumps_networkapi({'rules': rule_list}))

        except InvalidValueError, e:
            self.log.error(
                u'Parameter %s is invalid. Value: %s.', e.param, e.value)
            return self.response_error(269, e.param, e.value)

    def handle_get(self, request, user, *args, **kwargs):
        """Treat requests GET to get Group User.

        URL: ugroup/get/<id_ugroup>/
        """
        try:

            self.log.info("Get Group User by ID")

            id_ugroup = kwargs.get('id_ugroup')

            # User permission
            if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.READ_OPERATION):
                self.log.error(
                    u'User does not have permission to perform the operation.')
                raise UserNotAuthorizedError(None)

            # Valid Group User ID
            if not is_valid_int_greater_zero_param(id_ugroup):
                self.log.error(
                    u'The id_ugroup parameter is not a valid value: %s.', id_ugroup)
                raise InvalidValueError(None, 'id_ugroup', id_ugroup)

            # Find Group User by ID to check if it exist
            ugroup = UGrupo.get_by_pk(id_ugroup)

            ugroup_map = dict()
            ugroup_map['user_group'] = model_to_dict(ugroup)

            return self.response(dumps_networkapi(ugroup_map))

        except InvalidValueError, e:
            return self.response_error(269, e.param, e.value)

    def handle_get(self, request, user, *args, **kwargs):
        """Treat requests GET to list all .
        URL: interface/get-type/
        """
        try:

            # User permission
            if not has_perm(user, AdminPermission.ENVIRONMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
                return self.not_authorized()

            lista_tipo_interface = []

            tipos_interface = TipoInterface.objects.all()

            for tipo in tipos_interface:
                lista_tipo_interface.append(tipo)

            lists = self.get_envs(lista_tipo_interface)

            # Return XML
            interface_list = dict()
            interface_list['tipo_interface'] = lists
            return self.response(dumps_networkapi(interface_list))

        except GrupoError:
            return self.response_error(1)

        except InvalidValueError, e:
            return self.response_error(369, e.param, e.value)