MyEMS / myems

# Step 2: Create multiprocessing pool to call worker in parallel

########################################################################################################################

def calculate_hourly(logger):

    while True:

        # the outermost while loop to reconnect server if there is a connection error

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 0 of virtual_meter.calculate_hourly " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        virtual_meter_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name, equation "

                                     " FROM tbl_virtual_meters "

                                     " ORDER BY id ")

            rows_virtual_meters = cursor_system_db.fetchall()

            if rows_virtual_meters is None or len(rows_virtual_meters) == 0:

                # sleep several minutes and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_virtual_meters:

                meta_result = {"id": row[0], "name": row[1], "equation": row[2]}

                virtual_meter_list.append(meta_result)

        except Exception as e:

            logger.error("Error in step 1 of virtual meter calculate hourly " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        # shuffle the virtual meter list for randomly calculating the meter hourly value

        random.shuffle(virtual_meter_list)

        print("Got all virtual meters in MyEMS System Database")

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, virtual_meter_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep ...")

        time.sleep(60)

        print("wake from sleep, and continue to work...")

########################################################################################################################

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all stores

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of store_energy_input_item.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        store_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_stores "

                                     " ORDER BY id ")

            rows_stores = cursor_system_db.fetchall()

            if rows_stores is None or len(rows_stores) == 0:

                print("There isn't any stores ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_stores:

                store_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of store_energy_input_item.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all stores in MyEMS System Database")

        # shuffle the store list for randomly calculating the meter hourly value

        random.shuffle(store_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, store_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all tenants

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of tenant_energy_input_category.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        tenant_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_tenants "

                                     " ORDER BY id ")

            rows_tenants = cursor_system_db.fetchall()

            if rows_tenants is None or len(rows_tenants) == 0:

                print("There isn't any tenants ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_tenants:

                tenant_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of tenant_energy_input_category.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all tenants in MyEMS System Database")

        # shuffle the tenant list for randomly calculating the hourly values

        random.shuffle(tenant_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, tenant_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all equipments

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of equipment_energy_output_category.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        equipment_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_equipments "

                                     " ORDER BY id ")

            rows_equipments = cursor_system_db.fetchall()

            if rows_equipments is None or len(rows_equipments) == 0:

                print("There isn't any equipments ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_equipments:

                equipment_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of equipment_energy_output_category.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all equipments in MyEMS System Database")

        # shuffle the equipment list for randomly calculating the meter hourly value

        random.shuffle(equipment_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, equipment_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all spaces

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of space_energy_output_category.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        space_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_spaces "

                                     " ORDER BY id ")

            rows_spaces = cursor_system_db.fetchall()

            if rows_spaces is None or len(rows_spaces) == 0:

                print("There isn't any spaces ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_spaces:

                space_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of space_energy_output_category.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all spaces in MyEMS System Database")

        # shuffle the space list for randomly calculating the meter hourly value

        random.shuffle(space_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, space_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all equipments

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of equipment_energy_input_item.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        equipment_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_equipments "

                                     " ORDER BY id ")

            rows_equipments = cursor_system_db.fetchall()

            if rows_equipments is None or len(rows_equipments) == 0:

                print("There isn't any equipments ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_equipments:

                equipment_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of equipment_energy_input_item.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all equipments in MyEMS System Database")

        # shuffle the equipment list for randomly calculating the meter hourly value

        random.shuffle(equipment_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, equipment_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all spaces

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of space_energy_input_item.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        space_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_spaces "

                                     " ORDER BY id ")

            rows_spaces = cursor_system_db.fetchall()

            if rows_spaces is None or len(rows_spaces) == 0:

                print("There isn't any spaces ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_spaces:

                space_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of space_energy_input_item.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all spaces in MyEMS System Database")

        # shuffle the space list for randomly calculating the meter hourly value

        random.shuffle(space_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, space_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all equipments

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of equipment_energy_input_category.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        equipment_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_equipments "

                                     " ORDER BY id ")

            rows_equipments = cursor_system_db.fetchall()

            if rows_equipments is None or len(rows_equipments) == 0:

                print("There isn't any equipments ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_equipments:

                equipment_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of equipment_energy_input_category.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all equipments in MyEMS System Database")

        # shuffle the equipment list for randomly calculating the meter hourly value

        random.shuffle(equipment_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, equipment_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all tenants

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of tenant_energy_input_item.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        tenant_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_tenants "

                                     " ORDER BY id ")

            rows_tenants = cursor_system_db.fetchall()

            if rows_tenants is None or len(rows_tenants) == 0:

                print("There isn't any tenants ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_tenants:

                tenant_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of tenant_energy_input_item.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all tenants in MyEMS System Database")

        # shuffle the tenant list for randomly calculating the hourly values

        random.shuffle(tenant_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, tenant_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all combined equipments

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of combined_equipment_energy_input_category.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        combined_equipment_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_combined_equipments "

                                     " ORDER BY id ")

            rows_combined_equipments = cursor_system_db.fetchall()

            if rows_combined_equipments is None or len(rows_combined_equipments) == 0:

                print("There isn't any combined equipments ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_combined_equipments:

                combined_equipment_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of combined_equipment_energy_input_category.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all combined equipments in MyEMS System Database")

        # shuffle the combined equipment list for randomly calculating the meter hourly value

        random.shuffle(combined_equipment_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, combined_equipment_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all shopfloors

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of shopfloor_energy_input_item.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        shopfloor_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_shopfloors "

                                     " ORDER BY id ")

            rows_shopfloors = cursor_system_db.fetchall()

            if rows_shopfloors is None or len(rows_shopfloors) == 0:

                print("There isn't any shopfloors ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_shopfloors:

                shopfloor_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of shopfloor_energy_input_item.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all shopfloors in MyEMS System Database")

        # shuffle the shopfloor list for randomly calculating the meter hourly value

        random.shuffle(shopfloor_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, shopfloor_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all shopfloors

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of shopfloor_energy_input_category.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        shopfloor_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_shopfloors "

                                     " ORDER BY id ")

            rows_shopfloors = cursor_system_db.fetchall()

            if rows_shopfloors is None or len(rows_shopfloors) == 0:

                print("There isn't any shopfloors ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_shopfloors:

                shopfloor_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of shopfloor_energy_input_category.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all shopfloors in MyEMS System Database")

        # shuffle the shopfloor list for randomly calculating the meter hourly value

        random.shuffle(shopfloor_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, shopfloor_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all stores

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of store_energy_input_category.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        store_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_stores "

                                     " ORDER BY id ")

            rows_stores = cursor_system_db.fetchall()

            if rows_stores is None or len(rows_stores) == 0:

                print("There isn't any stores ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_stores:

                store_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of store_energy_input_category.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all stores in MyEMS System Database")

        # shuffle the store list for randomly calculating the meter hourly value

        random.shuffle(store_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, store_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all combined equipments

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of combined_equipment_energy_input_item.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        combined_equipment_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_combined_equipments "

                                     " ORDER BY id ")

            rows_combined_equipments = cursor_system_db.fetchall()

            if rows_combined_equipments is None or len(rows_combined_equipments) == 0:

                print("There isn't any combined equipments ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_combined_equipments:

                combined_equipment_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of combined_equipment_energy_input_item.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all combined equipments in MyEMS System Database")

        # shuffle the combined equipment list for randomly calculating the meter hourly value

        random.shuffle(combined_equipment_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, combined_equipment_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all spaces

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of space_energy_input_category.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        space_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_spaces "

                                     " ORDER BY id ")

            rows_spaces = cursor_system_db.fetchall()

            if rows_spaces is None or len(rows_spaces) == 0:

                print("There isn't any spaces ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_spaces:

                space_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of space_energy_input_category.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all spaces in MyEMS System Database")

        # shuffle the space list for randomly calculating the meter hourly value

        random.shuffle(space_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, space_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while

########################################################################################################################

def main(logger):

    while True:

        # the outermost while loop

        ################################################################################################################

        # Step 1: get all combined equipments

        ################################################################################################################

        cnx_system_db = None

        cursor_system_db = None

        try:

            cnx_system_db = mysql.connector.connect(**config.myems_system_db)

            cursor_system_db = cnx_system_db.cursor()

        except Exception as e:

            logger.error("Error in step 1.1 of combined_equipment_energy_output_category.main " + str(e))

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        print("Connected to MyEMS System Database")

        combined_equipment_list = list()

        try:

            cursor_system_db.execute(" SELECT id, name "

                                     " FROM tbl_combined_equipments "

                                     " ORDER BY id ")

            rows_combined_equipments = cursor_system_db.fetchall()

            if rows_combined_equipments is None or len(rows_combined_equipments) == 0:

                print("There isn't any combined equipments ")

                # sleep and continue the outer loop to reconnect the database

                time.sleep(60)

                continue

            for row in rows_combined_equipments:

                combined_equipment_list.append({"id": row[0], "name": row[1]})

        except Exception as e:

            logger.error("Error in step 1.2 of combined_equipment_energy_output_category.main " + str(e))

            # sleep and continue the outer loop to reconnect the database

            time.sleep(60)

            continue

        finally:

            if cursor_system_db:

                cursor_system_db.close()

            if cnx_system_db:

                cnx_system_db.close()

        print("Got all combined equipments in MyEMS System Database")

        # shuffle the combined equipment list for randomly calculating the meter hourly value

        random.shuffle(combined_equipment_list)

        ################################################################################################################

        # Step 2: Create multiprocessing pool to call worker in parallel

        ################################################################################################################

        p = Pool(processes=config.pool_size)

        error_list = p.map(worker, combined_equipment_list)

        p.close()

        p.join()

        for error in error_list:

            if error is not None and len(error) > 0:

                logger.error(error)

        print("go to sleep 300 seconds...")

        time.sleep(300)

        print("wake from sleep, and continue to work...")

    # end of outer while