using Shared.Phone.UserCenter;
|
using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using ZigBee.Device;
|
using System.Linq;
|
|
namespace Shared.Common
|
{
|
/// <summary>
|
/// 房间对象
|
/// </summary>
|
[System.Serializable]
|
public class Room
|
{
|
#region ◆ 变量____________________________
|
|
/// <summary>
|
/// 房间文件
|
/// </summary>
|
/// <value>The name of the file.</value>
|
[Newtonsoft.Json.JsonIgnore]
|
public string FileName
|
{
|
get
|
{
|
return $"Room_{Id}.json";
|
}
|
}
|
/// <summary>
|
/// 房间id--使用guid
|
/// Guid.NewGuid().ToString()
|
/// </summary>
|
public string Id = Guid.NewGuid().ToString();
|
/// <summary>
|
/// 楼层Id
|
/// 新增时使用Guid
|
/// </summary>
|
public string FloorId = string.Empty;
|
/// <summary>
|
/// 楼层名称
|
/// </summary>
|
public string FloorName
|
{
|
get
|
{
|
return Config.Instance.Home.GetFloorNameById(FloorId);
|
}
|
}
|
/// <summary>
|
/// 房间名
|
/// </summary>
|
public string Name = string.Empty;
|
|
/// <summary>
|
/// 房间背景图
|
/// </summary>
|
public string BackgroundImage = string.Empty;
|
|
/// <summary>
|
/// 图片来源 0--本地图库 1--拍照 2--系统图库
|
/// </summary>
|
public int BackgroundImageType = 0;
|
|
/// <summary>
|
/// 楼层--备用
|
/// </summary>
|
public Dictionary<string, string> FloorList = new Dictionary<string, string> { };
|
|
/// <summary>
|
/// 温度传感器(设备主键)
|
/// </summary>
|
public string TemperatrueDevice = string.Empty;
|
/// <summary>
|
/// 湿度传感器(设备主键)
|
/// </summary>
|
public string HumidityDevice = string.Empty;
|
/// <summary>
|
/// 温度
|
/// </summary>
|
public decimal Temperatrue;
|
/// <summary>
|
/// 湿度
|
/// </summary>
|
public decimal Humidity;
|
|
/// <summary>
|
/// 当前选择的房间
|
/// </summary>
|
private static Room m_CurrentRoom = null;
|
/// <summary>
|
/// 当前选择的房间
|
/// </summary>
|
[Newtonsoft.Json.JsonIgnore]
|
public static Room CurrentRoom
|
{
|
get
|
{
|
if (m_CurrentRoom == null && Lists.Count > 0)
|
{
|
if (m_CurrentRoom == null) { m_CurrentRoom = Lists[0]; }
|
return Lists[0];
|
}
|
return m_CurrentRoom;
|
}
|
set { m_CurrentRoom = value; }
|
}
|
|
/// <summary>
|
/// 房间里所有的设备列表
|
/// </summary>
|
[Newtonsoft.Json.JsonIgnore]
|
public List<DeviceUI> DeviceUIList = new List<DeviceUI> { };
|
/// <summary>
|
///设备文件路径列表
|
/// </summary>
|
public readonly List<string> DeviceUIFilePathList = new List<string>();
|
|
/// <summary>
|
/// 喜爱房间id
|
/// </summary>
|
public const string LoveRoomId= "Favorite";
|
|
/// <summary>
|
/// 是否是默认喜爱房间
|
/// </summary>
|
/// <value><c>true</c> if is love; otherwise, <c>false</c>.</value>
|
[Newtonsoft.Json.JsonIgnore]
|
public bool IsLove
|
{
|
get
|
{
|
return Id == LoveRoomId;
|
}
|
}
|
|
/// <summary>
|
/// 是否是分享过来的房间
|
/// 注：分享过来的房间不能删除，不能编辑该房间，不能对设备（功能）、场景进行增删改
|
/// </summary>
|
public bool IsSharedRoom = false;
|
|
/// <summary>
|
/// 获取喜爱房间的所有设备路径
|
/// </summary>
|
/// <value>The love room device list.</value>
|
[Newtonsoft.Json.JsonIgnore]
|
public static List<string> LoveRoomDeviceUIFilePathList
|
{
|
get
|
{
|
if (Lists.Count == 0)
|
{
|
return new List<string> { };
|
}
|
return CurrentRoom.GetLoveRoom().DeviceUIFilePathList;
|
}
|
}
|
|
/// <summary>
|
/// 所有房间的所有设备类型
|
/// </summary>
|
/// <value>All room device type list.</value>
|
[Newtonsoft.Json.JsonIgnore]
|
public static List<DeviceType> AllRoomDeviceTypeList
|
{
|
get
|
{
|
var typeList = new List<DeviceType> { };
|
foreach (var deviceUI in AllRoomDeviceUIList)
|
{
|
if (deviceUI == null || deviceUI.CommonDevice == null)
|
{
|
continue;
|
}
|
if (!typeList.Contains(deviceUI.CommonDevice.Type))
|
{
|
typeList.Add(deviceUI.CommonDevice.Type);
|
}
|
}
|
return typeList;
|
}
|
}
|
|
/// <summary>
|
/// 获取所有房间的所有场景
|
/// </summary>
|
/// <value>All room scene UIL ist.</value>
|
[Newtonsoft.Json.JsonIgnore]
|
public static List<SceneUI> AllRoomSceneUIList
|
{
|
get
|
{
|
var sceneList = new List<SceneUI> { };
|
foreach (var r in Shared.Common.Room.Lists)
|
{
|
if(r.IsLove)
|
{
|
continue;
|
}
|
if (r.SceneUIList.Count == 0)
|
{
|
continue;
|
}
|
foreach (var sceneUI in r.SceneUIList)
|
{
|
if (sceneUI == null)
|
{
|
continue;
|
}
|
sceneList.Add(sceneUI);
|
}
|
}
|
return sceneList;
|
}
|
}
|
|
/// <summary>
|
/// 获取所有房间的所有场景路径
|
/// </summary>
|
/// <value>All room scene UIL ist.</value>
|
[Newtonsoft.Json.JsonIgnore]
|
public List<string> AllRoomSceneUIFilepathList
|
{
|
get
|
{
|
var pathList = new List<string> { };
|
foreach (var r in Lists)
|
{
|
if(r.IsLove)
|
{
|
continue;
|
}
|
|
if (r.SceneUIFilePathList.Count == 0)
|
{
|
continue;
|
}
|
foreach (var path in r.SceneUIFilePathList)
|
{
|
pathList.Add(path);
|
}
|
}
|
return pathList;
|
}
|
}
|
|
/// <summary>
|
/// 场景列表---不再序列化
|
/// </summary>
|
[Newtonsoft.Json.JsonIgnore]
|
public List<SceneUI> SceneUIList = new List<SceneUI> { };
|
/// <summary>
|
///场景文件列表
|
/// </summary>
|
public readonly List<string> SceneUIFilePathList = new List<string>();
|
|
/// <summary>
|
/// 所有的房间信息
|
/// </summary>
|
public static List<Room> Lists = new List<Room>();
|
|
/// <summary>
|
/// 获取所有房间的所有设备
|
/// </summary>
|
/// <value>All room device UIL ist.</value>
|
[Newtonsoft.Json.JsonIgnore]
|
public static List<DeviceUI> AllRoomDeviceUIList
|
{
|
get
|
{
|
List<DeviceUI> deviceList = new List<DeviceUI>();
|
for (int i = 0; i < Lists.Count; i++)
|
{
|
var room = Lists[i];
|
if (room.IsSharedRoom || room.IsLove)
|
{
|
continue;
|
}
|
if (room.DeviceUIList.Count == 0)
|
{
|
continue;
|
}
|
for (int j = 0; j < room.DeviceUIList.Count; j++)
|
{
|
var device = room.DeviceUIList[j];
|
if (device == null || device.CommonDevice == null)
|
{
|
continue;
|
}
|
if (deviceList.Find((obj) => obj.FileName == device.FileName) == null)
|
{
|
deviceList.Add(device);
|
}
|
}
|
}
|
return deviceList;
|
}
|
}
|
|
#endregion
|
|
#region ◆ 构造方法________________________
|
|
/// <summary>
|
/// 构造方法
|
/// </summary>
|
static Room()
|
{
|
InitAllRoom();
|
}
|
|
#endregion
|
|
#region ◆ 初始化__________________________
|
|
/// <summary>
|
/// 初始化房间信息
|
/// 从文件中全部读取所有的房间数据到内存
|
/// </summary>
|
public static void InitAllRoom()
|
{
|
Lists.Clear();
|
if (Config.Instance.Home.RoomFilePathList.Contains("Room_Favorite.json") == false)
|
{
|
//默认添加喜爱的房间--禁止修改房间名
|
var love = new Room { Name = Language.StringByID(R.MyInternationalizationString.Favorite), BackgroundImage = "RoomIcon/0.JPG", Id = LoveRoomId };
|
love.Save(false);
|
//添加到house 房间路径列表
|
var currentHome = Config.Instance.Home;
|
currentHome.RoomFilePathList.Insert(0, love.FileName);
|
currentHome.Save(false);
|
}
|
foreach (var roomFilePath in Config.Instance.Home.RoomFilePathList)
|
{
|
var room = GetRoomByFilePath(roomFilePath);
|
|
if (null != room)
|
{
|
if (room.IsSharedRoom)
|
{
|
room.Name = $"{room.Name}";
|
}
|
Lists.Add(room);
|
|
}
|
}
|
|
Config.Instance.Home.InitFloor();
|
|
CurrentRoom.RefreshRoomListView();
|
}
|
|
/// <summary>
|
/// 刷新房间视图列表
|
/// </summary>
|
public void RefreshRoomListView()
|
{
|
Application.RunOnMainThread(() =>
|
{
|
Phone.Device.Room.RoomManagement.Instance.Show();
|
});
|
}
|
|
/// <summary>
|
/// 从本地重新加载全部的房间
|
/// </summary>
|
public static void RefreshAllRoomByLocation()
|
{
|
var homeTemp = Config.Instance.Home;
|
homeTemp.RoomFilePathList.Clear();
|
|
var listFile = Global.FileListByHomeId();
|
|
//我的喜爱的房间必须要在第0位才行
|
string fRoom = "Room_Favorite.json";
|
if (listFile.Contains(fRoom) == true)
|
{
|
listFile.Remove(fRoom);
|
homeTemp.RoomFilePathList.Add(fRoom);
|
}
|
|
var listRoomFile = new List<string>();
|
foreach (string fileName in listFile)
|
{
|
if (fileName.StartsWith("Room_"))
|
{
|
homeTemp.RoomFilePathList.Add(fileName);
|
listRoomFile.Add(fileName);
|
}
|
}
|
//检测楼层数据的合法性
|
CheckFloorData(listRoomFile);
|
|
homeTemp.Save(false);
|
InitAllRoom();
|
}
|
|
/// <summary>
|
/// 检测楼层数据的合法性
|
/// </summary>
|
/// <param name="listRoomFile"></param>
|
private static void CheckFloorData(List<string> listRoomFile)
|
{
|
for (int i = 0; i < listRoomFile.Count; i++)
|
{
|
try
|
{
|
var byteData = Global.ReadFileByHomeId(listRoomFile[i]);
|
string valueData = System.Text.Encoding.UTF8.GetString(byteData);
|
var roomTemp = Newtonsoft.Json.JsonConvert.DeserializeObject<Common.Room>(valueData);
|
|
//检测多个手机来回创建,然后又删除之后,楼层数据不能保证100%同步的问题
|
if (roomTemp.FloorId != string.Empty && Config.Instance.Home.FloorDics.ContainsKey(roomTemp.FloorId) == false)
|
{
|
//未知楼层
|
Config.Instance.Home.FloorDics[roomTemp.FloorId] = Language.StringByID(R.MyInternationalizationString.uUnKnownFloor);
|
}
|
}
|
catch (Exception ex) { HdlLogLogic.Current.WriteLog(ex); }
|
}
|
}
|
|
#endregion
|
|
#region ◆ 添加房间_________________________
|
|
/// <summary>
|
/// 增加房间
|
/// </summary>
|
/// <returns><c>true</c>, if room was added, <c>false</c> otherwise.</returns>
|
/// <param name="room">Room.</param>
|
public bool AddRoom(Room room)
|
{
|
if (string.IsNullOrEmpty(room.FileName) || Global.IsExistsByHomeId(room.FileName))
|
{
|
return false;
|
}
|
if (Config.Instance.Home.RoomFilePathList.Contains(room.FileName))
|
{
|
return false;
|
}
|
Lists.Add(room);
|
var r = Config.Instance.Home.AddRoomListFilePath(room.FileName);
|
if (r == false)
|
{
|
return false;
|
}
|
Save();
|
HdlAutoBackupLogic.AddOrEditorFile(room.FileName);
|
CurrentRoom.RefreshRoomListView();
|
return true;
|
}
|
|
#endregion
|
|
#region ◆ 删除房间_________________________
|
|
/// <summary>
|
/// 删除房间
|
/// </summary>
|
public bool Remove(string roomFilePath)
|
{
|
var room = GetRoomByFilePath(roomFilePath);
|
if (null == room)
|
{
|
return false;
|
}
|
//删除来自拍照或者系统图库的房间背景图片
|
if (room.BackgroundImageType == 1 || room.BackgroundImageType == 2)
|
{
|
//删除掉原来的自定义图片
|
if (Global.IsExistsByHomeId(room.BackgroundImage) == true)
|
{
|
Global.DeleteFilebyHomeId(room.BackgroundImage);
|
//删除备份
|
HdlAutoBackupLogic.DeleteFile(room.BackgroundImage);
|
}
|
}
|
//我的喜爱
|
var loveRoom = this.GetLoveRoom();
|
if (loveRoom != null)
|
{
|
//移除我的喜爱里面的设备
|
for (int i = 0; i < room.DeviceUIFilePathList.Count; i++)
|
{
|
loveRoom.DeviceUIFilePathList.Remove(room.DeviceUIFilePathList[i]);
|
loveRoom.DeviceUIList.RemoveAll((obj) => { return room.DeviceUIFilePathList[i] == obj.FileName; });
|
}
|
//移除我的喜爱里面的场景
|
for (int i = 0; i < room.SceneUIFilePathList.Count; i++)
|
{
|
loveRoom.SceneUIFilePathList.Remove(room.SceneUIFilePathList[i]);
|
loveRoom.SceneUIList.RemoveAll((obj) => { return room.SceneUIFilePathList[i] == obj.FileName; });
|
}
|
loveRoom.Save(false);
|
}
|
|
if (Global.IsExistsByHomeId(roomFilePath) == false)
|
{
|
return false;
|
}
|
Config.Instance.Home.RemoveRoomListFilePath(roomFilePath);
|
//删除文件
|
Global.DeleteFilebyHomeId(roomFilePath);
|
Lists.Remove(room);
|
HdlAutoBackupLogic.DeleteFile(roomFilePath);
|
|
CurrentRoom.RefreshRoomListView();
|
|
return true;
|
}
|
|
#endregion
|
|
#region ◆ 获取房间________________________
|
|
/// <summary>
|
/// 获取喜爱房间
|
/// </summary>
|
/// <returns></returns>
|
public Room GetLoveRoom()
|
{
|
return CurrentRoom.GetRoomById(LoveRoomId);
|
}
|
|
/// <summary>
|
/// 通过路径获取房间
|
/// </summary>
|
/// <returns>The room by file path.</returns>
|
/// <param name="roomFilePath">Room file path.</param>
|
public static Room GetRoomByFilePath(string roomFilePath)
|
{
|
try
|
{
|
var roomFile = Global.ReadFileByHomeId(roomFilePath);
|
var nowRoom = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(System.Text.Encoding.UTF8.GetString(roomFile));
|
|
if (null == nowRoom)
|
{
|
System.Console.WriteLine("房间文件路径不对，文件路径为：" + roomFilePath);
|
return null;
|
}
|
|
var beforeRoom = Lists.Find((obj) => obj.Id == nowRoom.Id);
|
if (beforeRoom != null)
|
{
|
var tempDeviceUIList = new List<DeviceUI>();
|
tempDeviceUIList.AddRange(beforeRoom.DeviceUIList);
|
var tempSceneUIList = new List<SceneUI>();
|
tempSceneUIList.AddRange(beforeRoom.SceneUIList);
|
//设备（deviceUI）
|
beforeRoom.DeviceUIList.Clear();
|
foreach (var deviceFilePath in beforeRoom.DeviceUIFilePathList)
|
{
|
var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(deviceFilePath));
|
var tempDeviceUI = Newtonsoft.Json.JsonConvert.DeserializeObject<DeviceUI>(jsonInfo);
|
if (tempDeviceUI != null)
|
{
|
var delCommon = tempDeviceUIList.Find((obj) => obj.CommonDevice != null && tempDeviceUI.CommonDevice != null && obj.CommonDevice.Type == tempDeviceUI.CommonDevice.Type && obj.CommonDevice.CommonDeviceAddrEpoint == tempDeviceUI.CommonDevice.CommonDeviceAddrEpoint);
|
if (delCommon != null)
|
{
|
beforeRoom.DeviceUIList.Add(delCommon);
|
}
|
else
|
{
|
beforeRoom.AddDevice(deviceFilePath);
|
}
|
}
|
}
|
//场景(SceneUI)
|
beforeRoom.SceneUIList.Clear();
|
foreach (var sceneFilePath in beforeRoom.SceneUIFilePathList)
|
{
|
var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(sceneFilePath));
|
var tempSceneUI = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(jsonInfo);
|
if (tempSceneUI != null)
|
{
|
var scene = tempSceneUIList.Find((obj) => obj.FileName == tempSceneUI.FileName);
|
if (scene != null)
|
{
|
beforeRoom.SceneUIList.Add(scene);
|
}
|
else
|
{
|
beforeRoom.AddScene(scene);
|
}
|
}
|
}
|
|
return beforeRoom;
|
}
|
|
//设备（deviceUI）
|
nowRoom.DeviceUIList.Clear();
|
foreach (var deviceFilePath in nowRoom.DeviceUIFilePathList)
|
{
|
var tempCommon = LocalDevice.Current.GetDeviceUI(deviceFilePath);
|
if (tempCommon == null || tempCommon.CommonDevice == null)
|
{
|
continue;
|
}
|
nowRoom.DeviceUIList.Add(tempCommon);
|
}
|
//场景(SceneUI)
|
nowRoom.SceneUIList.Clear();
|
foreach (var sceneUIFilePath in nowRoom.SceneUIFilePathList)
|
{
|
var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(sceneUIFilePath));
|
var tempScene = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(jsonInfo);
|
if (tempScene == null)
|
{
|
continue;
|
}
|
nowRoom.SceneUIList.Add(tempScene);
|
}
|
return nowRoom;
|
}
|
catch(Exception ex)
|
{
|
return null;
|
}
|
}
|
|
/// <summary>
|
/// 根据房间Id，获取房间对象
|
/// </summary>
|
/// <returns>The room by name.</returns>
|
/// <param name="roomId">房间ID</param>
|
public Room GetRoomById(string roomId)
|
{
|
if (string.IsNullOrEmpty(roomId))
|
{
|
return null;
|
}
|
return Lists.Find((obj) => obj.Id == roomId);
|
}
|
|
/// <summary>
|
/// 根据房间名字，获取房间对象
|
/// </summary>
|
/// <returns>The room by name.</returns>
|
/// <param name="roomName">房间名</param>
|
public Room GetRoomByName(string roomName)
|
{
|
return Lists.Find((obj) => obj.Name == roomName);
|
}
|
|
/// <summary>
|
/// 根据设备获取房间名字(楼层+房间名)
|
/// </summary>
|
/// <returns>房间名</returns>
|
/// <param name="device">设备对象</param>
|
public string GetRoomNameByDevice(CommonDevice device)
|
{
|
var room = this.GetRoomByDevice(device);
|
if (room == null)
|
{
|
//未分配区域
|
return Language.StringByID(R.MyInternationalizationString.uDeviceNotAssignedRoom);
|
}
|
if (Config.Instance.Home.FloorDics.ContainsKey(room.FloorId) == true)
|
{
|
//(楼层+房间名)
|
return Config.Instance.Home.FloorDics[room.FloorId] + " " + room.Name;
|
}
|
return room.Name;
|
}
|
|
/// <summary>
|
/// 获取设备所在的房间
|
/// </summary>
|
/// <returns>The room by device.</returns>
|
/// <param name="device">设备对象</param>
|
public Room GetRoomByDevice(CommonDevice device)
|
{
|
string deviceFile = device.FilePath;
|
return Lists.Find((obj) => obj.IsLove == false && obj.DeviceUIFilePathList.Contains(deviceFile));
|
}
|
|
/// <summary>
|
/// 通过场景id获取房间名
|
/// </summary>
|
/// <returns>The room name by scene identifier.</returns>
|
/// <param name="sceneId">Scene identifier.</param>
|
public string GetRoomNameBySceneId(int sceneId)
|
{
|
var room = GetRoomBySceneId(sceneId);
|
if (room == null)
|
{
|
return null;
|
}
|
return room.Name;
|
}
|
|
/// <summary>
|
/// 通过场景id获取房间对象
|
/// </summary>
|
/// <returns>The room by scene identifier.</returns>
|
/// <param name="sceneId">Scene identifier.</param>
|
public Room GetRoomBySceneId(int sceneId)
|
{
|
foreach (var r in Lists)
|
{
|
if(r.IsLove)
|
{
|
continue;
|
}
|
foreach (var scene in r.SceneUIList)
|
{
|
if (scene.Id == sceneId)
|
{
|
return r;
|
}
|
}
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 获取当前楼层的房间
|
/// </summary>
|
/// <param name="id"></param>
|
/// <returns></returns>
|
public List<Room> GetRoomsByFloorId(string id)
|
{
|
try
|
{
|
if (Lists == null || Lists.Count == 0 || Lists.Count == 1)
|
{
|
return null;
|
}
|
if (Config.Instance.Home.FloorDics.Count == 0)
|
{
|
return Lists;
|
}
|
return Lists.FindAll((obj) => obj.FloorId == id);
|
}
|
catch(Exception ex)
|
{
|
System.Console.WriteLine(ex.Message);
|
return null;
|
}
|
|
}
|
/// <summary>
|
/// 获取当前楼层的房间名称
|
/// </summary>
|
/// <param name="id"></param>
|
/// <returns></returns>
|
public List<string> GetRoomNamesByFloorId(string id)
|
{
|
List<string> names = new List<string> { };
|
foreach (var r in Lists)
|
{
|
if (r.FloorId == id)
|
{
|
names.Add(r.Name);
|
}
|
}
|
return names;
|
}
|
|
/// <summary>
|
/// 获取当前楼层的房间(拼接了【常用】在第一位)
|
/// </summary>
|
/// <param name="id"></param>
|
/// <returns></returns>
|
public List<Room> GetRoomsByFloorIdAppendLoveRoom(string id)
|
{
|
if (Config.Instance.Home.FloorDics.Count == 0)
|
{
|
return Lists;
|
}
|
var r= Lists.FindAll((obj) => obj.FloorId == id);
|
r.Insert(0, GetLoveRoom());
|
return r;
|
}
|
|
/// <summary>
|
/// 获取当前楼层的房间(拼接了【常用】在第一位)
|
/// </summary>
|
/// <returns></returns>
|
public List<Room> GetRoomsByCurrentFloorIdAppendLoveRoom()
|
{
|
if(Config.Instance.Home.FloorDics.Count==0)
|
{
|
return Lists;
|
}
|
var r = Lists.FindAll((obj) => obj.FloorId == Config.Instance.Home.CurrentFloorId);
|
r.Insert(0, GetLoveRoom());
|
return r;
|
}
|
|
#endregion
|
|
#region ◆ 房间方法________________________
|
|
/// <summary>
|
/// 设备的房间变更
|
/// </summary>
|
/// <param name="device">设备对象</param>
|
/// <param name="roomId">新房间Id</param>
|
/// <param name="saveRealRoom">是否修改真实物理设备的房间,不出意外,这个值默认为true即可</param>
|
public void ChangedRoom(CommonDevice device, string roomId, bool saveRealRoom = true)
|
{
|
//房间是否修改
|
if (this.IsRoomChanged(device, roomId) == false)
|
{
|
return;
|
}
|
//从原来的房间移除设备
|
this.DeleteDevice(device);
|
|
//添加到新的房间
|
var room = this.GetRoomById(roomId);
|
if (room != null)
|
{
|
room.AddDevice(device, saveRealRoom);
|
}
|
}
|
|
/// <summary>
|
/// 房间名字是否有修改
|
/// </summary>
|
/// <param name="device">设备对象</param>
|
/// <param name="roomId">新房间Id</param>
|
/// <returns></returns>
|
public bool IsRoomChanged(CommonDevice device, string roomId)
|
{
|
var room = this.GetRoomByDevice(device);
|
if (room == null || room.Id != roomId)
|
{
|
return true;
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// 获取房间所在区域
|
/// 楼层,房间名
|
/// </summary>
|
/// <returns></returns>
|
public string GetZoneName()
|
{
|
if (string.IsNullOrEmpty(FloorId))
|
{
|
return Name;
|
}
|
var floorName = Config.Instance.Home.GetFloorNameById(FloorId);
|
if (floorName == null)
|
{
|
return Name;
|
}
|
return $"{floorName},{Name}";
|
}
|
|
#endregion
|
|
#region ◆ 更新房间_________________________
|
|
/// <summary>
|
/// Updates the memorry.
|
/// </summary>
|
/// <param name="roomFilePath">Room file path.</param>
|
public static void UpdateMemorry(string roomFilePath)
|
{
|
GetRoomByFilePath(roomFilePath);
|
}
|
|
#endregion
|
|
#region ◆ 房间背景图的相关___________________
|
|
/// <summary>
|
/// 移动背景图片到住宅目录下
|
/// </summary>
|
/// <param name="oldFile">需要移动的文件(直接文件名)</param>
|
/// <param name="newFile">要移动到的位置-(包含住宅路径：住宅/文件名)</param>
|
public void MoveBackGroundIamageFileToDirectory(string oldFile, string newFile)
|
{
|
try
|
{
|
var newPath = System.IO.Path.Combine(Config.Instance.FullPath, newFile);
|
var path = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath,oldFile);
|
Global.MoveFileToDirectory(path, newPath);
|
//备份
|
Phone.UserCenter.HdlAutoBackupLogic.AddOrEditorFile(oldFile);
|
//Save();
|
}
|
catch (Exception ex)
|
{
|
System.Console.WriteLine("移动图片异常 " + ex.Message);
|
}
|
}
|
|
#endregion
|
|
#region ◆ 添加设备________________________
|
|
/// <summary>
|
/// 添加设备(此方法目前只给【我的喜爱】使用)
|
/// </summary>
|
/// <param name="deviceUIFilePath">Device UIF ile path.</param>
|
public void AddDevice(string deviceUIFilePath)
|
{
|
if (string.IsNullOrEmpty(deviceUIFilePath))
|
{
|
return;
|
}
|
var deviceUI = Common.LocalDevice.Current.GetDeviceUI(deviceUIFilePath);
|
if (null == deviceUI.CommonDevice)
|
{
|
//当前对象数据无效
|
return;
|
}
|
if (!DeviceUIFilePathList.Contains(deviceUIFilePath) && !DeviceUIList.Contains(deviceUI))
|
{
|
DeviceUIFilePathList.Add(deviceUIFilePath);
|
DeviceUIList.Add(deviceUI);
|
}
|
//保存到本地
|
Save();
|
}
|
|
/// <summary>
|
/// 添加设备(此方法目前只给Room里面使用)
|
/// </summary>
|
/// <param name="device">要添加的设备对象</param>
|
/// <param name="saveRealRoom">是否修改真实物理设备的房间,不出意外,这个值默认为true即可</param>
|
public void AddDevice(CommonDevice device, bool saveRealRoom)
|
{
|
if (device == null)
|
{
|
return;
|
}
|
//设备信息保存到本地
|
device.Save();
|
|
var deviceUI = Common.LocalDevice.Current.GetDeviceUI(device);
|
if (DeviceUIFilePathList.Contains(deviceUI.FileName) == false)
|
{
|
DeviceUIFilePathList.Add(deviceUI.FileName);
|
DeviceUIList.Add(deviceUI);
|
//保存到本地
|
Save();
|
|
if (saveRealRoom == true && LocalDevice.Current.GetDevicesCountByMac(device.DeviceAddr) == 1)
|
{
|
//如果只有一个回路,则修改真实物理设备的房间
|
LocalDevice.Current.SaveRealDeviceRoomId(new List<CommonDevice>() { device }, this.Id, false);
|
}
|
}
|
}
|
|
#endregion
|
|
#region ◆ 删除设备_________________________
|
/// <summary>
|
/// 删除功能-设备
|
/// </summary>
|
/// <param name="deviceUIFilePath">Device UIF ile path.</param>
|
public void DeleteDevice(string deviceUIFilePath)
|
{
|
if (deviceUIFilePath == null) return;
|
if (DeviceUIFilePathList.Contains(deviceUIFilePath))
|
{
|
DeviceUIFilePathList.Remove(deviceUIFilePath);
|
DeviceUIList.RemoveAll((obj) => obj.FileName == deviceUIFilePath);
|
Save();
|
}
|
}
|
|
/// <summary>
|
/// 删除设备
|
/// </summary>
|
/// <param name="device">要删除的设备对象</param>
|
public void DeleteDevice(CommonDevice device)
|
{
|
if (device == null)
|
{
|
return;
|
}
|
//根据设备，获取所在的房间
|
var room = this.GetRoomByDevice(device);
|
if (room == null)
|
{
|
return;
|
}
|
string deviceFile = device.FilePath;
|
//移除缓存
|
if (room.DeviceUIFilePathList.Contains(deviceFile) == false)
|
{
|
return;
|
}
|
room.DeviceUIFilePathList.Remove(deviceFile);
|
|
room.DeviceUIList.RemoveAll((obj) => obj.FileName == deviceFile);
|
room.Save();
|
//更改自动备份
|
HdlAutoBackupLogic.AddOrEditorFile(room.FileName);
|
|
//递归：删除掉以前的旧数据导致的多个房间的问题
|
this.DeleteDevice(device);
|
}
|
|
/// <summary>
|
/// 删除我的喜爱的设备
|
/// </summary>
|
/// <param name="device">要删除的设备对象</param>
|
public void DeleteLoveDevice(CommonDevice device)
|
{
|
if (device == null)
|
{
|
return;
|
}
|
//我的喜爱
|
var loveRoom = this.GetLoveRoom();
|
if (loveRoom != null)
|
{
|
string deviceFile = device.FilePath;
|
//移除缓存
|
if (loveRoom.DeviceUIFilePathList.Contains(deviceFile) == false)
|
{
|
return;
|
}
|
loveRoom.DeviceUIFilePathList.Remove(deviceFile);
|
loveRoom.DeviceUIList.RemoveAll((obj) => obj.FileName == deviceFile);
|
}
|
}
|
|
#endregion
|
|
#region ◆ 获取设备_________________________
|
|
/// <summary>
|
/// 根据设备获取它的UI对象，如果不存在则新建
|
/// </summary>
|
/// <returns>The device user interface.</returns>
|
/// <param name="device">设备对象</param>
|
public DeviceUI GetDeviceUI(CommonDevice device)
|
{
|
return Common.LocalDevice.Current.GetDeviceUI(device);
|
}
|
|
/// <summary>
|
/// 获取当前房间下的全部设备
|
/// </summary>
|
/// <returns></returns>
|
public List<CommonDevice> GetRoomListDevice()
|
{
|
var listDevice = new List<CommonDevice>();
|
foreach (var device in this.DeviceUIList)
|
{
|
if (device == null || device.CommonDevice == null)
|
{
|
continue;
|
}
|
listDevice.Add(device.CommonDevice);
|
}
|
return listDevice;
|
}
|
|
/// <summary>
|
/// 获取房间设备类型
|
/// </summary>
|
/// <param name="room"></param>
|
/// <returns></returns>
|
public static List<DeviceType> GetdeviceTypes(Room room)
|
{
|
List<DeviceType> typeList = new List<DeviceType> { };
|
foreach (var deviceUI in room.DeviceUIList)
|
{
|
if (deviceUI == null || deviceUI.CommonDevice == null)
|
{
|
continue;
|
}
|
if (!typeList.Contains(deviceUI.CommonDevice.Type))
|
{
|
typeList.Add(deviceUI.CommonDevice.Type);
|
}
|
}
|
return typeList;
|
}
|
|
/// <summary>
|
/// 获取该类型的设备
|
/// </summary>
|
/// <param name="room"></param>
|
/// <param name="deviceType"></param>
|
/// <returns></returns>
|
public static List<DeviceUI> GetDeviceUIs(Room room ,DeviceType deviceType)
|
{
|
List<DeviceUI> typeList = new List<DeviceUI> { };
|
foreach (var deviceUI in room.DeviceUIList)
|
{
|
if (deviceUI == null || deviceUI.CommonDevice == null)
|
{
|
continue;
|
}
|
if(deviceUI.CommonDevice.Type!=deviceType)
|
{
|
continue;
|
}
|
if (!typeList.Contains(deviceUI))
|
{
|
typeList.Add(deviceUI);
|
}
|
}
|
return typeList;
|
}
|
|
/// <summary>
|
/// 获取未分配区域设备
|
/// </summary>
|
/// <returns></returns>
|
public List<DeviceUI> GetUnalloctedDeviceUIs()
|
{
|
List<DeviceUI> deviceUIs = new List<DeviceUI> { };
|
var dList = AllRoomDeviceUIList;
|
var commonDeviceList = Common.LocalDevice.Current.listAllDevice;
|
|
foreach (var device in commonDeviceList)
|
{
|
if (dList.Find((obj) => obj.CommonDevice.DeviceEpoint == device.DeviceEpoint && obj.CommonDevice.DeviceAddr == device.DeviceAddr) == null)
|
{
|
deviceUIs.Add(Common.LocalDevice.Current.GetDeviceUI(device));
|
}
|
}
|
if (deviceUIs.Count == 0)
|
{
|
return null;
|
}
|
return deviceUIs;
|
}
|
|
//public List<DeviceUI> GetUnalloctedDeviceUITypes
|
|
#endregion
|
|
#region ◆ 添加场景_________________________
|
|
/// <summary>
|
/// 添加场景 0失败 1成功 -1已经存在
|
/// </summary>
|
/// <returns>The scene.</returns>
|
/// <param name="sceneName">Scene name.</param>
|
/// <param name="sceneIconPath">背景图片，不包含住宅路径 如果iconPathType=1或者2 需要拼接住宅 变成 住宅/sceneIconPath</param>
|
/// <param name="commons">Commons.</param>
|
/// <param name="iconPathType">I场景背景图片来源类型 图片来源 0--本地图库 1--拍照 2--系统图库 默认0</param>
|
public async System.Threading.Tasks.Task<int> AddScene(string sceneName, string sceneIconPath, List<ZigBee.Device.Scene.AddSceneMemberData> commons, int iconPathType)
|
{
|
//var scenes = GetSceneUIsByFloorId(FloorId);
|
//if(scenes!=null && scenes.Count>0)
|
//{
|
// if (scenes.Find(s => s.Name == sceneName) != null)
|
// {
|
// return -1;
|
// }
|
//}
|
|
var getSceneIdAllData = await ZigBee.Device.Scene.GetSceneNewIdAsync(sceneName);
|
if (getSceneIdAllData == null || getSceneIdAllData.getSceneIdData == null)
|
{
|
return 0;
|
}
|
var getSceneIdData = getSceneIdAllData.getSceneIdData;
|
|
bool result = true;
|
foreach (var common in commons)
|
{
|
//添加新成员
|
var addSceneMemberData = new ZigBee.Device.Scene.AddSceneMemberData
|
{
|
Type = common.Type,
|
DeviceAddr = common.DeviceAddr,
|
Epoint = common.Epoint,
|
ScenesId = getSceneIdData.NewScenesId,
|
TaskList = common.TaskList,
|
DelayTime = common.DelayTime,
|
MemberNumber=common.MemberNumber,
|
ElseScenesId = common.ElseScenesId
|
};
|
//common.ScenesId = getSceneIdData.NewScenesId;
|
//添加新成员 返回结果
|
var addSceneMemberResponseAllData = await ZigBee.Device.Scene.AddSceneMemberAsync(addSceneMemberData);
|
if (addSceneMemberResponseAllData == null || addSceneMemberResponseAllData.addSceneMemberResponseData == null)
|
{
|
continue;
|
}
|
var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
|
if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
|
{
|
result = false;
|
}
|
}
|
//加入成功
|
if (result)
|
{
|
var sceneUI = new SceneUI
|
{
|
Name = sceneName,
|
Id = getSceneIdData.NewScenesId,
|
IconPath = sceneIconPath,
|
IconPathType = iconPathType,
|
AddSceneMemberDataList= commons
|
};
|
sceneUI.Save();
|
SceneUIList.Add(sceneUI);
|
SceneUIFilePathList.Add(sceneUI.FileName);
|
Save();
|
return 1;
|
}
|
return 0;
|
}
|
|
/// <summary>
|
/// 添加场景
|
/// </summary>
|
/// <param name="scene">Scene.</param>
|
public void AddScene(SceneUI scene)
|
{
|
SceneUIList.Add(scene);
|
SceneUIFilePathList.Add(scene.FileName);
|
Save();
|
}
|
|
/// <summary>
|
/// 删除场景
|
/// </summary>
|
/// <param name="scene"></param>
|
public void DeleteScene(SceneUI scene)
|
{
|
var curScene = SceneUIList.Find((obj) => obj.Id == scene.Id);
|
if (curScene == null)
|
{
|
return;
|
}
|
SceneUIList.Remove(curScene);
|
SceneUIFilePathList.Remove(curScene.FileName);
|
Save();
|
}
|
|
#endregion
|
|
#region ◆ 设备是否收藏______________________
|
|
/// <summary>
|
/// 是否是收藏设备
|
/// </summary>
|
/// <param name="filePath"></param>
|
/// <returns></returns>
|
public bool IsCollectInRoom(string filePath)
|
{
|
if (GetLoveRoom().DeviceUIFilePathList.Find((obj) => obj == filePath) == null)
|
{
|
return false;
|
}
|
return true;
|
}
|
#endregion
|
|
#region ◆ 修改场景________________________
|
|
/// <summary>
|
/// 修改场景设备 0失败 1成功
|
/// </summary>
|
/// <returns>The scene.</returns>
|
/// <param name="sceneUI">Scene user interface.</param>
|
/// <param name="sceneRemoveMemberData">Scene remove member data.</param>
|
/// <param name="addCommons">Add commons.</param>
|
public async System.Threading.Tasks.Task<int> ModifyScene(SceneUI sceneUI, Scene.SceneRemoveMemberData sceneRemoveMemberData, List<Scene.AddSceneMemberData> addCommons)
|
{
|
//if (AllRoomSceneUIList.Find(s => s.Name == sceneUI.Name) == null)
|
//{
|
// return 0;
|
//}
|
|
bool result = true;
|
//移除成员 返回结果
|
var removeSceneMemberResponseAllData = await ZigBee.Device.Scene.RemoveSceneMemberAsync(sceneRemoveMemberData);
|
if (removeSceneMemberResponseAllData == null || removeSceneMemberResponseAllData.removeSceneMemberResponseData == null)
|
{
|
return 0;
|
}
|
var removeSceneMemberResponseData = removeSceneMemberResponseAllData.removeSceneMemberResponseData;
|
if (removeSceneMemberResponseData == null)
|
{
|
return 0;
|
}
|
if (removeSceneMemberResponseData.Result != 0)
|
{
|
result = false;
|
}
|
//添加
|
foreach (var addCommon in addCommons)
|
{
|
//添加新成员
|
var addSceneMemberData = new ZigBee.Device.Scene.AddSceneMemberData
|
{
|
DeviceAddr = addCommon.DeviceAddr,
|
Type = addCommon.Type,
|
Epoint = addCommon.Epoint,
|
ScenesId = sceneUI.Id,
|
TaskList = addCommon.TaskList,
|
DelayTime = addCommon.DelayTime,
|
ElseScenesId = addCommon.ElseScenesId,
|
MemberNumber=addCommon.MemberNumber
|
};
|
//添加新成员 返回结果
|
var addSceneMemberResponseAllData = await ZigBee.Device.Scene.AddSceneMemberAsync(addSceneMemberData);
|
if (addSceneMemberResponseAllData == null || addSceneMemberResponseAllData.addSceneMemberResponseData == null)
|
{
|
result = false;
|
System.Console.WriteLine("添加场景失败");
|
continue;
|
}
|
var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
|
if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
|
{
|
result = false;
|
}
|
}
|
//加入成功
|
if (result)
|
{
|
sceneUI.AddSceneMemberDataList = addCommons;
|
sceneUI.Save();
|
if (IsLove == false)
|
{
|
var curScene = Common.Room.CurrentRoom.GetLoveRoom().SceneUIList.Find((obj) => obj.Id == sceneUI.Id);
|
if (curScene != null)
|
{
|
curScene.Name = sceneUI.Name;
|
curScene.IconPath = sceneUI.IconPath;
|
curScene.IconPathType = sceneUI.IconPathType;
|
curScene.AddSceneMemberDataList = sceneUI.AddSceneMemberDataList;
|
curScene.SceneDelayTime = sceneUI.SceneDelayTime;
|
curScene.Save(false);
|
Common.Room.CurrentRoom.GetLoveRoom().Save();
|
}
|
}
|
return 1;
|
}
|
return 0;
|
}
|
|
/// <summary>
|
/// 设置、同步延时时间
|
/// </summary>
|
/// <param name="scene"></param>
|
public void ModifySceneDelayTime(SceneUI scene)
|
{
|
if (IsLove)
|
{
|
foreach (var r in Lists)
|
{
|
if (r.IsLove || r.SceneUIList.Count == 0)
|
{
|
continue;
|
}
|
foreach (var sce in r.SceneUIList)
|
{
|
if (sce.Id == scene.Id)
|
{
|
sce.SceneDelayTime = scene.SceneDelayTime;
|
sce.Save(false);
|
r.Save(false);
|
break;
|
}
|
}
|
}
|
}
|
else
|
{
|
var curScene = Common.Room.CurrentRoom.GetLoveRoom().SceneUIList.Find((obj) => obj.Id == scene.Id);
|
if (curScene != null)
|
{
|
curScene.SceneDelayTime = scene.SceneDelayTime;
|
curScene.Save(false);
|
Common.Room.CurrentRoom.GetLoveRoom().Save(false);
|
}
|
}
|
}
|
|
#endregion
|
|
#region ◆ 删除场景________________________
|
|
/// <summary>
|
/// 移除场景--该仅进行了对本地场景数据的删除
|
/// </summary>
|
/// <param name="sceneUI">Scene user interface.</param>
|
public void RemoveScene(SceneUI sceneUI)
|
{
|
if(Global.IsExistsByHomeId(sceneUI.FileName)==false)
|
{
|
return;
|
}
|
|
if (sceneUI.IconPathType == 1 || sceneUI.IconPathType == 2)
|
{
|
if (Global.IsExistsByHomeId(sceneUI.IconPath))
|
{
|
Global.DeleteFilebyHomeId(sceneUI.IconPath);
|
HdlAutoBackupLogic.DeleteFile(sceneUI.IconPath);
|
}
|
}
|
|
if (IsLove == false)
|
{
|
if (CurrentRoom.GetLoveRoom().SceneUIList.Find((obj) => obj.Id == sceneUI.Id) != null)
|
{
|
CurrentRoom.GetLoveRoom().DeleteScene(sceneUI);
|
}
|
}
|
|
SceneUIList.Remove(sceneUI);
|
SceneUIFilePathList.Remove(sceneUI.FileName);
|
Save();
|
|
Global.DeleteFilebyHomeId(sceneUI.FileName);
|
HdlAutoBackupLogic.DeleteFile(sceneUI.FileName);
|
}
|
|
#endregion
|
|
#region ◆ 获取场景________________________
|
|
/// <summary>
|
/// 通过场景id获取场景
|
/// </summary>
|
/// <returns>The scene UIB y scene identifier.</returns>
|
/// <param name="sceneId">Scene identifier.</param>
|
public SceneUI GetSceneUIBySceneId(int sceneId)
|
{
|
foreach (var r in Lists)
|
{
|
if (r.IsLove)
|
{
|
continue;
|
}
|
foreach (var sceneUI in r.SceneUIList)
|
{
|
if (sceneUI.Id == sceneId)
|
{
|
return sceneUI;
|
}
|
}
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 获取该楼层所有场景
|
/// </summary>
|
/// <param name="floorId"></param>
|
/// <returns></returns>
|
public List<SceneUI> GetSameFloorScenes(string floorId)
|
{
|
List<SceneUI> sceneUIs = new List<SceneUI> { };
|
var rooms= CurrentRoom.GetRoomsByFloorId(floorId);
|
foreach(var r in rooms)
|
{
|
sceneUIs.AddRange(r.SceneUIList);
|
}
|
return sceneUIs;
|
}
|
|
/// <summary>
|
/// 获取该楼层的场景
|
/// </summary>
|
/// <param name="floorId"></param>
|
/// <returns></returns>
|
public List<SceneUI> GetSceneUIsByFloorId(string floorId)
|
{
|
var rooms = GetRoomsByFloorId(floorId);
|
if (rooms == null)
|
{
|
return null;
|
}
|
var sceneList = new List<SceneUI> { };
|
foreach (var r in rooms)
|
{
|
if (r.SceneUIList.Count == 0)
|
{
|
continue;
|
}
|
foreach (var sceneUI in r.SceneUIList)
|
{
|
if (sceneUI == null)
|
{
|
continue;
|
}
|
sceneList.Add(sceneUI);
|
}
|
}
|
return sceneList;
|
}
|
|
/// <summary>
|
/// 获取未分配区域场景
|
/// </summary>
|
/// <returns></returns>
|
public List<SceneUI> GetUnalloctedScenes()
|
{
|
List<SceneUI> sceneUIs = new List<SceneUI> { };
|
var sList = AllRoomSceneUIFilepathList;
|
|
List<string> sfile = new List<string> { };
|
foreach (var path in Global.FileListByHomeId())
|
{
|
if (path.StartsWith("Scene_", StringComparison.Ordinal))
|
{
|
sfile.Add(path);
|
}
|
}
|
foreach (var path in sfile)
|
{
|
if (sList.Find((obj) => obj == path) == null)
|
{
|
var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(path));
|
var tempSceneUI = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(jsonInfo);
|
if (tempSceneUI != null)
|
{
|
sceneUIs.Add(tempSceneUI);
|
}
|
}
|
}
|
if (sceneUIs.Count == 0)
|
{
|
return null;
|
}
|
return sceneUIs;
|
}
|
|
#endregion
|
|
#region ◆ 刷新场景_________________________
|
|
/// <summary>
|
/// 刷新房间的场景列表
|
/// </summary>
|
public async System.Threading.Tasks.Task<bool> RefreshSceneUIList()
|
{
|
bool result = true;
|
var sceneList = await ZigBee.Device.Scene.GetSceneListAsync();
|
if (sceneList == null)
|
{
|
return false;
|
}
|
List<int> sceneIDList = new List<int> { };
|
foreach (var scene in sceneList)
|
{
|
if (scene == null)
|
{
|
continue;
|
}
|
sceneIDList.Add(scene.ScenesId);
|
}
|
foreach (var r in Lists)
|
{
|
if(r.IsLove)
|
{
|
continue;
|
}
|
if (r.SceneUIList == null || r.SceneUIList.Count == 0)
|
{
|
continue;
|
}
|
foreach (var rScene in r.SceneUIList)
|
{
|
if (rScene == null)
|
{
|
continue;
|
}
|
if (sceneIDList.Contains(rScene.Id) == false)
|
{
|
r.RemoveScene(rScene);
|
result = true;
|
}
|
}
|
}
|
return result;
|
}
|
|
#endregion
|
|
#region ◆ 保存____________________________
|
|
/// <summary>
|
/// 保存
|
/// </summary>
|
/// <param name="autoBackup">是否自动备份，默认true</param>
|
public void Save(bool autoBackup = true)
|
{
|
//保存房间信息
|
Global.WriteFileByBytesByHomeId(FileName, System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(this)));
|
if (autoBackup == true)
|
{
|
HdlAutoBackupLogic.AddOrEditorFile(FileName);
|
}
|
}
|
|
#endregion
|
|
#region ◆ 楼层和房间顺序相关_______________
|
|
/// <summary>
|
/// 根据楼层的主键获取排序后的房间列表
|
/// </summary>
|
/// <param name="i_floorKeys">楼层的主键</param>
|
/// <param name="getShard">分享的房间是否也获取</param>
|
/// <returns></returns>
|
public List<Room> GetFloorSortRoom(string i_floorKeys, bool getShard = true)
|
{
|
Dictionary<string, List<string>> dicAllSort = new Dictionary<string, List<string>>();
|
//读取房间顺序
|
string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.RoomSortFile);
|
var strData = UserCenterLogic.LoadFileContent(fullName);
|
if (strData != null)
|
{
|
dicAllSort = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, List<string>>>(strData);
|
}
|
|
var listRoomSort = new List<string>();
|
if (dicAllSort.ContainsKey(i_floorKeys) == true)
|
{
|
listRoomSort = dicAllSort[i_floorKeys];
|
}
|
else
|
{
|
dicAllSort[i_floorKeys] = listRoomSort;
|
}
|
|
var dicRoom = new Dictionary<string, Common.Room>();
|
foreach (var room in Common.Room.Lists)
|
{
|
if (room.FloorId != i_floorKeys || room.IsLove == true)
|
{
|
//不是同一个楼层
|
continue;
|
}
|
if (listRoomSort.Contains(room.Id) == false)
|
{
|
//新添加的房间
|
listRoomSort.Add(room.Id);
|
}
|
if (getShard == false && room.IsSharedRoom == true)
|
{
|
//不要分享的房间
|
continue;
|
}
|
dicRoom[room.Id] = room;
|
}
|
|
var listSortRoom = new List<Room>();
|
for (int i = 0; i < listRoomSort.Count; i++)
|
{
|
if (dicRoom.ContainsKey(listRoomSort[i]) == true)
|
{
|
listSortRoom.Add(dicRoom[listRoomSort[i]]);
|
}
|
}
|
|
//保存顺序
|
UserCenterLogic.SaveFileContent(fullName, dicAllSort);
|
return listSortRoom;
|
}
|
|
/// <summary>
|
/// 保存房间的顺序
|
/// </summary>
|
/// <param name="i_floorKeys">楼层主键</param>
|
/// <param name="listSort">房间顺序(房间的主键)</param>
|
public void SaveRoomSort(string i_floorKeys, List<string> listSort)
|
{
|
Dictionary<string, List<string>> dicAllSort = new Dictionary<string, List<string>>();
|
//读取房间顺序
|
string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.RoomSortFile);
|
var strData = UserCenterLogic.LoadFileContent(fullName);
|
if (strData != null)
|
{
|
dicAllSort = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, List<string>>>(strData);
|
}
|
|
//保存顺序
|
dicAllSort[i_floorKeys] = listSort;
|
UserCenterLogic.SaveFileContent(fullName, dicAllSort);
|
dicAllSort.Clear();
|
}
|
|
/// <summary>
|
/// 获取排序后的楼层
|
/// </summary>
|
/// <returns></returns>
|
public Dictionary<string, string> GetFloorSortList()
|
{
|
//读取楼层顺序
|
var listFloorSort = new List<string>();
|
string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.FloorSortFile);
|
var strData = UserCenterLogic.LoadFileContent(fullName);
|
if (strData != null)
|
{
|
listFloorSort = Newtonsoft.Json.JsonConvert.DeserializeObject<List<string>>(strData);
|
}
|
foreach (string keys in Common.Config.Instance.Home.FloorDics.Keys)
|
{
|
if (listFloorSort.Contains(keys) == false)
|
{
|
//新添加的楼层
|
listFloorSort.Add(keys);
|
}
|
}
|
|
var dic = new Dictionary<string, string>();
|
for (int i = 0; i < listFloorSort.Count; i++)
|
{
|
if (Config.Instance.Home.FloorDics.ContainsKey(listFloorSort[i]) == true)
|
{
|
dic[listFloorSort[i]] = Config.Instance.Home.FloorDics[listFloorSort[i]];
|
}
|
}
|
|
//保存顺序
|
UserCenterLogic.SaveFileContent(fullName, listFloorSort);
|
return dic;
|
}
|
|
/// <summary>
|
/// 保存楼层的顺序
|
/// </summary>
|
/// <param name="listSort">楼层的主键</param>
|
public void SaveFloorSort(List<string> listSort)
|
{
|
string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.FloorSortFile);
|
//保存顺序
|
UserCenterLogic.SaveFileContent(fullName, listSort);
|
}
|
|
#endregion
|
|
#region ◆ 克隆房间对象_____________________
|
|
/// <summary>
|
/// 克隆房间对象
|
/// </summary>
|
/// <returns></returns>
|
public Room CloneRoomClass()
|
{
|
var newRoom = new Room();
|
//克隆属性
|
newRoom.Id = this.Id;
|
newRoom.FloorId = this.FloorId;
|
newRoom.TemperatrueDevice = this.TemperatrueDevice;
|
newRoom.HumidityDevice = this.HumidityDevice;
|
newRoom.Name = this.Name;
|
newRoom.BackgroundImage = this.BackgroundImage;
|
newRoom.BackgroundImageType = this.BackgroundImageType;
|
|
return newRoom;
|
}
|
|
#endregion
|
|
}
|
}
|
