HYTOS

# coding: utf-8

import os

import sys

import sqlite3

from SingletonInstance import SingletonInstance

class StreamData:

    def __init__(self, name, unit='', value='', index=0, phase='', value_min='', value_max=''):

        self.name = name

        self.unit = unit

        self.value = value

        self.index = index

        self.phase = phase

        self.value_min = value_min

        self.value_max = value_max

class HMBData:

    """HMB data class"""

    def __init__(self, uid=None):

        self._uid = uid

        self._stream_no = None

        self._from = None

        self._to = None

        self._phase = None

        self._data = []

    @property

    def data(self):

        """return hmb data"""

        return self._data

    @data.setter

    def data(self, value):

        """hmb data"""

        self._data = value

    @property

    def phase(self):

        """phase"""

        return self._phase

    @phase.setter

    def phase(self, value):

        """phase"""

        self._phase = value

    @property

    def hfrom(self):

        """from"""

        return self._from

    @hfrom.setter

    def hfrom(self, value):

        """from"""

        self._from = value

    @property

    def hto(self):

        """to"""

        return self._to

    @hto.setter

    def hto(self, value):

        """to"""

        self._to = value

    @property

    def uid(self):

        """uid"""

        return self._uid

    @uid.setter

    def uid(self, value):

        """uid"""

        self._uid = value

    @property

    def stream_no(self):

        """stream no"""

        return self._stream_no

    @stream_no.setter

    def stream_no(self, value):

        """stream no"""

        self._stream_no = value

    @staticmethod

    def from_row(rows):

        """create hmb data from database record"""

        if rows:

            pre_no = rows[0]['Stream_No']

        data_list = []

        datas = []

        for row in rows:

            if row['Stream_No'] == pre_no:

                datas.append(row)

            else:

                pre_no = row['Stream_No']

                data_list.append(datas)

                datas = [row]

        data_list.append(datas)

        hmbs = []

        for datas in data_list:

            hmb = HMBData(datas[0]['UID'])

            hmb.stream_no = datas[0]['Stream_No']

            hmb.hfrom = datas[0]['From']

            hmb.hto = datas[0]['To']

            hmb.phase = datas[0]['Phase']

            hmb_data = []

            for _data in datas:

                name = _data['Name']

                unit = _data['Unit']

                value = _data['Value']

                index = _data['index']

                phase = _data['Type']

                value_min = _data['Value_Min'] if _data['Value_Min'] else ''

                value_max = _data['Value_Max'] if _data['Value_Max'] else ''

                hmb_data.append(StreamData(name, unit, value, index, phase, value_min, value_max))

            hmb.data = hmb_data

            hmbs.append(hmb)

        return hmbs

class HMBTable:

    """HMB table class"""

    def __init__(self):

        self._hmbs = None

    def load_data(self):

        """load hmb data from database"""

        from AppDocData import AppDocData

        try:

            if self._hmbs is None:

                self._hmbs = []

                rows = AppDocData.get_hmb_data(None)

                for row in rows:

                    hmb = HMBData.from_row(row)

                    self._hmbs.append(hmb)

        # Catch the exception

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            App.mainWnd().addMessage.emit(MessageType.Error, message)

        return self._hmbs

    @property

    def names(self):

        """return hmb attribute names"""

        return set([hmb.name for hmb in self._hmbs if not hmb.isDeleted]) if self._hmbs is not None else {}

    def streamNos(self):

        """return stream no collection which are not duplicated """

        return set([hmb.stream_no for hmb in self._hmbs]) if self._hmbs is not None else {}

    def dataOfStreamNo(self, streamNo):

        """return stream data"""

        if self._hmbs is not None:

            matches = [hmb.data for hmb in self._hmbs if hmb.stream_no == streamNo]

            return matches[0] if matches else None

        else:

            return None

    '''

        @brief      append hmb data

        @author     humkyung

        @date       2018.07.12

    '''

    def append(self, hmbData):

        if self._hmbs is None:

            self._hmbs = []

        self._hmbs.append(hmbData)

    '''

        @brief      reset

        @author     humkyung

        @date       2018.07.12

    '''

    def reset(self):

        if self._hmbs is not None:

            del self._hmbs

        self._hmbs = None