ibms-dome/Repository/BackendRepository/Implement/NiagaraDataSynchronizeRepository.cs

using Dapper;
using Repository.BackendRepository.Interface;
using Repository.Helper;
using System;
using System.Text;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
using System.Transactions;
using Repository.Models;
using System.Data.SqlTypes;
using Microsoft.Extensions.Primitives;
using System.Web;
using Org.BouncyCastle.Utilities.Collections;
using System.Reflection;

namespace Repository.BackendRepository.Implement
{
    public class NiagaraDataSynchronizeRepository : BackendRepository, INiagaraDataSynchronizeRepository
    {
        public NiagaraDataSynchronizeRepository(IDatabaseHelper databaseHelper) : base(databaseHelper)
        {
        }

        /// <summary>
        /// 更新import_niagara_tag資料表
        /// </summary>
        /// <param name="ds"></param>
        /// <param name="building"></param> 
        /// <returns></returns>
        public async Task InsertNiagaraTagList(List<Device_value> ds, List<string> building, string tag_quantity)
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    StringBuilder sb = new StringBuilder();
                    try
                    {
                        foreach(var b in building)
                        {
                            string sql = @"CREATE TABLE IF NOT EXISTS `import_niagara_tag` (
                                     `id` int(11) NOT NULL AUTO_INCREMENT,
                                     `db_tags` varchar(50) DEFAULT NULL,
                                     `niagara_tags` varchar(50) DEFAULT NULL,
                                     `device_area_tag` varchar(50) DEFAULT NULL,
                                     `device_building_tag` varchar(50) DEFAULT NULL,
                                     `device_system_tag` varchar(50) DEFAULT NULL,
                                     `device_name_tag` varchar(50) DEFAULT NULL,
                                     `device_floor_tag` varchar(50) DEFAULT NULL,
                                     `device_master_tag` varchar(50) DEFAULT NULL,
                                     `device_last_name_tag` varchar(50) DEFAULT NULL,
                                     `device_serial_tag` varchar(50) DEFAULT NULL,
                                     `atDateTime` datetime(1) DEFAULT NULL,
                                     `device_full_name` varchar(100) DEFAULT NULL,
                                     `is_used` smallint(1) DEFAULT 0,
                                     PRIMARY KEY (`id`)
                                   ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;";
                            await conn.ExecuteAsync(sql);
                            sql = "delete from import_niagara_tag where device_building_tag = '" + b + "' limit 10000";
                            await conn.ExecuteAsync(sql);
                        }

                        //N4資料groupBy後放入import_niagara_tag資料表
                        var ds2 = ds.GroupBy(x => new
                        {
                            tag_name2 = x.tag_name,
                            displayName2 = x.displayName
                        }).Select(x => new Device_value
                        {
                            tag_name = x.Key.tag_name2,
                            displayName = x.Key.displayName2
                        }); 
                       
                        // StringBuilder sb = new StringBuilder();
                        bool isDome = false; //是否為巨蛋案
                        int count  = 0;
                        foreach (var row in ds2)
                        {
                            if (string.IsNullOrEmpty(row.tag_name)) continue;
                            string[] arrTag = row.tag_name.Split('_');

                            if (int.Parse(tag_quantity) == 8)
                            {
                                if (arrTag.Length == 8)
                                {
                                    sb.Append($@" insert into import_niagara_tag(niagara_tags, device_area_tag, device_building_tag, device_system_tag,
                                    device_name_tag, device_floor_tag, device_master_tag, device_last_name_tag, device_serial_tag, device_full_name, atDateTime) values('" +
                                        row.tag_name + "', '" +   //niagara_tags
                                        arrTag[0] + "', '" +  //device_area_tag
                                        arrTag[1] + "', '" +  //device_building_tag
                                        arrTag[2] + "', '" +  //device_system_tag
                                        arrTag[3] + "', '" +  //device_name_tag
                                        arrTag[4] + "', '" +  //device_floor_tag
                                        arrTag[5] + "', '" +  //device_master_tag
                                        arrTag[6] + "', '" +  //device_last_name_tag
                                        arrTag[7] + "', '" +  //device_serial_tag
                                        row.displayName + "', " + //device_full_name
                                        "now());"); //atDateTime
                                }
                            }
                            else
                            {
                                if (arrTag.Length == 5)
                                {
                                    isDome= true;
                                    sb.Append($@" insert into import_niagara_tag(niagara_tags, device_area_tag, device_building_tag, device_system_tag,
                                                device_name_tag, device_floor_tag, device_master_tag, device_last_name_tag, device_serial_tag, device_full_name, atDateTime) values('" +
                                        row.tag_name + "', '" +   //niagara_tags
                                        "', '" +  //device_area_tag
                                        arrTag[0] + "', '" +  //device_building_tag
                                        arrTag[1] + "', '" +  //device_system_tag  巨蛋沒有大類，後面再用關聯的方式補上
                                        arrTag[3] + "', '" +  //device_name_tag
                                        arrTag[2] + "', '" +  //device_floor_tag
                                        "', '" +  //device_master_tag
                                        "', '" +  //device_last_name_tag
                                        arrTag[4] + "', '" +  //device_serial_tag
                                        row.displayName + "', " + //device_full_name
                                        "now());"); //atDateTime
                                    //await conn.ExecuteAsync(sb.ToString());
                                    //sb.Clear();
                                    count += 1;
                                    if (count >= 100)
                                    {
                                        count = 0;
                                        await conn.ExecuteAsync(sb.ToString());
                                        sb.Clear();
                                    }
                                }
                            }
                        }
                        if (sb.Length > 0)
                        {
                            var temp = sb.ToString();
                            await conn.ExecuteAsync(temp);
                            sb.Clear();

                            //巨蛋特殊處理
                            if (isDome)
                            {
                                sb.Append($@" -- tag 第二碼為小類(除了安全系統之外)
                                    update import_niagara_tag set device_name_tag = device_system_tag
                                    where (device_system_tag <> 'S' and device_system_tag <> 'CWB');  

                                    update import_niagara_tag a join dic_system b 
				                                    on a.device_name_tag COLLATE utf8mb4_general_ci = b.s2_code
                                    set device_system_tag = b.s1_code -- tag 第二碼為小類(除了安全系統之外)
                                    where (device_system_tag <> 'S' and device_system_tag <> 'CWB');  -- 安全系統 第二段大類 第四段小類");
                                await conn.ExecuteAsync(sb.ToString());
                            }
                        }
                    }
                    catch (Exception exception)
                    {
                        Console.WriteLine(sb.ToString());
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }
        
        /// <summary>
        /// 獲取照明開關 是否在 device_node 層
        /// </summary>
        /// <returns></returns>
        public async Task<string> getLightSwitchLevel()
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open(); 
                var sql = "select system_value from variable where system_type = 'module_light_switch' ";
                var module_light_switch = conn.QueryAsync<string>(sql).Result.FirstOrDefault(); 
                conn.Close();
                return module_light_switch;
            }
        }

        /// <summary>
        /// 更新import_niagara_tag資料表
        /// </summary>
        /// <param name="ds"></param>
        /// <param name="building"></param>
      
        /// <returns></returns>
        public async Task InsertItemFromNiagara(List<ImpNiaItem> ds, List<string> building)
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        #region 刪除 import_niagara_item資料表中選取的棟別
                        foreach(var b in building)
                        {
                            string sql = @"CREATE TABLE IF NOT EXISTS `import_niagara_item` (
                                  `id` int(11) NOT NULL AUTO_INCREMENT,
                                  `device_area_tag` varchar(50) DEFAULT NULL,
                                  `device_building_tag` varchar(50) DEFAULT NULL,
                                  `device_system_tag` varchar(50) DEFAULT NULL,
                                  `device_name_tag` varchar(50) DEFAULT NULL,
                                  `device_point_name` varchar(50) DEFAULT NULL,
                                  `check_status` varchar(50) DEFAULT NULL,
                                  `parent_path` varchar(50) DEFAULT NULL,
                                  `full_name` varchar(50) DEFAULT NULL,
                                  PRIMARY KEY (`id`)
                                ) ENGINE=InnoDB AUTO_INCREMENT=59 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;";
                            await conn.ExecuteAsync(sql);
                            sql = "delete from import_niagara_item where device_building_tag = '" + b + "' limit 10000;";
                            await conn.ExecuteAsync(sql);
                        }
                        #endregion
                        ds = ds.GroupBy(x => new {
                            device_area_tag = x.device_area_tag,
                            device_building_tag = x.device_building_tag,
                            device_system_tag = x.device_system_tag,
                            device_name_tag = x.device_name_tag,
                            device_point_name = x.device_point_name,
                            full_name = x.full_name,
                            parent_path = x.parent_path,
                            isHistory = x.isHistory
                        })
                        .Select(x => new ImpNiaItem
                        {
                            device_area_tag = x.Key.device_area_tag,
                            device_building_tag = x.Key.device_building_tag,
                            device_system_tag = x.Key.device_system_tag,
                            device_name_tag = x.Key.device_name_tag,
                            device_point_name = x.Key.device_point_name,
                            full_name = x.Key.full_name,
                            parent_path = x.Key.parent_path,
                            isHistory = x.Key.isHistory
                        }).ToList();

                        StringBuilder sb = new StringBuilder();
                        #region 放入import_niagara_item資料表
                        foreach (var row in ds)
                        {
                            sb.Append($@" insert import_niagara_item(device_area_tag, device_building_tag, device_system_tag, device_name_tag, device_point_name, parent_path, full_name, is_history)
                                        values('"+
                                            row.device_area_tag + "', '" +
                                            row.device_building_tag + "', '" +
                                            row.device_system_tag + "', '" +
                                            row.device_name_tag + "', '" +
                                            row.device_point_name + "', '" +
                                            row.parent_path + "', '" +
                                            row.full_name + "'," +
                                            row.isHistory +
                                            ");");
                        }

                        var isDome = await GetOneAsync<string>("select system_value from variable where deleted = 0 and system_type = 'project_name';");
                        if (sb.Length > 0)
                        {
                            if (isDome.Contains("ibms_dome"))
                            {
                                sb.Append($@" update import_niagara_item a join dic_system b 
				                                    on a.device_name_tag COLLATE utf8mb4_0900_ai_ci = b.s2_code COLLATE utf8mb4_0900_ai_ci
                                            set device_system_tag = b.s1_code 
                                            where (device_system_tag <> 'S' and device_system_tag <> 'CWB');");
                            }

                            sb.Append($@" update import_niagara_item set full_name = device_point_name where full_name = '' or full_name is null;");
                            await conn.ExecuteAsync(sb.ToString());
                            sb.Clear();
                        }
                        #endregion
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }
        /// <summary>
        /// 比對 device
        /// </summary>
        /// <returns></returns>
        public async Task DeviceComparison(string LightSwitchLevel)
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope((TransactionScopeOption)TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        List<NiagaraTags> result;
                        StringBuilder sb = new StringBuilder();
                        StringBuilder sb2 = new StringBuilder();
                        sb.Append($@"SELECT m.*
                                    FROM import_niagara_tag m
                                    WHERE NOT EXISTS (
                                        SELECT 1
                                        FROM device d
                                        WHERE m.niagara_tags = d.device_number
                                    );");
                        result = (await conn.QueryAsync<NiagaraTags>(sb.ToString())).ToList<NiagaraTags>();

                        sb.Clear();
                        #region device, device_kind 新增
                        //新增至device, is_link = 1
                        if (result.Count > 0)
                        {
                            var result2 = result.GroupBy(x => new
                            {
                                device_building_tag2 = x.device_building_tag,
                                device_system_tag2 = x.device_system_tag,
                                device_name_tag2 = x.device_name_tag
                            }).Select(x => new Device_item8
                            {
                                device_building_tag = x.Key.device_building_tag2,
                                device_system_tag = x.Key.device_system_tag2,
                                device_name_tag = x.Key.device_name_tag2
                            });

                            foreach (var data in result)
                            {
                                //開關控制在個別燈具(device_node層) and 小類為二線式照明系統 and tag第八段開頭不是 G
                                if (LightSwitchLevel == "node" && data.device_name_tag == "L1" && data.device_serial_tag.Substring(0, 1) != "G")
                                {
                                    // 燈具新增 device_node
                                    continue;
                                }
                                else { 
                                     sb.Append($@" insert device(device_guid, deleted, status, priority, is_link, device_area_tag, 
                                        device_building_tag, device_system_tag, device_name_tag, full_name, device_floor_tag, device_master, 
                                        device_last_name, device_serial_tag, device_number, device_system_category_layer3, visible, created_at, updated_at)
                                     values(uuid(), 0, 1, 0, 1, '" +
                                            data.device_area_tag + "', '" +
                                            data.device_building_tag + "', '" +
                                            data.device_system_tag + "', '" +
                                            data.device_name_tag + "', '" +
                                            data.device_full_name + "', '" + 
                                            data.device_floor_tag + "', '" +
                                            data.device_master_tag + "', '" +
                                            data.device_last_name_tag + "', '" +
                                            data.device_serial_tag + "', '" +
                                            data.niagara_tags + "', '" +
                                            data.device_system_tag + "', 1, now(), now() );");
                                }                               
                            }

                            foreach (var data in result2)
                            {
                                var sqlString = new StringBuilder();
                                sqlString.Append("select * from device_kind where device_building_tag = '" + data.device_building_tag + "' and device_system_tag = '" + data.device_system_tag + "' and device_name_tag = '" + data.device_name_tag + "'");
                                var dk = (await conn.QueryAsync<device_kind>(sqlString.ToString())).ToList<device_kind>();

                                if (dk.Count == 0)
                                {
                                    sb2.Append($@"INSERT device_kind (device_kind_guid, device_building_tag, device_system_tag, device_name_tag, 
                                        device_normal_flashing, device_close_flashing, device_error_flashing, device_error_independent, 
                                        created_by, created_at)
                                        VALUES (uuid(), '" + data.device_building_tag + "', '" + data.device_system_tag + "', '" + data.device_name_tag +
                                                "', 0, 0, 1, 0, 'B43E3CA7-96DD-4FC7-B6E6-974ACC3B0878', now());");
                                }
                            }

                            if (sb.Length > 0)
                            {
                                await conn.ExecuteAsync(sb.ToString()); 
                                await conn.ExecuteAsync(sb2.ToString()); 

                                sb.Clear();
                                sb2.Clear();
                            }
                        }
                        #endregion

                        #region device_node 新增 
                        sb.Append($@" SELECT m.*
                                        FROM import_niagara_tag m
                                        WHERE NOT EXISTS (
                                            SELECT 1
                                            FROM device_node d
                                            WHERE m.niagara_tags COLLATE utf8mb4_0900_ai_ci = d.device_number COLLATE utf8mb4_0900_ai_ci
                                        );");
                        result = (await conn.QueryAsync<NiagaraTags>(sb.ToString())).ToList<NiagaraTags>();
                        sb.Clear();

                        if (result.Count > 0)
                        {
                            var result2 = result.GroupBy(x => new
                            {
                                device_building_tag2 = x.device_building_tag,
                                device_system_tag2 = x.device_system_tag,
                                device_name_tag2 = x.device_name_tag
                            }).Select(x => new Device_item8
                            {
                                device_building_tag = x.Key.device_building_tag2,
                                device_system_tag = x.Key.device_system_tag2,
                                device_name_tag = x.Key.device_name_tag2
                            });

                            foreach (var data in result)
                            {
                                //開關控制在個別燈具(device_node層) and 小類為二線式照明系統 and tag第八段開頭不是 G
                                if (LightSwitchLevel == "node" && data.device_name_tag == "L1" && data.device_serial_tag.Substring(0, 1) != "G")
                                {
                                    // 燈具新增 device_node
                                    sb.Append($@"INSERT INTO  device_node(device_node_guid, deleted, device_guid, device_number, full_name, created_by, created_at, updated_at) 
                                        VALUES (uuid(), 0, '' " + //device_guid 父層需要 forge 那邊提供
                                         ",'" + data.niagara_tags + // device_number
                                        "', '" + data.device_full_name + //full_name
                                        "','B43E3CA7-96DD-4FC7-B6E6-974ACC3B0878', now(), now());");
                                }
                            }

                            if (sb.Length > 0)
                            {
                                await conn.ExecuteAsync(sb.ToString()); 
                                sb.Clear(); 
                            }
                        }
                        #endregion

                        //device有，niagara沒有，is_link 更新成 0
                        sb.Append($@" SET SQL_SAFE_UPDATES = 0;
                            UPDATE device d
                            left JOIN (
		                            SELECT niagara_tags
		                            FROM import_niagara_tag
		                            LIMIT 100000
                            ) i ON d.device_number COLLATE utf8mb4_0900_ai_ci = i.niagara_tags COLLATE utf8mb4_0900_ai_ci
                            SET d.is_link = 0
                            WHERE d.is_link = 1 and i.niagara_tags is null;");
                        await conn.ExecuteAsync(sb.ToString());

                        sb.Clear();

                        // device_node 有, niagara沒有, is_link 更新成 0
                        sb.Append($@" SET SQL_SAFE_UPDATES = 0;
                                UPDATE device_node dn
                                left JOIN (
                                    SELECT niagara_tags
                                    FROM import_niagara_tag
                                    LIMIT 100000
                                ) i ON dn.device_number COLLATE utf8mb4_0900_ai_ci = i.niagara_tags COLLATE utf8mb4_0900_ai_ci
                                SET dn.is_link = 0 
                                WHERE dn.is_link = 1 and i.niagara_tags is null;");
                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

        /// <summary>
        /// 比對 device_item
        /// </summary>
        /// <returns></returns>
        public async Task DeviceItemComparison()
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        List<NiagaraTagsForItem> result;
                        StringBuilder sb = new StringBuilder();
                        sb.Append($@" SELECT m.*
                              FROM import_niagara_item m
                              LEFT JOIN device_item d
                              ON m.device_system_tag = d.device_system_tag and m.device_name_tag = d.device_name_tag and m.device_point_name = d.points and m.device_building_tag collate utf8mb4_0900_ai_ci = d.device_building_tag
                              WHERE d.points IS NULL;");
                        result = (await conn.QueryAsync<NiagaraTagsForItem>(sb.ToString())).ToList<NiagaraTagsForItem>();
                        
                        sb.Clear();
                        # region 新增至device, is_link = 1
                        if (result.Count > 0)
                        {
                            foreach (var data in result)
                            {
                                var isControll = 0;
                                var isBool = 0;
                                if (data.device_point_name == "ER" || data.device_point_name == "AL" || data.device_point_name == "ST")
                                {
                                    isControll = 1;
                                }
                                if (data.device_point_name == "ER" || data.device_point_name == "ST")
                                {
                                    isBool = 1;
                                }
                                sb.Append($@"insert device_item(deleted, points, is_show, is_show_riserDiagram, is_controll, is_bool, is_show_history, is_link, 
                                    device_system_tag, device_name_tag, device_building_tag, full_name, parent_path, created_at, updated_at)
                                    VALUES (0, '" +
                                            data.device_point_name + "', 1, 0, " +
                                            isControll + "," +
                                            isBool + "," +
                                            data.is_history +
                                            ", 1, '" +
                                            data.device_system_tag + "', '" +
                                            data.device_name_tag + "', '" +
                                            data.device_building_tag + "', '" +
                                            data.full_name + "', '" +
                                            data.parent_path + "', " +
                                            "now(), now());");
                            }
                            if (sb.Length > 0)
                            {
                                await conn.ExecuteAsync(sb.ToString());
                                sb.Clear();
                            }
                        }
                        #endregion



                        //device有，niagara沒有，is_link 更新成 0
                        //sb.Append($@" SET SQL_SAFE_UPDATES = 0;
                        //      UPDATE device_item d LEFT JOIN import_niagara_item m 
                        //      ON d.device_system_tag = m.device_system_tag and d.device_name_tag = m.device_name_tag and d.points = m.device_point_name
                        //      SET d.is_link = 0, d.is_show_history = 0
                        //      WHERE m.device_point_name IS NULL");
                        
                        //本次有匯入的 isLink 改為 1, 沒有的 isLink = 0
                        sb.Append($@" SET SQL_SAFE_UPDATES = 0;
                                update
                                    device_item d 
                                    LEFT JOIN import_niagara_item m 
                                    ON d.device_system_tag = m.device_system_tag
                                     and d.device_name_tag = m.device_name_tag 
                                     and d.points = m.device_point_name 
                                     and d.full_name = m.full_name 
                                    SET d.is_link = case when device_point_name is null then 0 else 1 end;

                                update 
                                device_item d 
                                LEFT JOIN import_niagara_item m 
                                ON d.device_system_tag = m.device_system_tag
                                 and d.device_name_tag = m.device_name_tag 
                                 and d.points = m.device_point_name 
                                 and d.full_name = m.full_name 
                                 and d.is_show_history = m.is_history
	                                SET d.is_show_history = case when device_point_name is null then 0 else 1 end
                                where (m.is_history = 1 or d.is_show_history);
                                ");

                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

        /// <summary>
        /// 新增資料至 buildingMenu
        /// </summary>
        /// <returns></returns>
        public async Task InsertBuildingMenu()
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        List<NiagaraTags> result;
                        StringBuilder sb = new StringBuilder();
                        #region comparison building_menu and import_niagara_tag
                        sb.Append($@" select a.* from (
                              	select  device_building_tag, device_system_tag, device_name_tag
                              	from import_niagara_tag
                              	group by device_building_tag, device_system_tag, device_name_tag 
                              ) AS a
                              LEFT JOIN building_menu b
                              ON a.device_building_tag COLLATE utf8mb4_0900_ai_ci = b.device_building_tag COLLATE utf8mb4_0900_ai_ci and 
                                a.device_system_tag COLLATE utf8mb4_0900_ai_ci = b.device_system_tag COLLATE utf8mb4_0900_ai_ci and 
                                a.device_name_tag COLLATE utf8mb4_0900_ai_ci = b.sub_system_tag COLLATE utf8mb4_0900_ai_ci
                              WHERE b.device_building_tag IS NULL");
                        result = (await conn.QueryAsync<NiagaraTags>(sb.ToString())).ToList<NiagaraTags>();
                        #endregion
                        sb.Clear();

                        if (result.Count > 0)
                        {
                            foreach (var data in result)
                            {
                                StringBuilder sqlString = new StringBuilder();
                                sqlString.Append(@"select * from building_menu where building_tag = '" + data.device_building_tag + "' and main_system_tag = '" + data.device_system_tag + "' and sub_system_tag = '" + data.device_name_tag + "'");
                                var bm = (await conn.QueryAsync<building_menu>(sqlString.ToString())).ToList<building_menu>();

                                #region insert building_menu
                                if (bm.Count == 0)
                                {
                                    sb.Append(@$"insert building_menu(building_tag, main_system_tag, sub_system_tag, device_building_tag, device_system_tag,
                                  left_drawing, left_icon_click, left_icon_click_url_width, left_icon_click_url_height, left_planimetric_click,
                                  is_link, created_by, created_at, updated_by, updated_at)
                                  values('{data.device_building_tag}', '{data.device_system_tag}', '{data.device_name_tag}', '{data.device_building_tag}', '{data.device_system_tag}',
                                            4, 1, 0, 0, 1,                                            
                                            1, 'B43E3CA7-96DD-4FC7-B6E6-974ACC3B0878', now(), 'B43E3CA7-96DD-4FC7-B6E6-974ACC3B0878', now());");
                                }
                                #endregion
                            }
                            if (sb.Length > 0)
                            {
                                await conn.ExecuteAsync(sb.ToString());
                                sb.Clear();
                            }
                        }
                        //building_menu有，import_niagara_tag沒有，is_link 更新成 0
                        sb.Append($@" SET SQL_SAFE_UPDATES = 0;
                              UPDATE building_menu b LEFT JOIN (
                              	select  device_building_tag, device_system_tag, device_name_tag
                              	from import_niagara_tag
                              	group by device_building_tag, device_system_tag, device_name_tag
                              ) AS a ON b.building_tag COLLATE utf8mb4_0900_ai_ci = a.device_building_tag COLLATE utf8mb4_0900_ai_ci
                              and a.device_system_tag COLLATE utf8mb4_0900_ai_ci = b.main_system_tag COLLATE utf8mb4_0900_ai_ci and a.device_name_tag COLLATE utf8mb4_0900_ai_ci = b.sub_system_tag COLLATE utf8mb4_0900_ai_ci
                              SET b.is_link = 0
                              WHERE b.building_tag IS NULL");
                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

        /// <summary>
        /// 新增資料至 subSystemFloor
        /// </summary>
        /// <returns></returns>
        public async Task InsertSubSystemFloor()
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        List<NiagaraTags> result;
                        StringBuilder sb = new StringBuilder();
                        #region comparison sub_system_floor and import_niagara_tag
                        sb.Append($@" select a.* from (
                              	select  device_building_tag, device_system_tag, device_name_tag, device_floor_tag
                              	from import_niagara_tag
                              	group by device_building_tag, device_system_tag, device_name_tag, device_floor_tag
                              ) AS a
                              LEFT JOIN sub_system_floor b
                              ON a.device_building_tag COLLATE utf8mb4_0900_ai_ci = b.building_tag COLLATE utf8mb4_0900_ai_ci and 
                                    a.device_system_tag COLLATE utf8mb4_0900_ai_ci = b.main_system_tag COLLATE utf8mb4_0900_ai_ci and 
                                    a.device_name_tag COLLATE utf8mb4_0900_ai_ci = b.sub_system_tag COLLATE utf8mb4_0900_ai_ci and 
                                    a.device_floor_tag COLLATE utf8mb4_0900_ai_ci = b.floor_tag COLLATE utf8mb4_0900_ai_ci
                              WHERE b.building_tag IS NULL");
                        result = (await conn.QueryAsync<NiagaraTags>(sb.ToString())).ToList<NiagaraTags>();
                        #endregion

                        sb.Clear();
                        if (result.Count > 0)
                        {
                            foreach (var data in result)
                            {
                                #region insert building_menu
                                sb.Append(@"insert sub_system_floor(building_tag, main_system_tag, sub_system_tag, floor_tag,  
                                    is_link, created_by, created_at, updated_by, updated_at)
                                    VALUES ('" +
                                            data.device_building_tag + "', '" +
                                            data.device_system_tag + "', '" +
                                            data.device_name_tag + "', '" +
                                            data.device_floor_tag + "', " +
                                            "1, 'B43E3CA7-96DD-4FC7-B6E6-974ACC3B0878', now(), 'B43E3CA7-96DD-4FC7-B6E6-974ACC3B0878', now());");
                                #endregion
                            }
                            if (sb.Length > 0)
                            {
                                await conn.ExecuteAsync(sb.ToString());
                                sb.Clear();
                            }
                        }
                        //building_menu有，import_niagara_tag沒有，is_link 更新成 0
                        sb.Append($@" SET SQL_SAFE_UPDATES = 0;
                              UPDATE sub_system_floor b LEFT JOIN (
                              	select  device_building_tag, device_system_tag, device_name_tag, device_floor_tag
                              	from import_niagara_tag
                              	group by device_building_tag, device_system_tag, device_name_tag, device_floor_tag
                              ) AS a ON b.building_tag COLLATE utf8mb4_0900_ai_ci = a.device_building_tag COLLATE utf8mb4_0900_ai_ci
                              and b.main_system_tag COLLATE utf8mb4_0900_ai_ci = a.device_system_tag COLLATE utf8mb4_0900_ai_ci 
                                and b.sub_system_tag COLLATE utf8mb4_0900_ai_ci = a.device_name_tag COLLATE utf8mb4_0900_ai_ci 
                                and b.floor_tag COLLATE utf8mb4_0900_ai_ci = a.device_floor_tag COLLATE utf8mb4_0900_ai_ci
                              SET b.is_link = 0
                              WHERE b.building_tag IS NULL");
                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {  
                        conn.Close();
                    }
                }
            }
        }
        /// <summary>
        /// 檢查device內FullName為空的值，以device_Name取代
        /// </summary>
        /// <returns></returns>
        public async Task CheckFullNameEmptyReplaceByDeviceName()
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        StringBuilder sb = new StringBuilder();
                        sb.Append("update device set full_name=device_number where full_Name='';");
                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

        /// <summary>
        /// 檢查device_item內FullName為空的值，以points取代
        /// </summary>
        /// <returns></returns>
        public async Task ItemCheckFullNameEmptyReplaceByDeviceName()
        {

            //檢查是否有空值
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        StringBuilder sb = new StringBuilder();
                        sb.Append("update device_item set full_name = points where full_Name = '''''';");
                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }

            }
        }

        /// <summary>
        /// 檢查device的full_name與niagara device_full_name不同者 覆蓋
        /// </summary>
        /// <returns></returns>
        public async Task CheckDiffFullNameAndCover()
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope((TransactionScopeOption)TransactionScopeAsyncFlowOption.Enabled, new TimeSpan (0, 0, 200)))
                {
                    try
                    {
                        StringBuilder sb = new StringBuilder();
                        sb.Append(@"SET SQL_SAFE_UPDATES = 0;
                                    update device d
                                    JOIN ( 
	                                    select niagara_tags, device_full_name from import_niagara_tag limit 100000
                                    ) m ON m.niagara_tags  = d.device_number 
                                    LEFT JOIN (
		                                    SELECT niagara_tags, device_full_name
		                                    FROM import_niagara_tag
		                                    LIMIT 100000
                                    ) m2 ON m2.niagara_tags = d.device_number AND m2.device_full_name = d.full_name
                                    SET d.full_name = m.device_full_name
                                    WHERE m2.niagara_tags IS NULL;");
                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }

            }
        }


        /// <summary>
        /// 比對 device_item full_name 與 import_niagara_item full_name是否相同
        /// 不同則覆蓋
        /// </summary>
        /// <returns></returns>
        public async Task CheckItemDiffFullNameAndCover()
        {
            //檢查
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        StringBuilder sb = new StringBuilder();
                        sb.Append($@"update device_item d  
                            inner JOIN import_niagara_item m ON  
                                        m.device_system_tag = d.device_system_tag and 
                                        m.device_name_tag = d.device_name_tag and 
                                        m.device_point_name = d.points 
                            set d.full_name=m.full_name  
                            where d.full_name<>m.full_name;");
                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

        /// <summary>
        /// 先將device_item 的is_show_history全部關掉
        /// 根據niagara輸入資料來決定要開哪些點
        /// </summary>
        /// <returns></returns>
        public async Task CheckItemIsShowHistory()
        {
            //先將所有is_show_history關閉,niagara有的才開啟
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        StringBuilder sb = new StringBuilder();
                        //先全部關閉
                        //sb.Append("update device_item set is_show_history=0;");
                        sb.Append("update device_item set is_show_history = 0 " +
                            "WHERE(device_system_tag, device_name_tag, points, full_name, is_show_history) NOT IN " +
                            "(select  distinct  device_system_tag, device_name_tag, device_point_name, full_name, is_history From import_niagara_item where is_history = 1);");
                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

        public async Task DeviceDisasterAysnc(List<Device_value_disaster> dv)
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                StringBuilder sb = new StringBuilder();
                List<DeviceDisasterOutput> deviceDisaster = new List<DeviceDisasterOutput>();
                List<DeviceDisasterOutput> device = new List<DeviceDisasterOutput>();
                using (TransactionScope scope = new TransactionScope((TransactionScopeOption)TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        sb.Append("select * from device_disaster;");
                        deviceDisaster = (await conn.QueryAsync<DeviceDisasterOutput>(sb.ToString())).ToList();
                        sb.Clear();
                        sb.Append("select * from device where deleted = 0;");
                        device = (await conn.QueryAsync<DeviceDisasterOutput>(sb.ToString())).ToList();
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }

                dv = dv.Where(x => device.Any(d => d.device_number == x.value.Split('/')[6])).ToList();
                sb.Clear();
                var updateList = dv.Where(x => deviceDisaster.Any(dd => dd.device_number == x.value.Split('/')[6] && dd.device_system_value != x.disasterValue)).ToList();
                foreach (var d in updateList)
                {
                    string device_number = d.value.Split('/')[6];
                    sb.Append($"update device_disaster set device_system_value = '{d.disasterValue}' where device_number = '{device_number}'; ");
                }

                var insertList = dv.Where(x => !deviceDisaster.Any(dd => dd.device_number == x.value.Split('/')[6])).ToList();
                foreach (var d in insertList)
                {
                    string device_number = d.value.Split('/')[6];
                    string device_guid = device.Where(x => x.device_number == device_number).Select(x => x.device_guid).FirstOrDefault();
                    string device_system_tag = device.Where(x => x.device_number == device_number).Select(x => x.device_system_tag).FirstOrDefault();
                    string device_name_tag = device.Where(x => x.device_number == device_number).Select(x => x.device_name_tag).FirstOrDefault();
                    sb.Append($@"
                                insert into device_disaster 
                                (device_guid, device_system_value, device_building_tag, device_system_tag, device_name_tag, device_floor_tag, device_serial_tag, device_number)
                                values ('{device_guid}', '{d.disasterValue}', '{device_number.Split('_')[0]}', '{device_system_tag}', '{device_name_tag}', '{device_number.Split('_')[2]}',
                                '{device_number.Split('_')[4]}', '{device_number}'); ");
                }

                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        if (!string.IsNullOrEmpty(sb.ToString()))
                            await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception ex)
                    {
                        throw ex;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

        /// <summary>
        /// InsertFloor
        /// </summary>
        /// <returns></returns>
        public async Task InsertFloor()
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        List<NiagaraTags> result;
                        StringBuilder sb = new StringBuilder();
                        #region comparison floor and sub_system_floor
                        sb.Append($@" select tag.*
                                        from (
	                                        select  device_building_tag, device_floor_tag
	                                        from import_niagara_tag
	                                        group by device_building_tag, device_floor_tag
                                        ) AS tag
                                        LEFT JOIN floor f
                                        ON tag.device_building_tag COLLATE utf8mb4_0900_ai_ci = f.building_tag COLLATE utf8mb4_0900_ai_ci 
                                            and tag.device_floor_tag COLLATE utf8mb4_0900_ai_ci = f.full_name COLLATE utf8mb4_0900_ai_ci 
                                            and f.deleted = 0
                                        WHERE f.building_tag IS NULL;");
                        result = (await conn.QueryAsync<NiagaraTags>(sb.ToString())).ToList<NiagaraTags>();
                        #endregion

                        sb.Clear();
                        #region insert floor
                        if (result.Count > 0)
                        {
                            Dictionary<string, int> floorPriority = new Dictionary<string, int>();
                            foreach (var data in result)
                            {
                                FloorPriority fp = (await conn.QueryAsync<FloorPriority>($@"select building_tag, max(priority) as priority from floor 
                                            where building_tag = '{data.device_building_tag}' and deleted = 0 group by building_tag;")).FirstOrDefault();
                                int priority = 0;

                                if (fp == null && floorPriority.GetValueOrDefault(data.device_building_tag) == 0)
                                    floorPriority.Add(data.device_building_tag, 0);
                                else if (fp != null && floorPriority.GetValueOrDefault(fp.building_tag) == 0)
                                    floorPriority.Add(fp.building_tag, fp.Priority);

                                priority = ++floorPriority[data.device_building_tag];

                                sb.Append($@"insert into floor(floor_guid, building_tag, deleted, status, full_name, priority, created_by, created_at)
                                    VALUES (uuid(), '{data.device_building_tag}', 0, 1, '{data.device_floor_tag}', {priority}, 'B43E3CA7-96DD-4FC7-B6E6-974ACC3B0878', now());");
                            }
                            if (sb.Length > 0)
                            {
                                await conn.ExecuteAsync(sb.ToString());
                                sb.Clear();
                            }
                        }
                        #endregion

                        #region update unuse floor with niagara data
                        var floor = (await conn.QueryAsync<BuildFloor>($@"select f1.*
                                                from floor as f1
                                                left join (
	                                                select f.floor_guid
	                                                from (
		                                                select  device_building_tag, device_floor_tag
		                                                from import_niagara_tag
		                                                group by device_building_tag, device_floor_tag
	                                                ) AS tag
	                                                LEFT JOIN floor f
	                                                ON tag.device_building_tag COLLATE utf8mb4_0900_ai_ci = f.building_tag COLLATE utf8mb4_0900_ai_ci 
                                                        and tag.device_floor_tag COLLATE utf8mb4_0900_ai_ci = f.full_name COLLATE utf8mb4_0900_ai_ci 
                                                        and f.deleted = 0
                                                ) as f2 on f1.floor_guid = f2.floor_guid
                                                where f2.floor_guid is null and f1.deleted = 0;")).ToList<BuildFloor>();

                        if (floor.Count > 0)
                        {
                            sb.Clear();
                            foreach (var f in floor)
                            {
                                sb.Append($"update floor set deleted = 1 where floor_guid = '{f.Floor_guid}';");
                            }

                            await conn.ExecuteAsync(sb.ToString());
                        }
                        #endregion
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

        public async Task InsertItemFromNiagara_History(List<ImpNiaItem> ds, List<string> building)
        {
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        //改成每次都新增 
                        string sql = @"SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for import_niagara_item_history
-- ----------------------------
DROP TABLE IF EXISTS `import_niagara_item_history`;
CREATE TABLE `import_niagara_item_history`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `device_area_tag` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `device_building_tag` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `device_system_tag` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `device_name_tag` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `device_floor_tag` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `device_master_tag` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `device_last_name_tag` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `device_serial_tag` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `device_point_name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `parent_path` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `is_history` bit(1) NULL DEFAULT b'0',
  `full_name` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `check_status` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  `created_at` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 271 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;";
                        await conn.ExecuteAsync(sql);

                        #region 刪除 import_niagara_item資料表中選取的棟別
                        //foreach (var b in building)
                        //{

                        //    sql = "delete from import_niagara_item_history where device_building_tag = '" + b + "'";
                        //    await conn.ExecuteAsync(sql);
                        //}
                        #endregion


                        StringBuilder sb = new StringBuilder();
                        #region 放入import_niagara_item資料表
                        foreach (var row in ds)
                        {
                            string ss = $@" insert import_niagara_item_history(device_area_tag, device_building_tag, device_system_tag, device_name_tag, 
device_floor_tag,  device_master_tag, device_last_name_tag, device_serial_tag, device_point_name, parent_path, full_name, is_history, created_at)
                                        values('" +
                                            row.device_area_tag + "', '" +
                                            row.device_building_tag + "', '" +
                                            row.device_system_tag + "', '" +
                                            row.device_name_tag + "', '" +
                                            row.device_floor_tag + "', '" +
                                            row.device_master_tag + "', '" +
                                            row.device_last_name_tag + "', '" +
                                            row.device_serial_tag + "', '" +
                                            row.device_point_name + "', '" +
                                            row.parent_path + "', '" +
                                            row.full_name + "'," +
                                            row.isHistory + ", now() " +
                                            ");";
                            sb.Append(ss);
                        }
                        if (sb.Length > 0)
                        {
                            await conn.ExecuteAsync(sb.ToString());
                            sb.Clear();
                        }
                        #endregion
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }

        /// <summary>
        /// Recover device_system_tag
        /// </summary>
        /// <returns></returns>
        public async Task RecoverSysTag(string tableName)
        {
            //檢查
            using (IDbConnection conn = GetDbConnection())
            {
                conn.Open();
                using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                {
                    try
                    {
                        StringBuilder sb = new StringBuilder();
                        sb.Append($@"SET SQL_SAFE_UPDATES = 0;
                                    update {tableName} a
                                    join dic_system ds on ds.s2_code = a.device_name_tag
                                    set a.device_system_tag = ds.s1_code
                                    where a.device_system_tag is null or a.device_system_tag = '';");
                        await conn.ExecuteAsync(sb.ToString());
                    }
                    catch (Exception exception)
                    {
                        throw exception;
                    }
                    finally
                    {
                        conn.Close();
                    }
                }
            }
        }
    }
}