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='', case=''):

        self.name = name

        self.unit = unit

        self.value = value

        self.index = index

        self.phase = phase

        self.case = case

class HMBData:

    """HMB data class"""

    def __init__(self, uid=None):

        self._uid = uid

        self._stream_no = None

        self._from = None

        self._to = None

        self._datas = []

    @property

    def datas(self):

        """return hmb data"""

        return self._datas

    @datas.setter

    def datas(self, value):

        """hmb data"""

        self._datas = 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']

        else:

            return []

        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']

            cases = {}

            for _data in datas:

                case = _data['Case']

                if case not in cases:

                    cases[case] = [_data]

                else:

                    cases[case].append(_data)

            hmb_datas = []

            keys = sorted(list(cases.keys()))

            for key in keys:

                hmb_data = []

                _datas = cases[key]

                for _data in _datas:

                    name = _data['Name']

                    unit = _data['Unit']

                    value = _data['Value']

                    index = _data['index']

                    phase = _data['Type']

                    case = _data['Case']

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

                hmb_datas.append(hmb_data)

            hmb.datas = hmb_datas

            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.instance().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

"""