all

WorkData/Argus/experience.py

+# -*- coding: utf_8 -*-
+# 表名: experience
+# 作者: 陈磊
+# 时间: 2019-11-18
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class Experience(Base):
+    """
+    经验手册
+    """
+    __tablename__ = "experience"
+
+    experienceid = Column(BigInteger, primary_key=True)
+    title = Column(VARCHAR(255), comment="标题")
+    content = Column(TEXT, comment="内容")
+    businessid = Column(VARCHAR(32), comment="业务Id")
+    business_name = Column(VARCHAR(255), comment="业务名称")
+    host_type = Column(Integer, comment="资产类型（和下面hostid对应的资产不一定对应）")
+    hostid = Column(BigInteger, comment="资产Id")
+    versions = Column(Integer, comment="版本号")
+    monitorid = Column(BigInteger, comment="监控Id")
+    monitor_name = Column(VARCHAR(255), comment="监控名称")
+    description = Column(VARCHAR(255), comment="告警描述")
+    eventid = Column(BigInteger, comment="对应problem")
+
+
+class DataExperience(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = Experience
+
+    def select_all_from_allKeys(self, session, experienceid=None, title=None, description=None):
+        """
+        :param session: 指针
+        :param experienceid:
+        :param title:
+        :param description:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="experienceid", value=experienceid)
+            base.add_param(_key="title", value=title)
+            base.add_param(_key="description", value=description)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error
+
+    def delete_like_title(self, session, title):
+        """
+        :param session: 指针
+        :param title:
+        :return:
+        """
+        self.log.debug("查询数据库:")
+        try:
+            self.log.debug("删除相关测试数据")
+            session.query(self.table).filter(self.table.title.like(str(title) + "%")).delete(synchronize_session=False)
+            # session.delete(sql)
+            session.commit()
+            session.close()
+            self.log.debug("删除成功")
+            return True
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error
+
+    def insert_one(self, session, title=None, content=None, businessid=None, business_name=None, host_type=None,
+                   hostid=None, versions=None, monitorid=None, monitor_name=None, description=None, eventid=None):
+        """
+        :param session: 指针
+        :param title:
+        :param content:
+        :param businessid:
+        :param business_name:
+        :param host_type:
+        :param hostid:
+        :param versions:
+        :param monitorid:
+        :param monitor_name:
+        :param description:
+        :param eventid:
+        :return:
+        """
+        self.log.debug("新增表数据:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="title", value=title)
+            base.add_param(_key="content", value=content)
+            base.add_param(_key="businessid", value=businessid)
+            base.add_param(_key="business_name", value=business_name)
+            base.add_param(_key="host_type", value=host_type)
+            base.add_param(_key="hostid", value=hostid)
+            base.add_param(_key="versions", value=versions)
+            base.add_param(_key="monitorid", value=monitorid)
+            base.add_param(_key="monitor_name", value=monitor_name)
+            base.add_param(_key="description", value=description)
+            base.add_param(_key="eventid", value=eventid)
+            sql_rep = self.table(**base.param)
+
+            session.add(sql_rep)
+            session.commit()
+            hostid = sql_rep.hostid
+            self.log.debug("新增的hostid:%s" % hostid)
+            session.close()
+            return hostid
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Argus/hosts.py

+# -*- coding: utf_8 -*-
+# 表名: hosts
+# 作者: 陈磊
+# 时间: 2019-11-15
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class Hosts(Base):
+    """
+    主机信息表
+    """
+    __tablename__ = "hosts"
+
+    hostid = Column(Integer, primary_key=True)
+    host_name = Column(VARCHAR(128), comment="主机名")
+    asset_code = Column(VARCHAR(128), comment="资产编号")
+    manage_ip = Column(VARCHAR(32), comment="管理IP")
+    departmentid = Column(Integer, comment="资产部门")
+    manage_level = Column(Integer, comment="资产管理等级")
+    host_type = Column(Integer, comment="主机类型")
+    parent_host = Column(VARCHAR(128), comment="所属主机")
+    available = Column(Integer, comment="可用性")
+    monitor_status = Column(Integer, comment="监控状态")
+    iplist = Column(VARCHAR(255), comment="IP列表 分号隔开")
+    monitor_interface = Column(VARCHAR(255), comment="监控接口 分号隔开")
+
+
+class DataHosts(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = Hosts
+
+    def select_all_from_allKeys(self, session, hostid=None, host_name=None, available=None, monitor_status=None):
+        """
+        :param session: 指针
+        :param hostid:
+        :param host_name:
+        :param available:
+        :param monitor_status:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="hostid", value=hostid)
+            base.add_param(_key="host_name", value=host_name)
+            base.add_param(_key="available", value=available)
+            base.add_param(_key="monitor_status", value=monitor_status)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error
+
+    def delete_like_host_name(self, session, host_name):
+        """
+        :param session: 指针
+        :param host_name:
+        :return:
+        """
+        self.log.debug("查询数据库:")
+        try:
+            self.log.debug("删除相关测试数据")
+            session.query(self.table).filter(self.table.host_name.like(str(host_name) + "%")).delete(synchronize_session=False)
+            # session.delete(sql)
+            session.commit()
+            session.close()
+            self.log.debug("删除成功")
+            return True
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error
+
+    def insert_one(self, session, host_name=None, asset_code=None, manage_ip=None, departmentid=None, manage_level=None,
+                   host_type=None, parent_host=None, available=None, monitor_status=None, iplist=None, monitor_interface=None):
+        """
+        :param session: 指针
+        :param host_name:
+        :param asset_code:
+        :param manage_ip:
+        :param departmentid:
+        :param manage_level:
+        :param host_type:
+        :param parent_host:
+        :param available:
+        :param monitor_status:
+        :param iplist:
+        :param monitor_interface:
+        :return:
+        """
+        self.log.debug("新增表数据:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="host_name", value=host_name)
+            base.add_param(_key="asset_code", value=asset_code)
+            base.add_param(_key="manage_ip", value=manage_ip)
+            base.add_param(_key="departmentid", value=departmentid)
+            base.add_param(_key="manage_level", value=manage_level)
+            base.add_param(_key="host_type", value=host_type)
+            base.add_param(_key="parent_host", value=parent_host)
+            base.add_param(_key="available", value=available)
+            base.add_param(_key="monitor_status", value=monitor_status)
+            base.add_param(_key="iplist", value=iplist)
+            base.add_param(_key="monitor_interface", value=monitor_interface)
+            sql_rep = self.table(**base.param)
+
+            session.add(sql_rep)
+            session.commit()
+            hostid = sql_rep.hostid
+            self.log.debug("新增的hostid:%s" % hostid)
+            session.close()
+            return hostid
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/DataTest.py

+# -*- coding: utf-8 -*-
+# 数据库测试
+# 作者: 陈磊
+# 时间: 2019-10-21
+
+
+from WorkData.Argus.hosts import DataHosts
+
+
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+
+# url = "192.168.1.180"
+# port = 3306
+# user = "root"
+# password = "root"
+
+url = "10.0.0.155"
+port = 3306
+user = "root"
+password = "123456"
+
+base = "argus"
+# base = "mmt-after"
+s = UtilsDataBase().conn_mysql(db_url=url, db_port=port, db_user=user, db_pw=password, db_base=base)
+
+DataHosts().insert_one(session=s, host_name="测试", )
+# for x, y in enumerate(r):
+#     print(y.name)
+
+
+
+
+# DataCustomerWxData().insert_one(
+#     session=s, customer_id=115216, _type=1, appid="test", openid="1"
+# )
+# for x in range(1, 51):
+#
+#     print(x)
+#     DataUserInfo().insert_one(session=s, _id=b+str(base_phone+x), name="cl测试"+str(x), _type="1", mobile=base_phone+x, agent_no="MMTCl"+str(base_phone+x),
+#                               up_user_id="00003ace77a84250ab8ef19600010002", up_up_user_id="1464ae4e42c14a4786d5cffa2cb1c73b")
+
+# DataUserInfo().insert_one(session=s, _id=str(b)+str(base_phone), name="下级代理2", _type="2", mobile=base_phone, agent_no="MMTCL"+str(base_phone),
+#                           up_user_id="00003ace77a84250ab8ef19600010001", up_up_user_id="1c5230248b9e4c3f8c006cee401980a1")
+# r = DataUserInfo().select_one_from_phone(session=s, mobile=15151969022)
+# print(r.id)
+
+# DataAfterComplain().select_group_by(session=s)
\ No newline at end of file

WorkData/Zabbix/group_prototype.py

+# -*- coding: utf_8 -*-
+# 表名: group_prototype
+# 作者: 陈磊
+# 时间: 2019-11-13
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, BIGINT, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class GroupPrototype(Base):
+    """
+    组原型关系表
+    """
+    __tablename__ = "group_prototype"
+
+    group_prototypeid = Column(BigInteger, primary_key=True)
+    hostid = Column(BigInteger)
+    name = Column(VARCHAR(255))
+    groupid = Column(BigInteger)
+    templateid = Column(BigInteger)
+
+
+class DataGroupPrototype(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = GroupPrototype
+
+    def select_all_from_allKeys(self, session, hostid=None, name=None):
+        """
+        :param session: 指针
+        :param hostid:
+        :param name:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="hostid", value=hostid)
+            base.add_param(_key="name", value=name)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Zabbix/host_discovery.py

+# -*- coding: utf_8 -*-
+# 表名: host_discovery
+# 作者: 陈磊
+# 时间: 2019-11-13
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, BIGINT, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class HostDiscovery(Base):
+    """
+    主机发现表
+    """
+    __tablename__ = "host_discovery"
+
+    hostid = Column(BigInteger, primary_key=True)
+    parent_hostid = Column(BigInteger)
+    parent_itemid = Column(BigInteger)
+    host = Column(VARCHAR(64))
+    lastcheck = Column(Integer)
+    ts_delete = Column(Integer)
+
+
+class DataHostDiscovery(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = HostDiscovery
+
+    def select_all_from_allKeys(self, session, hostid=None, parent_itemid=None):
+        """
+        :param session: 指针
+        :param hostid:
+        :param parent_itemid:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="hostid", value=hostid)
+            base.add_param(_key="parent_itemid", value=parent_itemid)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Zabbix/hosts.py

+# -*- coding: utf_8 -*-
+# 表名: hosts
+# 作者: 陈磊
+# 时间: 2019-11-13
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class Hosts(Base):
+    """
+    主机信息表
+    """
+    __tablename__ = "hosts"
+
+    hostid = Column(BigInteger, primary_key=True)
+    proxy_hostid = Column(BigInteger)
+    host = Column(VARCHAR(128))
+    status = Column(Integer)
+    disable_until = Column(Integer)
+    error = Column(VARCHAR(2048))
+    available = Column(Integer)
+    errors_from = Column(Integer)
+    lastaccess = Column(Integer)
+    ipmi_authtype = Column(Integer)
+    ipmi_privilege = Column(Integer)
+    ipmi_username = Column(VARCHAR(16))
+    ipmi_password = Column(VARCHAR(20))
+    ipmi_disable_until = Column(Integer)
+    ipmi_available = Column(Integer)
+    snmp_disable_until = Column(Integer)
+    snmp_available = Column(Integer)
+    maintenanceid = Column(BigInteger)
+    maintenance_status = Column(Integer)
+    maintenance_type = Column(Integer)
+    maintenance_from = Column(Integer)
+    ipmi_errors_from = Column(Integer)
+    snmp_errors_from = Column(Integer)
+    ipmi_error = Column(VARCHAR(2048))
+    snmp_error = Column(VARCHAR(2048))
+    jmx_disable_until = Column(Integer)
+    jmx_available = Column(Integer)
+    jmx_errors_from = Column(Integer)
+    jmx_error = Column(VARCHAR(2048))
+    name = Column(VARCHAR(128))
+    flags = Column(Integer)
+    templateid = Column(BigInteger)
+    description = Column(TEXT)
+    tls_connect = Column(Integer)
+    tls_accept = Column(Integer)
+    tls_issuer = Column(VARCHAR(1024))
+    tls_subject = Column(VARCHAR(1024))
+    tls_psk_identity = Column(VARCHAR(128))
+    tls_psk = Column(VARCHAR(512))
+    proxy_address = Column(VARCHAR(255))
+    auto_compress = Column(Integer)
+
+
+class DataHosts(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = Hosts
+
+    def select_all_from_allKeys(self, session, hostid=None, host=None, name=None):
+        """
+        :param session: 指针
+        :param hostid:
+        :param host:
+        :param name:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="hostid", value=hostid)
+            base.add_param(_key="host", value=host)
+            base.add_param(_key="name", value=name)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error
+
+    def delete_name(self, session, name):
+        """
+        :param session: 指针
+        :param name:
+        :return:
+        """
+        self.log.debug("查询数据库:")
+        try:
+            self.log.debug("删除相关测试数据")
+            session.query(self.table).filter_by(name=name).delete(synchronize_session=False)
+            # session.delete(sql)
+            session.commit()
+            session.close()
+            self.log.debug("删除成功")
+            return True
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Zabbix/hosts_groups.py

+# -*- coding: utf_8 -*-
+# 表名: hosts_groups
+# 作者: 陈磊
+# 时间: 2019-11-15
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, BIGINT, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class HostsGroups(Base):
+    """
+    主机组与主机关系表
+    """
+    __tablename__ = "hosts_groups"
+
+    hostgroupid = Column(BigInteger, primary_key=True)
+    hostid = Column(BigInteger)
+    groupid = Column(BigInteger)
+
+
+class DataHostsGroups(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = HostsGroups
+
+    def select_all_from_allKeys(self, session, hostid=None, groupid=None):
+        """
+        :param session: 指针
+        :param hostid:
+        :param groupid:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="hostid", value=hostid)
+            base.add_param(_key="groupid", value=groupid)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Zabbix/hstgrp.py

+# -*- coding: utf_8 -*-
+# 表名: hstgrp
+# 作者: 陈磊
+# 时间: 2019-11-04
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, BIGINT, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class HstGrp(Base):
+    """
+    主机组信息表
+    """
+    __tablename__ = "hstgrp"
+
+    groupid = Column(BigInteger, primary_key=True)
+    name = Column(VARCHAR(255))
+    internal = Column(Integer)
+    flags = Column(Integer)
+
+
+class DataHstGrp(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = HstGrp
+
+    def select_all_from_allKeys(self, session, groupid=None, name=None, internal=None, flags=None):
+        """
+        :param session: 指针
+        :param groupid:
+        :param name:
+        :param internal:
+        :param flags:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="groupid", value=groupid)
+            base.add_param(_key="name", value=name)
+            base.add_param(_key="internal", value=internal)
+            base.add_param(_key="flags", value=flags)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error
+
+    def delete_like_name(self, session, name):
+        """
+        :param session: 指针
+        :param name:
+        :return:
+        """
+        self.log.debug("查询数据库:")
+        try:
+            self.log.debug("删除相关测试数据")
+            session.query(self.table).filter(self.table.name.like(str(name) + "%")).delete(synchronize_session=False)
+            # session.delete(sql)
+            session.commit()
+            session.close()
+            self.log.debug("删除成功")
+            return True
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Zabbix/interface.py

+# -*- coding: utf_8 -*-
+# 表名: interface
+# 作者: 陈磊
+# 时间: 2019-11-11
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, BIGINT, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class Interface(Base):
+    """
+    主机接口信息表
+    """
+    __tablename__ = "interface"
+
+    interfaceid = Column(Integer, primary_key=True)
+    hostid = Column(Integer)
+    main = Column(Integer)
+    type = Column(Integer)
+    useip = Column(Integer)
+    ip = Column(VARCHAR(64))
+    dns = Column(VARCHAR(255))
+    port = Column(VARCHAR(64))
+    bulk = Column(Integer)
+
+
+class DataInterface(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = Interface
+
+    def select_all_from_allKeys(self, session, interfaceid=None, hostid=None, ip=None, port=None):
+        """
+        :param session: 指针
+        :param interfaceid:
+        :param hostid:
+        :param ip:
+        :param port:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="interfaceid", value=interfaceid)
+            base.add_param(_key="hostid", value=hostid)
+            base.add_param(_key="ip", value=ip)
+            base.add_param(_key="port", value=port)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error
+
+    def delete_hostid(self, session, hostid):
+        """
+        :param session: 指针
+        :param hostid:
+        :return:
+        """
+        self.log.debug("查询数据库:")
+        try:
+            self.log.debug("删除相关测试数据")
+            session.query(self.table).filter_by(hostid=hostid).delete(synchronize_session=False)
+            # session.delete(sql)
+            session.commit()
+            session.close()
+            self.log.debug("删除成功")
+            return True
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Zabbix/problem.py

+# -*- coding: utf_8 -*-
+# 表名: problem
+# 作者: 陈磊
+# 时间: 2019-11-14
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, BIGINT, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class Problem(Base):
+    """
+    告警信息表
+    """
+    __tablename__ = "problem"
+
+    eventid = Column(BigInteger, primary_key=True)
+    source = Column(Integer)
+    object = Column(Integer)
+    objectid = Column(BigInteger)
+    clock = Column(Integer)
+    ns = Column(Integer)
+    r_eventid = Column(BigInteger)
+    r_clock = Column(Integer)
+    r_ns = Column(Integer)
+    correlationid = Column(BigInteger)
+    userid = Column(BigInteger)
+    name = Column(VARCHAR(2048))
+    acknowledged = Column(Integer)
+    severity = Column(Integer)
+
+
+class DataProblem(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = Problem
+
+    def select_all_from_allKeys(self, session, eventid=None, source=None, severity=None):
+        """
+        :param session: 指针
+        :param eventid:
+        :param source:
+        :param severity:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="eventid", value=eventid)
+            base.add_param(_key="source", value=source)
+            base.add_param(_key="severity", value=severity)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error
+
+    def delete_like_name(self, session, name):
+        """
+        :param session: 指针
+        :param name:
+        :return:
+        """
+        self.log.debug("查询数据库:")
+        try:
+            self.log.debug("删除相关测试数据")
+            session.query(self.table).filter(self.table.name.like(str(name) + "%")).delete(synchronize_session=False)
+            # session.delete(sql)
+            session.commit()
+            session.close()
+            self.log.debug("删除成功")
+            return True
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Zabbix/scripts.py

+# -*- coding: utf_8 -*-
+# 表名: scripts
+# 作者: 陈磊
+# 时间: 2019-11-06
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, BIGINT, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class Scripts(Base):
+    """
+    脚本信息表
+    """
+    __tablename__ = "scripts"
+
+    scriptid = Column(Integer, primary_key=True)
+    name = Column(VARCHAR(255))
+    command = Column(VARCHAR(255))
+    host_access = Column(Integer)
+    usrgrpid = Column(Integer)
+    groupid = Column(Integer)
+    description = Column(TEXT)
+    confirmation = Column(VARCHAR(255))
+    type = Column(Integer)
+    execute_on = Column(Integer)
+
+
+class DataScripts(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = Scripts
+
+    def select_all_from_allKeys(self, session, scriptid=None, name=None, command=None, host_access=None, usrgrpid=None, groupid=None,
+                                description=None, confirmation=None, _type=None, execute_on=None):
+        """
+        :param session: 指针
+        :param scriptid:
+        :param name:
+        :param command:
+        :param host_access:
+        :param usrgrpid:
+        :param groupid:
+        :param description:
+        :param confirmation:
+        :param _type:
+        :param execute_on:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="scriptid", value=scriptid)
+            base.add_param(_key="name", value=name)
+            base.add_param(_key="command", value=command)
+            base.add_param(_key="host_access", value=host_access)
+            base.add_param(_key="usrgrpid", value=usrgrpid)
+            base.add_param(_key="groupid", value=groupid)
+            base.add_param(_key="description", value=description)
+            base.add_param(_key="confirmation", value=confirmation)
+            base.add_param(_key="type", value=_type)
+            base.add_param(_key="execute_on", value=execute_on)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Zabbix/trigger_tag.py

+# -*- coding: utf_8 -*-
+# 表名: trigger_tag
+# 作者: 陈磊
+# 时间: 2019-11-13
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, BIGINT, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class TriggerTag(Base):
+    """
+    触发器标签关系表
+    """
+    __tablename__ = "trigger_tag"
+
+    triggertagid = Column(BigInteger, primary_key=True)
+    triggerid = Column(BigInteger)
+    tag = Column(VARCHAR(255))
+    value = Column(VARCHAR(255))
+
+
+class DataTriggerTag(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = TriggerTag
+
+    def select_all_from_allKeys(self, session, triggerid=None):
+        """
+        :param session: 指针
+        :param triggerid:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="triggerid", value=triggerid)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error

WorkData/Zabbix/triggers.py

+# -*- coding: utf_8 -*-
+# 表名: triggers
+# 作者: 陈磊
+# 时间: 2019-11-13
+
+
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy import Column, Integer, VARCHAR, SMALLINT, DATETIME, DECIMAL, BigInteger, FLOAT, NUMERIC, TEXT
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+from sqlalchemy import or_
+
+from WorkUtils.UtilsLog import UtilsLog
+from WorkUtils.UtilsDataBase import UtilsDataBase
+
+import time
+
+Base = declarative_base()
+
+
+class Triggers(Base):
+    """
+    触发器信息表
+    """
+    __tablename__ = "triggers"
+
+    triggerid = Column(BigInteger, primary_key=True)
+    expression = Column(VARCHAR(2048))
+    description = Column(VARCHAR(255))
+    url = Column(VARCHAR(255))
+    status = Column(Integer)
+    value = Column(Integer)
+    priority = Column(Integer)
+    comments = Column(TEXT)
+    error = Column(VARCHAR(2048))
+    templateid = Column(BigInteger)
+    type = Column(Integer)
+    state = Column(Integer)
+    flags = Column(Integer)
+    recovery_mode = Column(Integer)
+    recovery_expression = Column(VARCHAR(2048))
+    correlation_mode = Column(Integer)
+    correlation_tag = Column(VARCHAR(255))
+    manual_close = Column(Integer)
+    details = Column(VARCHAR(255))
+
+
+class DataTriggers(object):
+    def __init__(self):
+        self.log = UtilsLog()
+        self.log.info(self.__class__)
+
+        self.table = Triggers
+
+    def select_all_from_allKeys(self, session, triggerid=None, description=None):
+        """
+        :param session: 指针
+        :param triggerid:
+        :param description:
+        :return: 查询结果
+        """
+        self.log.debug("查询数据库:")
+        try:
+            base = UtilsDataBase()
+            base.add_param(_key="triggerid", value=triggerid)
+            base.add_param(_key="description", value=description)
+            sql_rep = session.query(self.table).filter_by(**base.param).all()
+            self.log.debug(sql_rep)
+            session.close()
+            return sql_rep
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error
+
+    def delete_description(self, session, description):
+        """
+        :param session: 指针
+        :param description:
+        :return:
+        """
+        self.log.debug("查询数据库:")
+        try:
+            self.log.debug("删除相关测试数据")
+            session.query(self.table).filter_by(description=description).delete(synchronize_session=False)
+            # session.delete(sql)
+            session.commit()
+            session.close()
+            self.log.debug("删除成功")
+            return True
+        except UtilsDataBase().errors as error:
+            self.log.error("异常:")
+            self.log.error(error)
+            session.close()
+            return error