Merge branch 'WJC'

wxr

2020-12-07 64dbbfe1d6488635e160189a704afccffc7d34d0

 HDL_ON/Entity/Room.cs

@@ -1,12 +1,13 @@
using System;
using System.Collections.Generic;
using HDL_ON.DAL.Server;

namespace HDL_ON.Entity
{
    /// <summary>
    /// 读取服务器空间信息返回到数据包
    /// </summary>
    public class RoomApiPack
    public class SpatialApiPack
    {
        public List<SpatialInfo> list = new List<SpatialInfo>();

@@ -25,19 +26,48 @@
    /// </summary>
    public class SpatialInfo
    {
        static SpatialInfo _currentSpatial;
        public static SpatialInfo CurrentSpatial
        {
            get
            {
                if (_currentSpatial == null)
                {
                    _currentSpatial = new SpatialInfo();
                }
                return _currentSpatial;
            }
        }
        public SpatialInfo()
        {
        }

        public SpatialInfo(string spatialType)
        {
            roomType = "FLOOR";
            parentId = DB_ResidenceData.residenceData.CurReginID;
        }

        public string roomId = "";
        public string roomName = "";
        public string roomImage = "";
        //public string roomImage = "";
        public string roomImage = "Classification/Room/Roombg.png";
        public string roomType = "";
        public string parentId = "";
        public string uid = Guid.NewGuid().ToString();

        public string createTime = "";
        public string modifyTime = "";
        /// <summary>
        /// 删除标记
        /// 需要删除数据时，标记为：true
        /// 由云端删除成功之后，返回数据再清除本地数据
        /// </summary>
        public bool DeleteSign = false;


        protected void SaveSpatialInfo()
        {
            var pm = new DAL.Server.HttpServerRequest();
            var pm = new HttpServerRequest();
            if (string.IsNullOrEmpty(createTime) && string.IsNullOrEmpty(modifyTime))
            {
                pm.AddRoom(new List<SpatialInfo>() { this });
@@ -53,55 +83,123 @@
        }

        /// <summary>
        /// 更新楼层信息
        /// 下载云端房间数据
        /// </summary>
        public void UpdateSpatialInfoData()
        public void DownloadRoomList()
        {
            if (roomType == "ROOM")
            new System.Threading.Thread(() =>
            {

            }
            else if (roomType == "FLOOR")
            {
                var tempFloor = Floor.InsFloor.Floors.Find((obj) => obj.roomId == roomId);
                if (tempFloor == null)
                var pm = new HttpServerRequest();
                var pack = pm.GetRoomList();
                if (pack.Code == StateCode.SUCCESS)
                {
                    Floor.InsFloor.Floors.Add(this as Floor);
                    var revData = Newtonsoft.Json.JsonConvert.DeserializeObject<SpatialApiPack>(pack.Data.ToString());
                    if (revData != null)
                    {
                        CurrentSpatial.UpdateSpatialList(revData.list, OptionType.Cover);
                    }
                }
                else
                {
                    tempFloor = this as Floor;
                    MainPage.Log($"读取房间数据失败:\r\nCode:{pack.Code}; msg:{pack.message}");
                }
                var ssd = System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(Floor.InsFloor.Floors));
                FileUtils.WriteFileByBytes(Floor.InsFloor.FloorDataSavePath, ssd);
                MainPage.Log("更新楼层信息");
            }
            })
            { IsBackground = true }.Start();
        }
    }

    /// <summary>
    /// 房间对象
    /// </summary>
    [Serializable]
    public class Floor : SpatialInfo
    {
        #region 楼层数据相关
        static Floor ins_Floor ;
        public static Floor InsFloor {
            get {
                if(ins_Floor== null)
        /// <summary>
        /// 更新空间信息
        /// </summary>
        /// <param name="spatials">空间信息</param>
        /// <param name="optionType">操作类型：ADD/UPDATE/DELETE</param>
        public void UpdateSpatialList(List<SpatialInfo> spatials,OptionType optionType)
        {
            var roomUpdateList = spatials.FindAll((obj) => obj.roomType == "ROOM");
            var floorUpdateList = spatials.FindAll((obj) => obj.roomType == "FLOOR");
            //处理房间列表
            if (roomUpdateList != null && roomUpdateList.Count > 0)
            {
                if (optionType == OptionType.Update)
                {
                    ins_Floor = new Floor();
                    foreach (var updateTemp in roomUpdateList)
                    {
                        var localDelRoom = CurrentSpatial.needDeleteRooms.Find((obj) => obj.roomId == updateTemp.roomId);
                        if(localDelRoom!= null)
                        {
                                    DelRoom(localDelRoom);
                           
                            continue;
                        }
                        var localRoom = CurrentSpatial.RoomList.Find((obj) => obj.roomId == updateTemp.roomId);
                        if (localRoom != null)
                        {
                            if (localRoom.modifyTime != updateTemp.modifyTime)
                            {
                                localRoom.roomName = updateTemp.roomName;
                                localRoom.roomImage = updateTemp.roomImage;
                                localRoom.parentId = updateTemp.parentId;
                                localRoom.createTime = updateTemp.createTime;
                                localRoom.modifyTime = updateTemp.modifyTime;
                                localRoom.SaveRoomData();
                            }
                        }else
                        {
                            updateTemp.SaveRoomData();
                        }
                    }
                }
                return ins_Floor;
                else if (optionType == OptionType.Cover)
                {
                    CurrentSpatial.DeleteAllRoom();
                    foreach(var newRoom in roomUpdateList)
                    {
                        newRoom.SaveRoomData();
                        RoomList.Add(Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(
                            Newtonsoft.Json.JsonConvert.SerializeObject(newRoom)));
                    }
                }
            }
            //楼层房间列表
            if (floorUpdateList != null && floorUpdateList.Count > 0)
            {
                if (optionType == OptionType.Update)
                {
                    foreach(var updateTemp in floorUpdateList)
                    {
                        var localFloor = FloorList.Find((obj) => obj.roomId == updateTemp.roomId);
                        if (localFloor == null)
                        {
                            FloorList.Add(updateTemp);
                        }
                        else
                        {
                            localFloor = updateTemp;
                        }
                    }
                    CurrentSpatial.SaveFloorData();
                }
                if(optionType == OptionType.Cover)
                {
                    FloorList.Clear();
                    foreach (var updateTemp in floorUpdateList)
                    {
                        FloorList.Add(updateTemp);
                    }
                    var ssd = System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(FloorList));
                    FileUtils.WriteFileByBytes(dataSavePath, ssd);
                }
            }
        }
        public string FloorDataSavePath = "FloorsData";

        #region 楼层列表
        /// <summary>
        /// 楼层列表
        /// </summary>
        List<Floor> floors;
        public List<Floor> Floors
        List<SpatialInfo> floors;
        /// <summary>
        /// 楼层列表
        /// </summary>
        public List<SpatialInfo> FloorList
        {
            get
            {
@@ -109,15 +207,15 @@
                {
                    try
                    {
                        var floorsDataBytes = FileUtils.ReadFile(FloorDataSavePath);
                        var floorsDataBytes = FileUtils.ReadFile("FloorsData");
                        if (floorsDataBytes != null)
                        {
                            var floorsDataString = System.Text.Encoding.UTF8.GetString(floorsDataBytes);
                            MainPage.Log(floorsDataString);
                            floors = Newtonsoft.Json.JsonConvert.DeserializeObject<List<Floor>>(floorsDataString);
                            floors = Newtonsoft.Json.JsonConvert.DeserializeObject<List<SpatialInfo>>(floorsDataString);
                            if (floors == null)
                            {
                                floors = new List<Floor>();
                                floors = new List<SpatialInfo>();
                            }
                        }
                    }
@@ -129,50 +227,238 @@
                return floors;
            }
        }

        /// <summary>
        /// 数据保存路径
        /// </summary>
        string dataSavePath
        {
            get
            {
                if(roomType == "ROOM")
                {
                    return "RoomPath_" + uid;
                }
                if(roomType == "FLOOR")
                {
                    return "FloorsData"; 
                }
                else
                {
                    return "SpatialInfo_"+uid;
                }
            }
        }
        /// <summary>
        /// 增加楼层
        /// </summary>
        /// <param name="floor"></param>
        public void AddFloor(Floor floor)
        public void AddFloor(SpatialInfo floor)
        {
            ins_Floor.floors.Add(floor);
            floor.SaveFloorData();
            FloorList.Add(floor);
            SaveFloorData();
        }
        /// <summary>
        /// 更新楼层信息
        /// </summary>
        /// <param name="floor"></param>
        public void UpdateFloor()
        {
            SaveFloorData();
        }
        /// <summary>
        /// 删除楼层
        /// </summary>
        /// <param name="floor"></param>
        public void DelFloor(Floor floor)
        public void DelFloor(SpatialInfo floor)
        {
            var tRoom = ins_Floor.floors.Find((obj) => obj.uid == floor.uid);
            var tRoom = FloorList.Find((obj) => obj.uid == floor.uid);
            if (tRoom != null)
            {
                ins_Floor.floors.Remove(floor);
                floor.modifyTime = "";
                FloorList.Remove(floor);
                floor.DeleteSign = true;
            }
            SaveFloorData();
        }

        #endregion

        public Floor()
        {
            roomType = "FLOOR";
            parentId = DB_ResidenceData.residenceData.CurReginID;
        }
        /// <summary>
        /// 保存楼层数据
        /// </summary>
        public void SaveFloorData()
        void SaveFloorData()
        {
            var ssd = System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(ins_Floor.floors));
            FileUtils.WriteFileByBytes(FloorDataSavePath, ssd);
            var ssd = System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(FloorList));
            FileUtils.WriteFileByBytes(dataSavePath, ssd);
            MainPage.Log($"Save floor Data");
            base.SaveSpatialInfo();
            SaveSpatialInfo();
        }


        #endregion

        #region 房间列表
        /// <summary>
        /// 房间列表
        /// </summary>
        List<Room> rooms;
        /// <summary>
        /// 房间列表
        /// </summary>
        public List<Room> RoomList
        {
            get
            {
                if (rooms == null)
                {
                    try
                    {
                        rooms = new List<Room> { };
                        var filePathList = FileUtils.ReadFiles();

                        foreach (var filePath in filePathList)
                        {
                            if (filePath.StartsWith("RoomData_"))
                            {
                                var roomDataBytes = FileUtils.ReadFile(filePath);
                                var roomDataString = System.Text.Encoding.UTF8.GetString(roomDataBytes);
                                var room = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(roomDataString);
                                if (room != null )
                                {
                                    if(room.DeleteSign)
                                    {
                                        needDeleteRooms.Add(room);
                                    }else
                                    {
                                        rooms.Add(room);
                                    }
                                }
                            }
                        }
                        if(needDeleteRooms.Count>0)
                        {
                            //删除已经标记需要删除的房间
                            new System.Threading.Thread(() =>
                            {
                                var delIds = new List<string>();
                                foreach(var delTemp in needDeleteRooms)
                                {
                                    delIds.Add(delTemp.roomId);
                                }
                                var pm = new HttpServerRequest();
                                var pack = pm.DeleteRoom(delIds);
                                if (pack.Code == StateCode.SUCCESS)
                                {
                                    foreach (var delTemp in needDeleteRooms)
                                    {
                                        FileUtils.DeleteFile(delTemp.dataSavePath);
                                    }
                                    needDeleteRooms.Clear();
                                }
                            })
                            { IsBackground = true }.Start();
                        }
                    }
                    catch (Exception ex)
                    {
                        MainPage.Log($"功能数据初始化失败：{ex.Message}");
                    }
                }
                return rooms;
            }
        }
        /// <summary>
        /// 需要删除的房间
        /// 本地标记删除了，但是服务上没有删除
        /// 无法与服务器通讯造成删除不成功，通讯成功之后要重新删除
        /// </summary>
        List<Room> needDeleteRooms = new List<Room>();
        /// <summary>
        /// 增加房间
        /// </summary>
        /// <param name="room"></param>
        public void AddRoom(Room room)
        {
            RoomList.Add(room);
            room.SaveRoomData();
        }
        /// <summary>
        /// 删除房间
        /// </summary>
        /// <param name="room"></param>
        public void DelRoom(Room room)
        {
            new System.Threading.Thread(() =>
            {
                room.DeleteSign = true;
                room.SaveRoomData();
                var tRoom = RoomList.Find((obj) => obj.uid == room.uid);
                if (tRoom != null)
                {
                    RoomList.Remove(room);
                }
                var temp = needDeleteRooms.Find((obj) => obj.uid == room.uid);
                if (temp != null)
                {
                    needDeleteRooms.Add(room);
                }
                var pm = new HttpServerRequest();
                var pack = pm.DeleteRoom(new List<string>() { room.roomId });
                if (pack.Code == StateCode.SUCCESS)
                {
                    FileUtils.DeleteFile(room.dataSavePath);
                    needDeleteRooms.Remove(room);
                }
            })
            { IsBackground = true }.Start();
        }
        /// <summary>
        /// 删除所有房间
        /// </summary>
        public void DeleteAllRoom()
        {
            foreach(var localRoom in RoomList)
            {
                FileUtils.DeleteFile(localRoom.dataSavePath);
            }
            RoomList.Clear();
        }
        /// <summary>
        /// 初始化每个房间的功能数据
        /// </summary>
        public void InitRoomFunction()
        {
            new System.Threading.Thread(() =>
            {
                try
                {
                    //初始化住宅所有房间功能数据
                    foreach (var r in RoomList)
                    {
                        r.GetRoomFunctions(true);
                        r.GetRoomScenes(true);
                    }
                }
                catch (Exception ex)
                {
                    MainPage.Log($"Init room function error : {ex.Message}");
                }
            })
            { IsBackground = true }.Start();
        }

        /// <summary>
        /// 保存房间数据
        /// </summary>
        public void SaveRoomData()
        {
            var ssd = System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(this));
            FileUtils.WriteFileByBytes(dataSavePath, ssd);
            MainPage.Log($"Save Room Data {roomName} : {uid}");
            SaveSpatialInfo();
        }
        #endregion

    }



    [Serializable]
    public class Room : SpatialInfo
@@ -182,14 +468,27 @@
            roomType = "ROOM";
            roomName = "Room";
        }
        public string backgroundImage = "Classification/Room/Roombg.png";
        public string roomSavePath
        //public string backgroundImage = "Classification/Room/Roombg.png";
        public string backgroundImage
        {
            get
            {
                return "RoomPath_" + uid;
                if (string.IsNullOrEmpty(roomImage))
                {
                    return "Classification/Room/Roombg.png";
                }
                else
                {
                    return roomImage;
                }
            }
            set
            {
                roomImage = value;
            }
        }


        /// <summary>
        /// 楼层
        /// </summary>
@@ -198,9 +497,9 @@
        {
            get
            {
                if (Floor.InsFloor.Floors.Count > 0)
                if (FloorList.Count > 0)
                {
                    var f = Floor.InsFloor.Floors.Find((obj) => obj.uid == parentId);
                    var f = FloorList.Find((obj) => obj.uid == parentId);
                    if (f != null)
                    {
                        return f.roomName + " ";
@@ -294,16 +593,6 @@
        public void RemoveRoomScene(Scene scene)
        {
            scenes.Remove(scenes.Find((obj) => obj.sid == scene.sid));
        }
        /// <summary>
        /// 保存房间数据
        /// </summary>
        public void SaveRoomData()
        {
            var ssd = System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(this));
            FileUtils.WriteFileByBytes(roomSavePath, ssd);
            MainPage.Log($"Save Room Data {roomName} : {this.uid}");
            base.SaveSpatialInfo();
        }
    }