def show(self, req, id, *args, **kwargs):
     """get one dns zone info"""
     # get the context
     context = req.context
     try:
         if kwargs.get('device'):
             LOG.info(_(" args is %(args)s"), {"args": args})
             # from rpc server get the zone in device
             zones = self.manager.get_zones(context)
         else:
             LOG.info(_(" args is %(args)s"), {"args": args})
             # from rpc server get the zone in db
             zones = self.manager.get_zone_db_details(context, id)
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tools.ret_info(e.code, e.message)
     except RemoteError as exception:
         self.response.status = 500
         message = exception.value
         return tools.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         return tools.ret_info(self.response.status, exception.message)
     return zones

 def show(self, req, id, *args, **kwargs):
     """get one dns region info"""
     # get the context
     context = req.context
     try:
         if kwargs.get('device'):
             LOG.info(_(" args is %(args)s"), {"args": args})
             # from rpc server get the region in device
             regions = self.manager.get_region(context)
         else:
             LOG.info(_(" args is %(args)s"), {"args": args})
             # from rpc server get the region in db
             regions = self.manager.get_region_db_detail(context, id)
             regions_user = self.manager.get_members(context, regions.name)
             region_users = []
             for key in regions_user:
                 region_users.append(dict(key))
             regions.region_user = region_users
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tools.ret_info(e.code, e.message)
     except RemoteError as exception:
         self.response.status = 500
         message = exception.value
         return tools.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         return tools.ret_info(self.response.status, exception.message)
     return regions

 def create(self, req, *args, **kwargs):
     """create the dns zone_record"""
     url = req.url
     try:
         if len(args) != 1:
             raise BadRequest(resource="record create", msg=url)
         list1 = ['name', 'type', 'rdata', "tenant_id"]
         list2 = ['ttl', 'current_user', "klass"]
         # get the body
         dic = json.loads(req.body)
         # validate the in values of the zone_record
         dic_body = tool.message_regrouping(dic, list1, list2)
         context = req.context
         LOG.info(_("req is %(json)s, args is %(args)s,"
                    "kwargs is %(kwargs)s"),
                  {"json": req.body, "args": args, "kwargs": kwargs})
         # from rpc server create the zone_record
         record = self.manager.create_record(context, dic_body, args[0])
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tool.ret_info(e.code, e.message)
     except MessagingException as exception:
         self.response.status = 500
         message = exception.value
         return tool.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         message = "the values of the body format error"
         return tool.ret_info(self.response.status, message)
     LOG.info(_("Return of create_zone_record JSON is %(record)s !"),
              {"record": record})
     return record

 def remove(self, req, *args, **kwargs):
     """delete the dns zone_record"""
     url = req.url
     try:
         if len(args) != 2:
             raise BadRequest(resource="record remove", msg=url)
         list_ = ['current_user']
         # get the body
         dic = json.loads(req.body)
         # validate the in values of the zone_record
         dic_body = tool.validat_parms(dic, list_)
         c = req.context
         LOG.info(_("server is %(json)s, args is %(args)s, "
                    "kwargs is %(kwargs)s"),
                  {"json": req.body, "args": args, "kwargs": kwargs})
         """from rpc server delete the zone_record"""
         record = self.manager.delete_record(c, dic_body, args[0], args[1])
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tool.ret_info(e.code, e.message)
     except MessagingException as exception:
         self.response.status = 500
         message = exception.value
         return tool.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         message = "the values of the body format error"
         return tool.ret_info(self.response.status, message)
     LOG.info(_("Return of remove_record JSON  is %(record)s !"),
              {"record": record})
     return record

 def remove(self, req, *args, **kwargs):
     """delete the dns zones"""
     # get the context
     context = req.context
     # check the in values
     valid_attributes = ['current_user']
     try:
         # get the url
         url = req.url
         if len(args) != 1:
             raise BadRequest(resource="zone delete", msg=url)
         # get the body
         values = json.loads(req.body)
         LOG.info(_("the in value body is %(body)s"), {"body": values})
         LOG.info(_("the id is %(id)s"), {"id": args[0]})
         # check the in values
         recom_msg = tools.validat_parms(values, valid_attributes)
         # from rpc server delete the zones in db and device
         zones = self.manager.delete_zone(context, recom_msg, args[0])
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tools.ret_info(e.code, e.message)
     except MessagingException as exception:
         self.response.status = 500
         message = exception.value
         return tools.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         message = "the values of the body format error"
         return tools.ret_info(self.response.status, message)
     return zones

 def list(self, req, *args, **kwargs):
     """get the list of the dns zones"""
     # get the context
     context = req.context
     try:
         if 'device' in args:
             LOG.info(_(" args is %(args)s, kwargs is %(kwargs)s"),
                      {"args": args, "kwargs": kwargs})
             # from rpc server get the zones in device
             zones = self.manager.get_zones(context)
         else:
             LOG.info(_(" args is %(args)s, kwargs is %(kwargs)s"),
                      {"args": args, "kwargs": kwargs})
             # from rpc server get the zones in db
             zones = self.manager.get_all_db_zone(context)
             LOG.info(_("Return of get_all_db_zone JSON is %(zones)s !"),
                      {"zones": zones})
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tools.ret_info(e.code, e.message)
     except MessagingException as exception:
         self.response.status = 500
         message = exception.value
         return tools.ret_info(self.response.status, message)
     LOG.info(_("Return of get_zones json is %(zones)s"), {"zones": zones})
     return zones

 def remove(self, req, id, *args, **kwargs):
     """delete the dns zone_record"""
     url = req.url
     try:
         # if len(args) != 1:
         #     raise BadRequest(resource="record remove", msg=url)
         dic = {}
         dic.update(kwargs)
         list_ = ["tenant_id", "id"]
         dic['id'] = id
         dic_body = self.validat_parms(dic, list_)
         # get the body
         # validate the in values of the zone_record
         c = req.context
         LOG.info(_("server is %(json)s, args is %(args)s, "
                    "kwargs is %(kwargs)s"),
                  {"json": req.body, "args": args, "kwargs": kwargs})
         """from rpc server delete the zone_record"""
         record = self.manager.delete_record(c, dic_body)
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tool.ret_info(e.code, e.message)
     except RemoteError as exception:
         self.response.status = 500
         message = exception.value
         return tool.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         return tool.ret_info(self.response.status, exception.message)
     LOG.info(_("Return of remove_record JSON  is %(record)s !"),
              {"record": record})
     return record

 def get(self, req, *args, **kwargs):
     """
     # get info for one or more
     :param req:
     :param args:
     :param kwargs:
     :return:
     """
     context = req.context
     try:
         LOG.info(
             _("args is %(args)s,kwargs is %(kwargs)s"), {
                 'args': args, "kwargs": kwargs})
         syngroup = self.manager.get_syngroups(context)
         LOG.info(_("Retrun of get_all_db_zone JSON is %(syngroup)s !"),
                  {"syngroup": syngroup})
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tools.ret_info(e.code, e.message)
     except RemoteError as e:
         self.response.status = 500
         message = e.value
         return tools.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         return tools.ret_info(self.response.status, exception.message)
     return syngroup

 def list(self, req, *args, **kwargs):
     """get the list of the dns members"""
     # get the context
     context = req.context
     try:
         # get the body
         values = {}
         values.update(kwargs)
         LOG.info(_(" args is %(args)s, kwargs is %(kwargs)s"),
                  {"args": args, "kwargs": kwargs})
         # check the in values
         valid_attributes = ['tenant_id']
         recom_msg = self.validat_parms(values, valid_attributes)
         # from db server get the get_members in db
         members = self.manager.get_db_members(context, recom_msg)
         LOG.info(_("Return get_members JSON is %(members)s !"),
                  {"members": members})
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tools.ret_info(e.code, e.message)
     except RemoteError as exception:
         self.response.status = 500
         message = exception.value
         return tools.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         return tools.ret_info(self.response.status, exception.message)
     return members

 def update(self, req, id, *args, **kwargs):
     """update the dns hm template"""
     try:
         LOG.info(_("update hm template:body is %(json)s, args is %(args)s,"
                    "kwargs is %(kwargs)s"),
                  {"json": req.body, "args": args, "kwargs": kwargs})
         url = req.url
         # if len(args) != 1:
         #     raise BadRequest(resource="hm template update", msg=url)
         dic = json.loads(req.body)
         dic['id'] = id
         c = req.context
         if not tool.is_not_nil(dic['id']):
             raise ParamNull(param_name="id")
         response = self.manager.update_hm_template(c, dic, dic['id'])
         LOG.info(_("Return of update hm template JSON  is %(response)s !"),
                  {"response": response})
         return response
     except Nca47Exception as e:
         LOG.error(_LE('Exception Message: %s !' % (e.message)))
         LOG.exception(e)
         self.response.status = e.code
         return tool.ret_info(e.code, e.message)
     except RemoteError as e:
         LOG.error(_LE('Exception Message: %s !' % (e.message)))
         LOG.exception(e)
         self.response.status = 500
         message = e.value
         return tool.ret_info(self.response.status, message)
     except Exception as e:
         LOG.error(_LE('Exception Message: %s !' % (e.message)))
         LOG.exception(e)
         self.response.status = 500
         return tool.ret_info(self.response.status, e.message)

 def create(self, req, *args, **kwargs):
     """create the dns hm_template"""
     try:
         LOG.info(_("create hm_template:body is %(json)s, args is %(args)s,"
                    "kwargs is %(kwargs)s"),
                  {"json": req.body, "args": args, "kwargs": kwargs})
         url = req.url
         # if len(args) != 0:
         #     raise BadRequest(resource="hm_template create", msg=url)
         array1 = ["tenant_id", "name", "types"]
         array2 = ["check_interval", "timeout", "max_retries"]
         # get the body
         dic = json.loads(req.body)
         dic_body = self.message_regrouping(dic, array1, array2)
         context = req.context
         response = self.manager.create_hm_template(context, dic_body)
         LOG.info(_("Return of Created hm_template Json is %(response)s !"),
         {"response": response})
         return response
     except Nca47Exception as e:
         LOG.error(_LE('Exception Message: %s !' % (e.message)))
         LOG.exception(e)
         self.response.status = e.code
         return tool.ret_info(e.code, e.message)
     except RemoteError as e:
         LOG.error(_LE('Exception Message: %s !' % (e.message)))
         LOG.exception(e)
         self.response.status = 500
         return tool.ret_info(self.response.status, e.value)
     except Exception as e:
         LOG.error(_LE('Exception Message: %s !' % (e.message)))
         LOG.exception(e)
         self.response.status = 500
         return tool.ret_info(self.response.status, e.message)

 def show(self, req, id, *args, **kwargs):
     """get one of the dns hm template"""
     try:
         LOG.info(_("get a hm template: args is %(args)s, "
                    "kwargs is %(kwargs)s"),
                  {"args": args, "kwargs": kwargs})
         url = req.url
         # if len(args) != 1:
         #     raise BadRequest(resource="hm template query one ", msg=url)
         context = req.context
         response = self.manager.get_one_hm_template_db(context, id)
         LOG.info(_("Return of hm template JSON  is %(response)s !"),
                  {"response": response})
         return response
     except Nca47Exception as e:
         LOG.error(_LE('Exception Message: %s !' % (e.message)))
         LOG.exception(e)
         self.response.status = e.code
         return tool.ret_info(e.code, e.message)
     except RemoteError as e:
         LOG.error(_LE('Exception Message: %s !' % (e.message)))
         LOG.exception(e)
         self.response.status = 500
         message = e.value
         return tool.ret_info(self.response.status, message)
     except Exception as e:
         LOG.error(_LE('Exception Message: %s !' % (e.message)))
         LOG.exception(e)
         self.response.status = 500
         return tool.ret_info(self.response.status, e.message)

    def clean_cache(self, *args, **kwargs):
        list_ = ['owners', 'domain_name', 'view_name']
        req = pecan.request
        context = req.context
        try:
            # get the body
            values = json.loads(req.body)

            LOG.info(_("req is %(json)s, args is %(args)s,"
                       " kwargs is %(kwargs)s"),
                     {"json": req.body, "args": args, "kwargs": kwargs})
            self.validat_parms(values, list_)
            caches = self.manager.del_cache(context, values)
            LOG.info(_("Return of delete cache JSON is %(zones)s !"),
                     {"zones": caches})
        except Nca47Exception as e:
            self.response.status = e.code
            LOG.error(_LE('Error exception! error info: %' + e.message))
            LOG.exception(e)
            return tool.ret_info(e.code, e.message)
        except RemoteError as exception:
            self.response.status = 500
            message = exception.value
            return tools.ret_info(self.response.status, message)
        except Exception as exception:
            LOG.exception(exception)
            self.response.status = 500
            return tools.ret_info(self.response.status, exception.message)
        return caches

 def update(self, req, id, *args, **kwargs):
     """update the dns zone_record"""
     url = req.url
     try:
         # if len(args) != 1:
         #     raise BadRequest(resource="record update", msg=url)
         dic = json.loads(req.body)
         dic['id'] = id
         list_ = ["tenant_id", "id"]
         if "ttl" not in dic.keys() and "rdata" not in dic.keys():
             raise ParamIsNotHaveError(param_name="rdata or ttl")
         if "ttl" in dic.keys():
             if tool.check_ttl(dic['ttl']):
                 list_.append("ttl")
             else:
                 raise ParamFormatError(param_name="ttl")
         if "rdata" in dic.keys():
             if tool.check_rdata(dic['rdata']):
                 list_.append("rdata")
             else:
                 raise ParamFormatError(param_name="rdata")
         if len(list_) == 0:
             raise ParamValueError(param_name="JSON")
         # get the body
         # validate the in values of the zone_record
         dic_body = self.validat_parms(dic, list_)
         c = req.context
         LOG.info(_("req is %(json)s, args is %(args)s, "
                    "kwargs is %(kwargs)s"),
                  {"json": req.body, "args": args, "kwargs": kwargs})
         # from rpc server update the zone_record
         record = self.manager.update_record(c, dic_body)
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tool.ret_info(e.code, e.message)
     except RemoteError as exception:
         self.response.status = 500
         message = exception.value
         return tool.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         return tool.ret_info(self.response.status, exception.message)
     LOG.info(_("Return of update_record JSON  is %(record)s !"),
              {"record": record})
     return record

 def update(self, req, id, *args, **kwargs):
     """
     update GPool method
     :param req:
     :param args:
     :param kwargs:
     :return:
     """
     context = req.context
     try:
         values = json.loads(req.body)
         values['id'] = id
         url = req.url
         self.check_update(values)
         # recom_msg = self.validat_update(values, valid_attrbutes)
         LOG.info(_('the in value body is %(body)s'), {'body': values})
         gpools = self.manager.update_gpool(context, values)
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE("Error exception ! error info:%" + e.message))
         LOG.exception(e)
         return tools.ret_info(self.response.status, e.message)
     except RemoteError as e:
         self.response.status = 500
         message = e.value
         return tools.ret_info(self.response.status, e.message)
     except Exception as e:
         LOG.exception(e)
         self.response.status = 500
         return tools.ret_info(self.response.status, e.message)
     return gpools

 def show(self, req, *args, **kwargs):
     """get the one addrobj"""
     url = req.url
     try:
         # get the right url
         if len(args) != 1:
             raise BadRequest(resource="addrobj operation", msg=url)
         # get the body
         json_body = req.body
         # get the context
         context = req.context
         values = json.loads(json_body)
         # check the in values
         valid_attributes = ['id']
         # check the in values
         recom_msg = self.validat_values(values, valid_attributes)
         LOG.info(_("the in value body is %(body)s"), {"body": values})
         # from rpc server get the addrobj in db and device
         addrobj = self.manager.get_addrobj(context, recom_msg)
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tools.ret_info(e.code, e.message)
     except MessagingException as exception:
         self.response.status = 500
         message = exception.value
         return tools.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         message = "the values of the body format error"
         return tools.ret_info(self.response.status, message)
     return addrobj

 def validate_filters(cls, **kwargs):
     bad_filters = [key for key in kwargs
                    if key not in cls.fields or key in cls.synthetic_fields]
     if bad_filters:
         bad_filters = ', '.join(bad_filters)
         msg = _("'%s' is not supported for filtering") % bad_filters
         raise exception.Invalid(error_message=msg)

 def create(self, req, *args, **kwargs):
     """
     Create syngorup method
     :param req:
     :param args:
     :param kwargs:
     :return:
     """
     context = req.context
     try:
         values = json.loads(req.body)
         url = req.url
         valid_attributes = [
             "tenant_id",
             "name",
         ]
         self.check_create(valid_attributes, values)
         LOG.info(_('the in value body is %(body)s'), {'body': values})
         syngroups = self.manager.create_syngroup(context, values)
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE("Error exception ! error info:%" + e.message))
         LOG.exception(e)
         return tools.ret_info(self.response.status, e.message)
     except RemoteError as e:
         self.response.status = 500
         message = e.value
         return tools.ret_info(self.response.status, message)
     except Exception as e:
         LOG.exception(e)
         self.response.status = 500
         return tools.ret_info(self.response.status, e.message)
     return syngroups

 def update(self, req, id, *args, **kwargs):
     """
     update Syngroup method
     :param req:
     :param args:
     :param kwargs:
     :return:
     """
     context = req.context
     try:
         url = req.url
         values = json.loads(req.body)
         values['id'] = id
         LOG.info(_("the in value body if %(body)s"), {'body': values})
         self.check_update(values)
         syngroups = self.manager.update_syngroup(
             context, values)
         # args[0] is id
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE("Error exception! error info: %" + e.message))
         LOG.exception(e)
         return tools.ret_info(e.code, e.message)
     except RemoteError as exception:
         self.reponse.status = 500
         message = exception.value
         return tools.ret_info(self.reponse.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         return tools.ret_info(self.response.status, exception.message)
     return syngroups

 def show(self, req, id, *args, **kwargs):
     """
     get syngroup by id
     :param req:
     :param id:
     :param args:
     :param kwargs:
     :return: return http response
     """
     context = req.context
     try:
         LOG.info(_("args is %(args)s"), {"args": args})
         syngroup = self.manager.get_syngroup(context, id)
     except Nca47Exception as e:
         self.response.status = e.code
         LOG.error(_LE('Error exception! error info: %' + e.message))
         LOG.exception(e)
         return tools.ret_info(e.code, e.message)
     except RemoteError as exception:
         self.response.status = 500
         message = exception.value
         return tools.ret_info(self.response.status, message)
     except Exception as exception:
         LOG.exception(exception)
         self.response.status = 500
         return tools.ret_info(self.response.status, exception.message)
     return syngroup