using Shared.Common;
|
using System;
|
using System.Collections.Generic;
|
using System.Collections.Specialized;
|
using System.IO;
|
using System.Net;
|
using System.Text;
|
using ZigBee.Device;
|
|
namespace Shared.Phone
|
{
|
/// <summary>
|
/// 分享的逻辑
|
/// </summary>
|
public class HdlShardLogic
|
{
|
#region ■ 变量声明___________________________
|
|
/// <summary>
|
/// 分享的逻辑
|
/// </summary>
|
private static HdlShardLogic m_Current = null;
|
/// <summary>
|
/// 分享的逻辑
|
/// </summary>
|
public static HdlShardLogic Current
|
{
|
get
|
{
|
if (m_Current == null)
|
{
|
m_Current = new HdlShardLogic();
|
}
|
return m_Current;
|
}
|
set
|
{
|
m_Current = value;
|
}
|
}
|
/// <summary>
|
/// 分享压缩文件的名字
|
/// </summary>
|
private const string SHARED_BIN_FILE = "SharedData.bin";
|
/// <summary>
|
/// 分享的设备对象
|
/// </summary>
|
private Dictionary<string, CommonDevice> DicDevices = null;
|
/// <summary>
|
/// 分享的场景对象
|
/// </summary>
|
private Dictionary<int, SceneUI> DicScenes = new Dictionary<int, SceneUI>();
|
/// <summary>
|
/// 分享的房间信息
|
/// </summary>
|
private Dictionary<string, Room> DicRooms = new Dictionary<string, Room>();
|
/// <summary>
|
/// 分享的楼层信息
|
/// </summary>
|
private Dictionary<string, string> DicFloor = new Dictionary<string, string>();
|
/// <summary>
|
/// 分享的文件的主键(key:文件名,value:主键)
|
/// </summary>
|
private Dictionary<string, string> DicShardKeys = new Dictionary<string, string>();
|
|
#endregion
|
|
#region ■ 同步服务器的分享内容_______________
|
|
/// <summary>
|
/// 同步服务器的分享内容(里面只负责把东西存入本地)
|
/// </summary>
|
public bool SynchronizeDbSharedContent()
|
{
|
if (HdlUserCenterResourse.ResidenceOption.AuthorityNo != 3)
|
{
|
//只有成员才有这个概念
|
return true;
|
}
|
|
//获取主人分享给成员的文件列表
|
var listShardInfo = this.GetShardFileListFromDb(Config.Instance.Guid);
|
if (listShardInfo == null)
|
{
|
return false;
|
}
|
|
//主键
|
var dicAddMark = new Dictionary<string, string>();
|
//检测取消了共享的操作使用
|
var dicShardFile = new Dictionary<string, string>();
|
//获取前回共享文件的更新日期(keys:文件名字,value:更新日期)
|
var dicUpdateTime = this.GetAllShardFileAgoUpdateTime();
|
|
//先看看这分享数据里面有什么鬼
|
foreach (var info in listShardInfo)
|
{
|
//如果是压缩文件,需要特殊处理
|
if (info.FileName == SHARED_BIN_FILE)
|
{
|
//判断Bin文件的更新日期
|
if (dicUpdateTime.ContainsKey(info.FileName) == false
|
|| info.CreateTime.CompareTo(dicUpdateTime[info.FileName]) > 0)
|
{
|
dicAddMark[info.Id] = info.FileName;
|
//更新日更新
|
dicUpdateTime[info.FileName] = info.CreateTime;
|
}
|
continue;
|
}
|
dicShardFile[info.FileName] = info.Id;
|
|
//如果本地没有,或者更新日期大于前回更新日期的时候
|
if (Global.IsExistsByHomeId(info.FileName) == false
|
|| dicUpdateTime.ContainsKey(info.FileName) == false
|
|| info.CreateTime.CompareTo(dicUpdateTime[info.FileName]) > 0)
|
{
|
dicAddMark[info.Id] = info.FileName;
|
//更新日更新
|
dicUpdateTime[info.FileName] = info.CreateTime;
|
}
|
}
|
|
//不要忘记初始化这个东西
|
this.DicDevices = new Dictionary<string, CommonDevice>();
|
//从云端获取下来文件
|
if (dicAddMark.Count > 0)
|
{
|
//开启进度条 共享数据同步中
|
ProgressFormBar.Current.Start();
|
ProgressFormBar.Current.SetMsg(Language.StringByID(R.MyInternationalizationString.uShardDataIsSynchronizing));
|
|
//将分享的数据存入本地(获取的是本地没有的)
|
var listDbFile = this.SetShardFileToLocation(dicAddMark);
|
if (listDbFile == null)
|
{
|
//关闭
|
ProgressFormBar.Current.Close();
|
return false;
|
}
|
|
//转移文件
|
foreach (string fileName in listDbFile)
|
{
|
//不是bin文件,则移动文件到本地
|
if (fileName != SHARED_BIN_FILE)
|
{
|
var oldPath = Path.Combine(HdlFileNameResourse.DownLoadShardDirectory, fileName);
|
var newPath = Path.Combine(Config.Instance.FullPath, fileName);
|
HdlFileLogic.Current.CopyFile(oldPath, newPath);
|
}
|
else
|
{
|
//读取bin文件的内容
|
var dataContent = this.GetShardFileContent(fileName);
|
if (dataContent != null)
|
{
|
//解析bin文件
|
this.AdjustBinFileContent(Encoding.UTF8.GetString(dataContent));
|
}
|
}
|
}
|
}
|
|
//同步服务器的取消了的分享内容
|
return this.SynchronizeSharedCancelContent(dicShardFile, dicUpdateTime);
|
}
|
|
/// <summary>
|
/// 同步服务器的取消了的分享内容
|
/// </summary>
|
/// <param name="dicShardFile">云端上面分享的文件,key:文件名 value:主键</param>
|
/// <param name="dicUpdateTime">分享文件的更新时间,key:文件名 value:时间</param>
|
/// <returns></returns>
|
private bool SynchronizeSharedCancelContent(Dictionary<string, string> dicShardFile, Dictionary<string, string> dicUpdateTime)
|
{
|
//开启进度条 共享数据同步中
|
ProgressFormBar.Current.Start();
|
ProgressFormBar.Current.SetMsg(Language.StringByID(R.MyInternationalizationString.uShardDataIsSynchronizing));
|
|
//重新设置楼层
|
Config.Instance.Home.FloorDics.Clear();
|
foreach (var key in this.DicFloor.Keys)
|
{
|
Config.Instance.Home.FloorDics[key] = this.DicFloor[key];
|
}
|
//获取分享的设备的文件名
|
var listShardDeviceFile = new HashSet<string>();
|
foreach (var device in this.DicDevices.Values)
|
{
|
listShardDeviceFile.Add(device.FilePath);
|
}
|
//住宅的根目录
|
var localPath = Config.Instance.FullPath;
|
|
//然后检测本地的文件
|
var listLocalFile = HdlFileLogic.Current.GetRootPathListFile();
|
foreach (string fileName in listLocalFile)
|
{
|
try
|
{
|
if (dicShardFile.ContainsKey(fileName) == true)
|
{
|
//本地的这个文件还分享着,没有问题,或许应该只有分享图片
|
continue;
|
}
|
|
//检测本地设备文件,是否存在已经取消了共享了的
|
if (fileName.StartsWith("Device_") == true)
|
{
|
//判断是否还在分享的bin文件里面
|
if (listShardDeviceFile.Contains(fileName) == false)
|
{
|
//删除掉这个设备文件
|
HdlFileLogic.Current.DeleteFile(Path.Combine(localPath, fileName));
|
dicUpdateTime.Remove(fileName);
|
}
|
}
|
//检测本地房间文件,是否存在已经取消了共享了的
|
else if (fileName.StartsWith("Room_") == true)
|
{
|
var fullFile = Path.Combine(localPath, fileName);
|
var roomData = HdlFileLogic.Current.ReadFileTextContent(fullFile);
|
if (roomData != null)
|
{
|
var nowRoom = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(roomData);
|
if (nowRoom.IsSharedRoom == false || this.DicRooms.ContainsKey(nowRoom.Id) == true)
|
{
|
//这个房间是他自己创建的,或者还在分享着
|
continue;
|
}
|
//删除掉这个房间文件
|
HdlFileLogic.Current.DeleteFile(fullFile);
|
dicUpdateTime.Remove(fileName);
|
}
|
}
|
//检测本地场景文件,是否存在已经取消了共享了的
|
else if (fileName.StartsWith("Scene_") == true)
|
{
|
var fullFile = Path.Combine(localPath, fileName);
|
var sceneData = HdlFileLogic.Current.ReadFileTextContent(fullFile);
|
var nowScene = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(sceneData);
|
if (nowScene != null)
|
{
|
if (nowScene.IsSharedScene == false || this.DicScenes.ContainsKey(nowScene.Id) == true)
|
{
|
//这个场景是他自己创建的,或者还在分享着
|
continue;
|
}
|
//删除掉这个场景文件
|
HdlFileLogic.Current.DeleteFile(fullFile);
|
dicUpdateTime.Remove(fileName);
|
}
|
}
|
}
|
catch { }
|
}
|
|
//保存楼层数据
|
Config.Instance.Home.Save(false);
|
|
//网关文件非合法性是刷新设备列表的函数里面实现
|
|
//保存全部分享文件的更新日期
|
this.SaveAllShardFileAgoUpdateTime(dicUpdateTime);
|
//关闭
|
ProgressFormBar.Current.Close();
|
|
//释放缓存
|
this.Dispone();
|
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 同步内容更新时间___________________
|
|
/// <summary>
|
/// 获取全部分享文件的前回更新日期
|
/// </summary>
|
/// <returns></returns>
|
private Dictionary<string, string> GetAllShardFileAgoUpdateTime()
|
{
|
var dicTime = new Dictionary<string, string>();
|
var data = HdlFileLogic.Current.ReadFileByteContent(HdlFileNameResourse.ShardFileUpdateTimeFile);
|
if (data == null)
|
{
|
//目标文件不存在
|
return dicTime;
|
}
|
dicTime = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(System.Text.Encoding.UTF8.GetString(data));
|
return dicTime;
|
}
|
|
/// <summary>
|
/// 保存全部分享文件的更新日期
|
/// </summary>
|
/// <param name="dicTime"></param>
|
private void SaveAllShardFileAgoUpdateTime(Dictionary<string, string> dicTime)
|
{
|
HdlFileLogic.Current.SaveFileContent(HdlFileNameResourse.ShardFileUpdateTimeFile, dicTime);
|
}
|
|
#endregion
|
|
#region ■ 获取分享数据列表___________________
|
|
/// <summary>
|
/// 从云端获取分享的文件列表
|
/// </summary>
|
/// <param name="i_childAccountId">账号的id,成员登陆的话,直接传账号密码登陆之后,云端返回的那个id</param>
|
/// <returns></returns>
|
private List<ReceiveShardInfoResult> GetShardFileListFromDb(string i_childAccountId)
|
{
|
//获取主人分享给成员的文件列表
|
var pra = new { homeId = Config.Instance.HomeId, childAccountId = i_childAccountId };
|
var result = HdlHttpLogic.Current.RequestResponseFromZigbeeHttps("home-wisdom/app/home/share/findAll", RestSharp.Method.POST, pra, null, null, CheckMode.A账号权限);
|
//检测状态码
|
if (HdlCheckLogic.Current.CheckNetCode(result, ShowNetCodeMode.YES) == false)
|
{
|
return null;
|
}
|
var listShardInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<List<ReceiveShardInfoResult>>(result.Data.ToString());
|
|
return listShardInfo;
|
}
|
|
/// <summary>
|
/// 将分享的数据存入本地,返回的是文件名字(异常时返回null)
|
/// </summary>
|
/// <param name="dicFileKeys">key:文件的主键 value:文件名称</param>
|
/// <returns></returns>
|
private List<string> SetShardFileToLocation(Dictionary<string, string> dicFileKeys)
|
{
|
if (dicFileKeys.Count == 0)
|
{
|
return new List<string>();
|
}
|
//创建文件夹
|
string strDir = HdlFileNameResourse.DownLoadShardDirectory;
|
HdlFileLogic.Current.CreateDirectory(strDir, true);
|
|
int listMarkCount = dicFileKeys.Count;
|
|
List<string> listFile = new List<string>();
|
|
//不允许按系统的返回键
|
Config.Instance.BackKeyCanClick = false;
|
HdlUserCenterResourse.AccountOption.AppCanSignout = false;
|
|
//计数
|
int nowCount = 0;
|
foreach (var fileKey in dicFileKeys.Keys)
|
{
|
nowCount++;
|
var pra = new { homeId = Config.Instance.Home.Id, homeShareId = fileKey };
|
var result = HdlHttpLogic.Current.RequestByteFromZigbeeHttps("home-wisdom/app/home/share/downOne", RestSharp.Method.POST, pra, null, null, CheckMode.A账号权限, true, 10);
|
//检测状态码
|
if (result == null)
|
{
|
//允许按系统的返回键
|
Config.Instance.BackKeyCanClick = true;
|
HdlUserCenterResourse.AccountOption.AppCanSignout = true;
|
return null;
|
}
|
string shareName = dicFileKeys[fileKey];
|
//文件名字
|
listFile.Add(shareName);
|
//保存到指定文件夹下
|
HdlFileLogic.Current.SaveByteToFile(System.IO.Path.Combine(strDir, shareName), result);
|
//设置进度值
|
ProgressFormBar.Current.SetValue(nowCount, listMarkCount);
|
}
|
|
//允许按系统的返回键
|
Config.Instance.BackKeyCanClick = true;
|
HdlUserCenterResourse.AccountOption.AppCanSignout = true;
|
|
return listFile;
|
}
|
|
#endregion
|
|
|
#region ■ 初始化成员分享数据_________________
|
|
/// <summary>
|
/// 初始化成员共享列表然后保存到本地
|
/// </summary>
|
/// <param name="i_ChildAccountId">成员ID</param>
|
/// <returns></returns>
|
public bool InitMemberShardContentListAndSetToLocation(string i_ChildAccountId)
|
{
|
if (DicDevices != null)
|
{
|
//已经获取了,则不再获取
|
return true;
|
}
|
|
//正在获取分享数据
|
ProgressFormBar.Current.Start();
|
ProgressFormBar.Current.SetMsg(Language.StringByID(R.MyInternationalizationString.uShardContentGetting));
|
|
//从云端获取分享的文件列表
|
var listData = this.GetShardFileListFromDb(i_ChildAccountId);
|
if (listData == null)
|
{
|
//关闭进度条
|
ProgressFormBar.Current.Close();
|
return false;
|
}
|
|
//分享的压缩文件的主键
|
string shardBinKey = string.Empty;
|
foreach (var data in listData)
|
{
|
//如果是这个压缩文件
|
if (data.FileName == SHARED_BIN_FILE)
|
{
|
shardBinKey = data.Id;
|
}
|
//记录起它们的主键
|
this.DicShardKeys[data.FileName] = data.Id;
|
}
|
|
//下载压缩的bin文件,然后进行解析,其他文件不用理会
|
bool result = this.DownloadBinFileAndAdjust(shardBinKey);
|
//关闭进度条
|
ProgressFormBar.Current.Close();
|
|
return result;
|
}
|
|
/// <summary>
|
/// 下载压缩的bin文件,然后进行解析
|
/// </summary>
|
/// <param name="i_binFileId">压缩文件的主键</param>
|
/// <returns></returns>
|
private bool DownloadBinFileAndAdjust(string i_binFileId)
|
{
|
if (i_binFileId == string.Empty)
|
{
|
//不要忘记要初始化这个东西
|
this.DicDevices = new Dictionary<string, CommonDevice>();
|
return true;
|
}
|
var pra = new { homeId = Config.Instance.Home.Id, homeShareId = i_binFileId };
|
var result = HdlHttpLogic.Current.RequestByteFromZigbeeHttps("home-wisdom/app/home/share/downOne", RestSharp.Method.POST, pra, null, null, CheckMode.A账号权限, true, 10);
|
//检测状态码
|
if (result == null)
|
{
|
return false;
|
}
|
//不要忘记要初始化这个东西
|
this.DicDevices = new Dictionary<string, CommonDevice>();
|
|
//直接飙到100%
|
ProgressFormBar.Current.SetValue(1);
|
|
var fileContent = Encoding.UTF8.GetString(result);
|
//解析压缩的bin文件
|
this.AdjustBinFileContent(fileContent);
|
|
return true;
|
}
|
|
/// <summary>
|
/// 解析压缩的bin文件
|
/// </summary>
|
/// <param name="i_content"></param>
|
private void AdjustBinFileContent(string i_content)
|
{
|
var deviceType = string.Empty;
|
|
//根据换行符切分数据文本
|
string[] arryData = i_content.Split(new string[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
|
string strContentData = string.Empty;
|
foreach (string strData in arryData)
|
{
|
if (strData == "#START#")
|
{
|
//无附加数据的【数据标题】
|
continue;
|
}
|
if (strData.StartsWith("#DeviceInfo START#") == true)
|
{
|
//附加数据:设备对象类型
|
deviceType = strData.Substring(18);
|
continue;
|
}
|
//执行数据处理
|
try
|
{
|
//场景对象
|
if (strData == "#Scene END#")
|
{
|
var scene = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(strContentData);
|
this.DicScenes[scene.Id] = scene;
|
|
strContentData = string.Empty;
|
continue;
|
}
|
//楼层对象
|
else if (strData == "#FloorInfo END#")
|
{
|
this.DicFloor = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(strContentData);
|
|
strContentData = string.Empty;
|
continue;
|
}
|
//房间对象
|
else if (strData == "#RoomInfo END#")
|
{
|
var room = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(strContentData);
|
this.DicRooms[room.Id] = room;
|
|
strContentData = string.Empty;
|
continue;
|
}
|
//设备对象
|
else if (strData == "#DeviceInfo END#")
|
{
|
//反序列化设备
|
CommonDevice device = null;
|
if (HdlCheckLogic.Current.CheckIsNumber(deviceType) == true)
|
{
|
//数值型为新数据,直接转换
|
device = CommonDevice.CommonDeviceByByteString(Convert.ToInt32(deviceType), strContentData);
|
}
|
else
|
{
|
//字符串型为旧数据,需要特殊处理
|
var myType = (DeviceType)Enum.Parse(typeof(DeviceType), deviceType);
|
device = CommonDevice.CommonDeviceByByteString((int)myType, strContentData);
|
}
|
if (device != null)
|
{
|
this.DicDevices[HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device)] = device;
|
}
|
strContentData = string.Empty;
|
continue;
|
}
|
else
|
{
|
strContentData += strData;
|
}
|
}
|
catch (Exception ex)
|
{
|
HdlLogLogic.Current.WriteLog(ex, "分享bin文件出问题\r\n" + strContentData);
|
strContentData = string.Empty;
|
}
|
}
|
}
|
|
#endregion
|
|
|
#region ■ 上传分享内容_______________________
|
|
/// <summary>
|
/// 执行上传新的分享(设备和场景仅限同一个房间)
|
/// </summary>
|
/// <param name="i_ChildAccountId">成员的ID</param>
|
/// <param name="i_nowRoom">指定的房间</param>
|
/// <param name="i_listDevice">选择上传的设备(仅限一个房间)</param>
|
/// <param name="i_listScene">选择上传的场景(仅限一个房间,不要获取它里面的绑定列表)</param>
|
public bool UploadSharedContent(string i_ChildAccountId, Room i_nowRoom, List<CommonDevice> i_listDevice, List<SceneUI> i_listScene)
|
{
|
if (i_listDevice.Count == 0 && i_listScene.Count == 0)
|
{
|
return true;
|
}
|
//打开进度条
|
ProgressBar.Show();
|
|
var listCheck = new HashSet<string>();
|
|
//获取场景里面嵌套的子设备和子场景(这几个东西不加到房间)
|
var listChirdDevice = new List<CommonDevice>();
|
var listChirdScene = new List<SceneUI>();
|
foreach (var SceneTemp in i_listScene)
|
{
|
//从缓存获取场景的执行目标
|
this.GetSceneAdjustTargetListFromLocal(SceneTemp, listCheck, listChirdScene, listChirdDevice);
|
}
|
//克隆一个房间出来
|
var cloneRoom = HdlRoomLogic.Current.CloneRoomClass(i_nowRoom);
|
if (this.DicRooms.ContainsKey(cloneRoom.Id) == true)
|
{
|
//把原来的的东西也复制过来
|
cloneRoom.ListDevice.AddRange(this.DicRooms[cloneRoom.Id].ListDevice);
|
cloneRoom.ListDeviceMac.AddRange(this.DicRooms[cloneRoom.Id].ListDeviceMac);
|
cloneRoom.ListSceneId.AddRange(this.DicRooms[cloneRoom.Id].ListSceneId);
|
}
|
else
|
{
|
//这里有点特殊,如果不存在的话,把真实设备的区域丢过去,因为只是主键而已
|
cloneRoom.ListDeviceMac.AddRange(i_nowRoom.ListDeviceMac);
|
}
|
//然后把场景和设备丢到这个克隆的对象里面去
|
foreach (var device in i_listDevice)
|
{
|
string mainKey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
|
if (cloneRoom.ListDevice.Contains(mainKey) == false)
|
{
|
//丢设备过去
|
cloneRoom.ListDevice.Add(mainKey);
|
}
|
}
|
foreach (var secne in i_listScene)
|
{
|
if (cloneRoom.ListSceneId.Contains(secne.Id) == false)
|
{
|
//丢场景过去
|
cloneRoom.ListSceneId.Add(secne.Id);
|
}
|
}
|
//获取需要上传的图片
|
var listUploadPic = this.GetUploadPictrueFile(new List<Room> { cloneRoom }, i_listScene, listChirdScene);
|
//生成分享Bin文件内容
|
var binfFileContent = this.CreatShardBinContentOnAdd(new List<Room> { cloneRoom }, i_listDevice, i_listScene, listChirdDevice, listChirdScene);
|
|
//设置最大值
|
ProgressBar.SetMaxValue(listUploadPic.Count + 1);
|
|
//上传bin文件
|
var fileKey = this.DoUploadShardContent(i_ChildAccountId, SHARED_BIN_FILE, Encoding.UTF8.GetBytes(binfFileContent));
|
if (fileKey == null)
|
{
|
ProgressBar.Close();
|
return false;
|
}
|
ProgressBar.SetValue(1);
|
|
//记录主键
|
this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
|
binfFileContent = null;
|
|
//上传图片
|
foreach (var fileName in listUploadPic)
|
{
|
var byteData = HdlFileLogic.Current.ReadFileByteContent(Path.Combine(Config.Instance.FullPath, fileName));
|
if (byteData != null)
|
{
|
fileKey = this.DoUploadShardContent(i_ChildAccountId, fileName, byteData);
|
if (fileKey == null)
|
{
|
ProgressBar.Close();
|
return false;
|
}
|
//记录主键
|
this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
|
}
|
ProgressBar.SetValue(1);
|
}
|
//如果全部成功了的话,覆盖缓存
|
this.DicDevices.Clear();
|
this.DicScenes.Clear();
|
this.DicRooms.Clear();
|
this.DicFloor.Clear();
|
this.AdjustBinFileContent(binfFileContent);
|
|
//删除已经不再分享的图片
|
this.DeleteNotShardPictrue();
|
|
ProgressBar.Close();
|
|
return true;
|
}
|
|
/// <summary>
|
/// 执行上传新的分享房间(整个房间分享)
|
/// </summary>
|
/// <param name="i_ChildAccountId">成员的ID</param>
|
/// <param name="i_listRoom">需要分享的房间</param>
|
public bool UploadSharedRoom(string i_ChildAccountId, List<Room> i_listRoom)
|
{
|
//打开进度条
|
ProgressBar.Show();
|
|
//让设备和场景不重复的东西
|
var listCheck = new HashSet<string>();
|
//克隆房间
|
var listCloneRoom = new List<Room>();
|
//添加的设备
|
var listDevice = new List<CommonDevice>();
|
//添加的场景
|
var listScene = new List<SceneUI>();
|
|
foreach (var room in i_listRoom)
|
{
|
//克隆一个房间出来
|
var cloneRoom = HdlRoomLogic.Current.CloneRoomClass(room);
|
if (this.DicRooms.ContainsKey(cloneRoom.Id) == true)
|
{
|
//把原来的的东西也复制过来
|
cloneRoom.ListDevice.AddRange(this.DicRooms[cloneRoom.Id].ListDevice);
|
cloneRoom.ListDeviceMac.AddRange(this.DicRooms[cloneRoom.Id].ListDeviceMac);
|
cloneRoom.ListSceneId.AddRange(this.DicRooms[cloneRoom.Id].ListSceneId);
|
}
|
else
|
{
|
//这里有点特殊,如果不存在的话,把真实设备的区域丢过去,因为只是主键而已
|
cloneRoom.ListDeviceMac.AddRange(room.ListDeviceMac);
|
}
|
listCloneRoom.Add(cloneRoom);
|
|
//获取设备对象
|
foreach (var mainkey in cloneRoom.ListDevice)
|
{
|
var device = HdlDeviceCommonLogic.Current.GetDevice(mainkey);
|
if (device != null)
|
{
|
listDevice.Add(device);
|
}
|
listCheck.Add(mainkey);
|
}
|
//获取场景对象
|
foreach (var sceneId in cloneRoom.ListSceneId)
|
{
|
var scene = HdlSceneLogic.Current.GetSceneUIBySceneId(sceneId);
|
if (scene != null)
|
{
|
listScene.Add(scene);
|
}
|
listCheck.Add(sceneId.ToString());
|
//从缓存获取场景的执行目标
|
this.GetSceneAdjustTargetListFromLocal(scene, listCheck, listScene, listDevice);
|
}
|
}
|
|
//获取需要上传的图片
|
var listUploadPic = this.GetUploadPictrueFile(listCloneRoom, listScene, new List<SceneUI>());
|
//生成分享Bin文件内容
|
var binfFileContent = this.CreatShardBinContentOnAdd(listCloneRoom, listDevice, listScene, new List<CommonDevice>(), new List<SceneUI>());
|
|
//设置最大值
|
ProgressBar.SetMaxValue(listUploadPic.Count + 1);
|
|
//上传bin文件
|
var fileKey = this.DoUploadShardContent(i_ChildAccountId, SHARED_BIN_FILE, Encoding.UTF8.GetBytes(binfFileContent));
|
if (fileKey == null)
|
{
|
ProgressBar.Close();
|
return false;
|
}
|
ProgressBar.SetValue(1);
|
|
//记录主键
|
this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
|
binfFileContent = null;
|
|
//上传图片
|
foreach (var fileName in listUploadPic)
|
{
|
var byteData = HdlFileLogic.Current.ReadFileByteContent(Path.Combine(Config.Instance.FullPath, fileName));
|
if (byteData != null)
|
{
|
fileKey = this.DoUploadShardContent(i_ChildAccountId, fileName, byteData);
|
if (fileKey == null)
|
{
|
ProgressBar.Close();
|
return false;
|
}
|
//记录主键
|
this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
|
}
|
ProgressBar.SetValue(1);
|
}
|
//如果全部成功了的话,覆盖缓存
|
this.DicDevices.Clear();
|
this.DicScenes.Clear();
|
this.DicRooms.Clear();
|
this.DicFloor.Clear();
|
this.AdjustBinFileContent(binfFileContent);
|
|
//删除已经不再分享的图片
|
this.DeleteNotShardPictrue();
|
|
ProgressBar.Close();
|
|
return true;
|
}
|
|
/// <summary>
|
/// 删除已经不再分享的图片(不用管返回值,即使失败也没事)
|
/// </summary>
|
private void DeleteNotShardPictrue()
|
{
|
var listPictrue = new List<string>();
|
foreach (var room in this.DicRooms.Values)
|
{
|
if (room.BackgroundImageType != 0)
|
{
|
//房间图片
|
listPictrue.Add(room.BackgroundImage);
|
}
|
}
|
foreach (var scene in this.DicScenes.Values)
|
{
|
if (scene.IconPathType != 0)
|
{
|
//场景图片
|
listPictrue.Add(scene.IconPath);
|
}
|
}
|
var listDeleteFile = new List<string>();
|
foreach (var fileName in this.DicShardKeys.Keys)
|
{
|
//如果是房间或者场景的图片
|
if (fileName.StartsWith("RoomIcon_") == true || fileName.StartsWith("SceneIcon_") == true)
|
{
|
if (listPictrue.Contains(fileName) == false)
|
{
|
//这个图片变更了,需要删除掉
|
listDeleteFile.Add(fileName);
|
}
|
}
|
}
|
//删除图片
|
this.DoDeleteSharedContent(listDeleteFile, ShowNetCodeMode.No);
|
}
|
|
/// <summary>
|
/// 上传分享内容(返回主键)
|
/// </summary>
|
/// <param name="i_childAccountId">子账号的主键</param>
|
/// <param name="i_fileName">文件名字</param>
|
/// <param name="i_content">文件内容</param>
|
/// <returns></returns>
|
private string DoUploadShardContent(string i_childAccountId, string i_fileName, byte[] i_content)
|
{
|
var dicQuery = new Dictionary<string, object>();
|
dicQuery["homeId"] = Config.Instance.Home.Id;
|
dicQuery["childAccountId"] = i_childAccountId;
|
dicQuery["fileName"] = i_fileName;
|
|
var result = HdlHttpLogic.Current.RequestResponseFromZigbeeHttps("home-wisdom/app/home/share/add", RestSharp.Method.POST, i_content, dicQuery, null, CheckMode.A账号权限, true, 10);
|
//检测状态码
|
if (HdlCheckLogic.Current.CheckNetCode(result, ShowNetCodeMode.YES) == false)
|
{
|
return null;
|
}
|
var info = Newtonsoft.Json.JsonConvert.DeserializeObject<ReceiveShardInfoResult>(result.Data.ToString());
|
return info.Id;
|
}
|
|
#endregion
|
|
#region ■ 上传分享内容辅助方法_______________
|
|
/// <summary>
|
/// 从本地获取场景里面的执行目标列表
|
/// </summary>
|
/// <param name="scene">场景</param>
|
/// <param name="listCheck">重复检测用</param>
|
/// <param name="listSceneUI">添加分享的场景列表</param>
|
/// <param name="listDevice">添加分享的设备列表</param>
|
/// <returns></returns>
|
private void GetSceneAdjustTargetListFromLocal(SceneUI scene, HashSet<string> listCheck, List<SceneUI> listSceneUI, List<CommonDevice> listDevice)
|
{
|
foreach (var data in scene.AdjustTargetList)
|
{
|
//设备
|
if (data.Type == 0)
|
{
|
string mainKeys = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(data.DeviceAddr, data.Epoint);
|
if (listCheck.Contains(mainKeys) == true)
|
{
|
//不重复添加
|
continue;
|
}
|
listCheck.Add(mainKeys);
|
|
var device = HdlDeviceCommonLogic.Current.GetDevice(data.DeviceAddr, data.Epoint);
|
if (device != null)
|
{
|
listDevice.Add(device);
|
}
|
}
|
//场景
|
else if (data.Type == 1)
|
{
|
string mainKeys = data.ElseScenesId.ToString();
|
if (listCheck.Contains(mainKeys) == true)
|
{
|
//不重复添加
|
continue;
|
}
|
listCheck.Add(mainKeys);
|
|
//获取场景对象
|
var sceneUi = HdlSceneLogic.Current.GetSceneUIBySceneId(data.ElseScenesId);
|
if (sceneUi != null)
|
{
|
listSceneUI.Add(sceneUi);
|
//递归获取执行目标
|
this.GetSceneAdjustTargetListFromLocal(sceneUi, listCheck, listSceneUI, listDevice);
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// 获取需要上传的图片名字
|
/// </summary>
|
/// <param name="i_listRoom">房间对象</param>
|
/// <param name="i_listScene">场景对象</param>
|
/// <param name="i_listChirdScene">场景对象</param>
|
/// <returns></returns>
|
private List<string> GetUploadPictrueFile(List<Room> i_listRoom, List<SceneUI> i_listScene, List<SceneUI> i_listChirdScene)
|
{
|
var listPic = new List<string>();
|
foreach (var room in i_listRoom)
|
{
|
if (room.BackgroundImageType != 0 && this.DicShardKeys.ContainsKey(room.BackgroundImage) == false)
|
{
|
//自定义图片
|
listPic.Add(room.BackgroundImage);
|
}
|
}
|
foreach (var scene in i_listScene)
|
{
|
if (scene.IconPathType != 0 && this.DicShardKeys.ContainsKey(scene.IconPath) == false)
|
{
|
//自定义图片
|
listPic.Add(scene.IconPath);
|
}
|
}
|
foreach (var scene in i_listChirdScene)
|
{
|
if (scene.IconPathType != 0 && this.DicShardKeys.ContainsKey(scene.IconPath) == false)
|
{
|
//自定义图片
|
listPic.Add(scene.IconPath);
|
}
|
}
|
return listPic;
|
}
|
|
#endregion
|
|
|
#region ■ 删除分享内容_______________________
|
|
/// <summary>
|
/// 移除指定分享内容(设备和场景仅限同一个房间)
|
/// </summary>
|
/// <param name="i_ChildAccountId">成员ID</param>
|
/// <param name="i_nowRoom">指定的房间</param>
|
/// <param name="i_listDevice">选择上传的设备(仅限一个房间)</param>
|
/// <param name="i_listScene">选择上传的场景(仅限一个房间,不要获取它里面的绑定列表)</param>
|
/// <returns></returns>
|
public bool DeleteSharedContent(string i_ChildAccountId, Room i_nowRoom,
|
List<CommonDevice> i_listDevice, List<SceneUI> i_listScene)
|
{
|
//克隆一个房间出来
|
var cloneRoom = HdlRoomLogic.Current.CloneRoomClass(i_nowRoom);
|
if (this.DicRooms.ContainsKey(cloneRoom.Id) == true)
|
{
|
//把原来的的东西也复制过来
|
cloneRoom.ListDevice.AddRange(this.DicRooms[cloneRoom.Id].ListDevice);
|
cloneRoom.ListDeviceMac.AddRange(this.DicRooms[cloneRoom.Id].ListDeviceMac);
|
cloneRoom.ListSceneId.AddRange(this.DicRooms[cloneRoom.Id].ListSceneId);
|
}
|
|
//让设备和场景不重复添加的东西
|
var listCheck = new HashSet<string>();
|
|
//然后把场景和设备从这个克隆的对象里面移除掉(真实物理设备的房间不用理)
|
foreach (var device in i_listDevice)
|
{
|
string mainKey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
|
cloneRoom.ListDevice.Remove(mainKey);
|
|
listCheck.Add(mainKey);
|
}
|
foreach (var secne in i_listScene)
|
{
|
cloneRoom.ListSceneId.Remove(secne.Id);
|
|
listCheck.Add(secne.Id.ToString());
|
}
|
//如果都移除完的话,则直接走删除分享房间的方法
|
if (cloneRoom.ListDevice.Count == 0 && cloneRoom.ListSceneId.Count == 0)
|
{
|
//执行整个房间删除的方法
|
return this.DeleteSharedRoom(i_ChildAccountId, new List<Room> { i_nowRoom });
|
}
|
//获取场景里面嵌套的子设备和子场景
|
foreach (var sceneTemp in i_listScene)
|
{
|
//从缓存获取场景的执行目标
|
this.GetSceneAdjustTargetListFromShard(sceneTemp, listCheck, i_listScene, i_listDevice);
|
}
|
//在删除一个房间中的一些设备的模式下,检测设备和场景是否能够删除(有可能它还在别的房间或者场景当中)
|
var listDelDevice = new List<CommonDevice>();
|
var listDelScene = new List<SceneUI>();
|
this.CheckDeviceAndSceneCanDeleteOnDeleteSome(i_listDevice, i_listScene, ref listDelDevice, ref listDelScene, cloneRoom);
|
|
//生成分享Bin文件内容(这里不用删除房间)
|
var binfFileContent = this.CreatShardBinContentOnDelete(new List<Room>(), listDelDevice, listDelScene);
|
|
//上传bin文件
|
var fileKey = this.DoUploadShardContent(i_ChildAccountId, SHARED_BIN_FILE, Encoding.UTF8.GetBytes(binfFileContent));
|
if (fileKey == null)
|
{
|
ProgressBar.Close();
|
return false;
|
}
|
ProgressBar.SetValue(1);
|
|
//记录主键
|
this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
|
binfFileContent = null;
|
|
//如果全部成功了的话,覆盖缓存
|
this.DicDevices.Clear();
|
this.DicScenes.Clear();
|
this.DicRooms.Clear();
|
this.DicFloor.Clear();
|
this.AdjustBinFileContent(binfFileContent);
|
|
//删除已经不再分享的图片
|
this.DeleteNotShardPictrue();
|
|
ProgressBar.Close();
|
|
return true;
|
}
|
|
/// <summary>
|
/// 移除指定分享内容(整个房间删除)
|
/// </summary>
|
/// <param name="i_ChildAccountId">成员ID</param>
|
/// <param name="i_listRoom">需要整个删除的房间</param>
|
/// <returns></returns>
|
public bool DeleteSharedRoom(string i_ChildAccountId, List<Room> i_listRoom)
|
{
|
//打开进度条
|
ProgressBar.Show();
|
//设置最大值
|
ProgressBar.SetMaxValue(1);
|
|
//获取删除房间的全部全部设备和场景
|
var listDevice = new List<CommonDevice>();
|
var listScene = new List<SceneUI>();
|
this.GetDeleteRoomAllDeviceAndScene(i_listRoom, ref listDevice, ref listScene);
|
|
//删除的房间ID
|
var listDeleteRoom = new List<string>();
|
foreach (var room in i_listRoom)
|
{
|
//判断场景和设备是否能删除时使用
|
listDeleteRoom.Add(room.Id);
|
}
|
//在删除整个房间的模式下,检测设备和场景是否能够删除(有可能它还在别的房间或者场景当中)
|
var listDelDevice = new List<CommonDevice>();
|
var listDelScene = new List<SceneUI>();
|
this.CheckDeviceAndSceneCanDeleteOnDeleteRoom(listDevice, listScene, ref listDelDevice, ref listDelScene, listDeleteRoom);
|
|
//生成分享Bin文件内容
|
var binfFileContent = this.CreatShardBinContentOnDelete(i_listRoom, listDelDevice, listDelScene);
|
|
//上传bin文件
|
var fileKey = this.DoUploadShardContent(i_ChildAccountId, SHARED_BIN_FILE, Encoding.UTF8.GetBytes(binfFileContent));
|
if (fileKey == null)
|
{
|
ProgressBar.Close();
|
return false;
|
}
|
ProgressBar.SetValue(1);
|
|
//记录主键
|
this.DicShardKeys[SHARED_BIN_FILE] = fileKey;
|
binfFileContent = null;
|
|
//如果全部成功了的话,覆盖缓存
|
this.DicDevices.Clear();
|
this.DicScenes.Clear();
|
this.DicRooms.Clear();
|
this.DicFloor.Clear();
|
this.AdjustBinFileContent(binfFileContent);
|
|
//删除已经不再分享的图片
|
this.DeleteNotShardPictrue();
|
|
ProgressBar.Close();
|
|
return true;
|
}
|
|
/// <summary>
|
/// 执行移除分享数据
|
/// </summary>
|
/// <param name="listDelFile">删除的文件</param>
|
/// <param name="mode">失败时是否显示tip消息</param>
|
/// <returns></returns>
|
private bool DoDeleteSharedContent(List<string> listDelFile, ShowNetCodeMode mode = ShowNetCodeMode.YES)
|
{
|
if (listDelFile.Count == 0)
|
{
|
return true;
|
}
|
foreach (var fileName in listDelFile)
|
{
|
if (this.DicShardKeys.ContainsKey(fileName) == false)
|
{
|
//我也不知道为什么会找不到主键
|
continue;
|
}
|
var pra = new { homeId = Config.Instance.Home.Id, homeShareId = this.DicShardKeys[fileName] };
|
//执行删除
|
var result = HdlHttpLogic.Current.RequestResponseFromZigbeeHttps("home-wisdom/app/home/share/delete", RestSharp.Method.POST, pra, null, null, CheckMode.A账号权限);
|
//检测状态码
|
if (HdlCheckLogic.Current.CheckNetCode(result, mode) == false)
|
{
|
return false;
|
}
|
//移除缓存
|
this.DicShardKeys.Remove(fileName);
|
}
|
return true;
|
}
|
|
#endregion
|
|
#region ■ 删除分享内容辅助方法_______________
|
|
/// <summary>
|
/// 获取删除房间的全部全部设备和场景
|
/// </summary>
|
/// <param name="i_listRoom">删除的房间</param>
|
/// <param name="listDevice">全部设备(返回值)</param>
|
/// <param name="listScene">全部场景(返回值)</param>
|
private void GetDeleteRoomAllDeviceAndScene(List<Room> i_listRoom, ref List<CommonDevice> listDevice, ref List<SceneUI> listScene)
|
{
|
var listCheck = new HashSet<string>();
|
foreach (var room in i_listRoom)
|
{
|
//获取设备
|
foreach (var mainkey in room.ListDevice)
|
{
|
if (listCheck.Contains(mainkey) == true) { continue; }
|
listCheck.Add(mainkey);
|
|
//分享数据里面有才添加
|
if (this.DicDevices.ContainsKey(mainkey) == true)
|
{
|
listDevice.Add(this.DicDevices[mainkey]);
|
}
|
}
|
//然后再获取场景
|
foreach (var sceneId in room.ListSceneId)
|
{
|
if (listCheck.Contains(sceneId.ToString()) == true) { continue; }
|
listCheck.Add(sceneId.ToString());
|
|
//分享数据里面有才添加
|
if (this.DicScenes.ContainsKey(sceneId) == true)
|
{
|
var sceneTemp = this.DicScenes[sceneId];
|
listScene.Add(sceneTemp);
|
|
//获取场景里面嵌套的子设备和子场景
|
this.GetSceneAdjustTargetListFromShard(sceneTemp, listCheck, listScene, listDevice);
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// 在删除整个房间的模式下,检测设备和场景是否能够删除(有可能它还在别的房间或者场景当中)
|
/// </summary>
|
/// <param name="i_listDevice">理论上要删除的设备</param>
|
/// <param name="i_listScene">理论上要删除的场景</param>
|
/// <param name="listDeleteDevice">真实能够删除的设备(返回值)</param>
|
/// <param name="listDeleteScene">真实能够删除的场景(返回值)</param>
|
/// <param name="i_listDelleteRoom">删除的房间</param>
|
private void CheckDeviceAndSceneCanDeleteOnDeleteRoom(List<CommonDevice> i_listDevice, List<SceneUI> i_listScene,
|
ref List<CommonDevice> listDeleteDevice, ref List<SceneUI> listDeleteScene, List<string> i_listNotCheckRoom)
|
{
|
//注意：这个函数和下面的CheckDeviceAndSceneCanDeleteOnDeleteSome有本质区别
|
//这个只是完全删除一个房间内的设备或者场景,因此只需要去判断删除以外的就可以了
|
|
//获取理论上需要删除的场景ID
|
var listSceneId = new List<int>();
|
foreach (var scene in i_listScene)
|
{
|
listSceneId.Add(scene.Id);
|
}
|
var listShardDevice = new HashSet<string>();
|
var listShardScene = new HashSet<int>();
|
//获取除了理论上需要删除的场景之外，目前还分享的场景的执行目标里面的设备
|
foreach (var scene in this.DicScenes.Values)
|
{
|
//这个是要删除的场景
|
if (listSceneId.Contains(scene.Id) == true) { continue; }
|
|
foreach (var data in scene.AdjustTargetList)
|
{
|
//设备
|
if (data.Type == 0)
|
{
|
var mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(data.DeviceAddr, data.Epoint);
|
if (listShardDevice.Contains(mainkey) == false)
|
{
|
listShardDevice.Add(mainkey);
|
}
|
}
|
//子场景
|
else if (data.Type == 1)
|
{
|
if (listShardScene.Contains(data.ElseScenesId) == false)
|
{
|
listShardScene.Add(data.ElseScenesId);
|
}
|
}
|
}
|
}
|
//获取除了理论上需要删除的房间之外，目前还分享的设备
|
foreach (var room in this.DicRooms.Values)
|
{
|
//这个是要删除的房间
|
if (i_listNotCheckRoom.Contains(room.Id) == true) { continue; }
|
|
foreach (var mainkey in room.ListDevice)
|
{
|
if (listShardDevice.Contains(mainkey) == false)
|
{
|
listShardDevice.Add(mainkey);
|
}
|
}
|
foreach (var sceneId in room.ListSceneId)
|
{
|
if (listShardScene.Contains(sceneId) == false)
|
{
|
listShardScene.Add(sceneId);
|
}
|
}
|
}
|
|
//判断实际能够删除的设备
|
foreach (var device in i_listDevice)
|
{
|
var mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
|
if (listShardDevice.Contains(mainkey) == false)
|
{
|
//这个设备已经不在分享
|
listDeleteDevice.Add(device);
|
}
|
}
|
//判断实际能够删除的场景
|
foreach (var scene in i_listScene)
|
{
|
if (listShardScene.Contains(scene.Id) == false)
|
{
|
//这个场景已经不在分享
|
listDeleteScene.Add(scene);
|
}
|
}
|
}
|
|
/// <summary>
|
/// 在删除一个房间中的一些设备的模式下,检测设备和场景是否能够删除(有可能它还在别的房间或者场景当中)
|
/// </summary>
|
/// <param name="i_listDevice">理论上要删除的设备</param>
|
/// <param name="i_listScene">理论上要删除的场景</param>
|
/// <param name="listDeleteDevice">真实能够删除的设备(返回值)</param>
|
/// <param name="listDeleteScene">真实能够删除的场景(返回值)</param>
|
/// <param name="i_nowCloneRoom">当前房间(克隆)</param>
|
private void CheckDeviceAndSceneCanDeleteOnDeleteSome(List<CommonDevice> i_listDevice, List<SceneUI> i_listScene,
|
ref List<CommonDevice> listDeleteDevice, ref List<SceneUI> listDeleteScene, Room i_nowCloneRoom)
|
{
|
//注意：这个函数和上面的CheckDeviceAndSceneCanDeleteOnDeleteRoom有本质区别
|
//这个只是删除一个房间内的部分设备或者场景,因此它有可能自身就嵌套着要删除的设备或者场景
|
|
//先获取目前还在分享的设备和场景
|
var listShardDevice = new HashSet<string>();
|
var listShardScene = new HashSet<int>();
|
|
foreach (var roomId in this.DicRooms.Keys)
|
{
|
//如果是当前克隆的房间,则用克隆的房间来处理,克隆的房间已经把理论上要删除的设备和场景都删除了
|
var room = i_nowCloneRoom.Id != roomId ? this.DicRooms[roomId] : i_nowCloneRoom;
|
//还在分享的设备
|
foreach (var mainkey in room.ListDevice)
|
{
|
if (listShardDevice.Contains(mainkey) == false)
|
{
|
listShardDevice.Add(mainkey);
|
}
|
}
|
//还在分享的场景
|
foreach (var sceneId in room.ListSceneId)
|
{
|
if (listShardScene.Contains(sceneId) == false)
|
{
|
listShardScene.Add(sceneId);
|
}
|
//从场景的执行目标当前获取
|
if (this.DicScenes.ContainsKey(sceneId) == true)
|
{
|
foreach (var data in this.DicScenes[sceneId].AdjustTargetList)
|
{
|
//子设备
|
if (data.Type == 0)
|
{
|
var mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(data.DeviceAddr, data.Epoint);
|
if (listShardDevice.Contains(mainkey) == false)
|
{
|
listShardDevice.Add(mainkey);
|
}
|
}
|
//子场景
|
else if (data.Type == 1)
|
{
|
if (listShardScene.Contains(data.ElseScenesId) == false)
|
{
|
listShardScene.Add(data.ElseScenesId);
|
}
|
}
|
}
|
}
|
}
|
}
|
//判断实际能够删除的设备
|
foreach (var device in i_listDevice)
|
{
|
var mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
|
if (listShardDevice.Contains(mainkey) == false)
|
{
|
//这个设备已经不在分享
|
listDeleteDevice.Add(device);
|
}
|
}
|
//判断实际能够删除的场景
|
foreach (var scene in i_listScene)
|
{
|
if (listShardScene.Contains(scene.Id) == false)
|
{
|
//这个场景已经不在分享
|
listDeleteScene.Add(scene);
|
}
|
}
|
}
|
|
/// <summary>
|
/// 从分享数据里面获取场景里面的执行目标列表
|
/// </summary>
|
/// <param name="scene">场景</param>
|
/// <param name="listCheck">重复检测用</param>
|
/// <param name="listSceneUI">添加分享的场景列表</param>
|
/// <param name="listDevice">添加分享的设备列表</param>
|
/// <returns></returns>
|
private void GetSceneAdjustTargetListFromShard(SceneUI scene, HashSet<string> listCheck, List<SceneUI> listSceneUI, List<CommonDevice> listDevice)
|
{
|
foreach (var data in scene.AdjustTargetList)
|
{
|
//设备
|
if (data.Type == 0)
|
{
|
string mainKeys = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(data.DeviceAddr, data.Epoint);
|
if (listCheck.Contains(mainKeys) == true)
|
{
|
//不重复添加
|
continue;
|
}
|
listCheck.Add(mainKeys);
|
if (this.DicDevices.ContainsKey(mainKeys) == true)
|
{
|
listDevice.Add(this.DicDevices[mainKeys]);
|
}
|
}
|
//场景
|
else if (data.Type == 1)
|
{
|
string mainKeys = data.ElseScenesId.ToString();
|
if (listCheck.Contains(mainKeys) == true)
|
{
|
//不重复添加
|
continue;
|
}
|
listCheck.Add(mainKeys);
|
|
//获取场景对象
|
if (this.DicScenes.ContainsKey(data.ElseScenesId) == true)
|
{
|
var sceneUi = this.DicScenes[data.ElseScenesId];
|
listSceneUI.Add(sceneUi);
|
|
//递归获取执行目标
|
this.GetSceneAdjustTargetListFromShard(sceneUi, listCheck, listSceneUI, listDevice);
|
}
|
}
|
}
|
}
|
|
|
#endregion
|
|
|
#region ■ 生成分享Bin文件内容________________
|
|
/// <summary>
|
/// 生成分享Bin文件内容(新增模式)
|
/// </summary>
|
/// <param name="i_listNewRoom">新的房间对象集合(也就是变更了的房间)</param>
|
/// <param name="i_listDevice">这个是需要追加的分享设备</param>
|
/// <param name="i_listScene">这个是需要追加的分享场景</param>
|
/// <param name="i_listChirdDevice">这个是由场景的执行目标来的</param>
|
/// <param name="i_listChirdScene">这个是由场景的执行目标来的</param>
|
/// <returns></returns>
|
private string CreatShardBinContentOnAdd(List<Room> i_listNewRoom, List<CommonDevice> i_listDevice, List<SceneUI> i_listScene,
|
List<CommonDevice> i_listChirdDevice, List<SceneUI> i_listChirdScene)
|
{
|
string writeText = string.Empty;
|
//生成写入文件的【设备对象数据】
|
this.CreatWriteCommonDeviceData(i_listDevice, i_listChirdDevice, false, ref writeText);
|
|
//生成写入文件的【场景数据】
|
this.CreatWriteSceneData(i_listScene, i_listChirdScene, false, ref writeText);
|
|
//生成写入文件的【场景数据】
|
this.CrearWriteRoomData(i_listNewRoom, false, ref writeText);
|
|
return writeText;
|
}
|
|
/// <summary>
|
/// 生成分享Bin文件内容(删除模式)
|
/// </summary>
|
/// <param name="i_listDelRoom">要删除的房间</param>
|
/// <param name="i_listDevice">这个是需要删除的分享设备</param>
|
/// <param name="i_listScene">这个是需要删除的分享场景</param>
|
/// <returns></returns>
|
private string CreatShardBinContentOnDelete(List<Room> i_listDelRoom, List<CommonDevice> i_listDevice, List<SceneUI> i_listScene)
|
{
|
string writeText = string.Empty;
|
//生成写入文件的【设备对象数据】
|
this.CreatWriteCommonDeviceData(i_listDevice, new List<CommonDevice>(), true, ref writeText);
|
|
//生成写入文件的【场景数据】
|
this.CreatWriteSceneData(i_listScene, new List<SceneUI>(), true, ref writeText);
|
|
//生成写入文件的【场景数据】
|
this.CrearWriteRoomData(i_listDelRoom, true, ref writeText);
|
|
return writeText;
|
}
|
|
/// <summary>
|
/// 生成写入文件的【设备对象数据】
|
/// </summary>
|
/// <param name="writeText"></param>
|
private void CreatWriteCommonDeviceData(List<CommonDevice> i_listDevice, List<CommonDevice> i_listChirdDevice, bool i_isDel, ref string writeText)
|
{
|
//合并设备到一个新的对象当中
|
var dicNewDevice = this.MergeNewShardDevices(i_listDevice, i_listChirdDevice, i_isDel);
|
var listCheck = new HashSet<string>();
|
foreach (var device in dicNewDevice.Values)
|
{
|
//设备端点
|
writeText += "#DeviceInfo START#" + (int)device.Type + "\r\n";
|
string dataInfo = Newtonsoft.Json.JsonConvert.SerializeObject(device);
|
writeText += dataInfo + "\r\n";
|
writeText += "#DeviceInfo END#\r\n\r\n";
|
|
//添加Ota设备对象的缓存
|
if (listCheck.Contains(device.DeviceAddr) == false)
|
{
|
listCheck.Add(device.DeviceAddr);
|
var otaDevice = HdlDeviceCommonLogic.Current.GetOTADevice(device.DeviceAddr);
|
if (otaDevice != null)
|
{
|
writeText += "#DeviceInfo START#" + (int)otaDevice.Type + "\r\n";
|
string dataInfo2 = Newtonsoft.Json.JsonConvert.SerializeObject(otaDevice);
|
writeText += dataInfo2 + "\r\n";
|
writeText += "#DeviceInfo END#\r\n\r\n";
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// 生成写入文件的【场景数据】
|
/// </summary>
|
/// <param name="i_listScene">这个是需要追加的分享场景</param>
|
/// <param name="i_listChirdScene">这个是由场景的执行目标来的</param>
|
/// <param name="writeText"></param>
|
private void CreatWriteSceneData(List<SceneUI> i_listScene, List<SceneUI> i_listChirdScene, bool i_isDel, ref string writeText)
|
{
|
//合并场景到一个新的对象当中
|
var dicNewScene = this.MergeNewShardScenes(i_listScene, i_listChirdScene, i_isDel);
|
|
foreach (var scene in dicNewScene.Values)
|
{
|
writeText += "#START#\r\n";
|
string dataInfo = Newtonsoft.Json.JsonConvert.SerializeObject(scene);
|
writeText += dataInfo + "\r\n";
|
writeText += "#SceneTemplate END#\r\n\r\n";
|
}
|
}
|
|
/// <summary>
|
/// 生成写入文件的【房间模板数据】
|
/// </summary>
|
/// <param name="i_listNewRoom">新的房间对象集合(也就是变更了的房间)</param>
|
/// <param name="writeText"></param>
|
private void CrearWriteRoomData(List<Room> i_listNewRoom, bool i_isDel, ref string writeText)
|
{
|
var dicNewFloor = new Dictionary<string, string>();
|
//合并分享的房间到一个新的对象中
|
var dicNewRoom = this.MergeNewShardRooms(i_listNewRoom, i_isDel);
|
foreach (var room in dicNewRoom.Values)
|
{
|
writeText += "#START#\r\n";
|
string dataInfo2 = Newtonsoft.Json.JsonConvert.SerializeObject(room);
|
writeText += dataInfo2 + "\r\n";
|
writeText += "#RoomInfo END#\r\n\r\n";
|
|
if (room.FloorId != string.Empty)
|
{
|
dicNewFloor[room.FloorId] = HdlResidenceLogic.Current.GetFloorNameById(room.FloorId);
|
}
|
}
|
//楼层数据
|
writeText += "#START#\r\n";
|
string dataInfo1 = Newtonsoft.Json.JsonConvert.SerializeObject(dicNewFloor);
|
writeText += dataInfo1 + "\r\n";
|
writeText += "#FloorInfo END#\r\n\r\n";
|
}
|
|
#endregion
|
|
#region ■ 生成分享Bin文件内容辅助方法________
|
|
/// <summary>
|
/// 合并分享的设备到一个新的对象中
|
/// </summary>
|
/// <param name="i_listDevice">这个是需要追加的分享设备</param>
|
/// <param name="i_listChirdDevice">这个是由场景的执行目标来的</param>
|
/// <param name="i_isDel">是否是删除分享模式</param>
|
/// <returns></returns>
|
private Dictionary<string, CommonDevice> MergeNewShardDevices(List<CommonDevice> i_listDevice, List<CommonDevice> i_listChirdDevice, bool i_isDel)
|
{
|
var dicNewDevice = new Dictionary<string, CommonDevice>();
|
//先合并原来的
|
foreach (var key in this.DicDevices.Keys)
|
{
|
dicNewDevice[key] = this.DicDevices[key];
|
}
|
//再合并新添加的
|
foreach (var device in i_listDevice)
|
{
|
string mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
|
if (i_isDel == false)
|
{
|
//直接覆盖,没问题
|
dicNewDevice[mainkey] = device;
|
}
|
else
|
{
|
//删除模式
|
dicNewDevice.Remove(mainkey);
|
}
|
}
|
foreach (var device in i_listChirdDevice)
|
{
|
string mainkey = HdlDeviceCommonLogic.Current.GetDeviceMainKeys(device);
|
//直接覆盖,没问题
|
dicNewDevice[mainkey] = device;
|
}
|
return dicNewDevice;
|
}
|
|
/// <summary>
|
/// 合并分享的场景到一个新的对象中
|
/// </summary>
|
/// <param name="i_listScene">这个是需要追加的分享场景</param>
|
/// <param name="i_listChirdScene">这个是由场景的执行目标来的</param>
|
/// <param name="i_isDel">是否是删除分享模式</param>
|
/// <returns></returns>
|
private Dictionary<int, SceneUI> MergeNewShardScenes(List<SceneUI> i_listScene, List<SceneUI> i_listChirdScene, bool i_isDel)
|
{
|
var dicNewScene = new Dictionary<int, SceneUI>();
|
//先合并原来的
|
foreach (var key in this.DicScenes.Keys)
|
{
|
dicNewScene[key] = this.DicScenes[key];
|
}
|
//再合并新添加的
|
foreach (var scene in i_listScene)
|
{
|
if (i_isDel == false)
|
{
|
//直接覆盖,没问题
|
dicNewScene[scene.Id] = scene;
|
}
|
else
|
{
|
//删除模式
|
dicNewScene.Remove(scene.Id);
|
}
|
}
|
foreach (var scene in i_listChirdScene)
|
{
|
//直接覆盖,没问题
|
dicNewScene[scene.Id] = scene;
|
}
|
return dicNewScene;
|
}
|
|
/// <summary>
|
/// 合并分享的房间到一个新的对象中
|
/// </summary>
|
/// <param name="i_listNewRoom">新的房间对象集合(也就是变更了的房间)</param>
|
/// <param name="i_isDel">是否是删除分享模式</param>
|
/// <returns></returns>
|
private Dictionary<string, Room> MergeNewShardRooms(List<Room> i_listNewRoom, bool i_isDel)
|
{
|
var dicNewRoom = new Dictionary<string, Room>();
|
//先合并原来的
|
foreach (var key in this.DicRooms.Keys)
|
{
|
dicNewRoom[key] = this.DicRooms[key];
|
}
|
//再合并新添加的
|
foreach (var room in i_listNewRoom)
|
{
|
if (i_isDel == false)
|
{
|
//直接覆盖,没问题
|
dicNewRoom[room.Id] = room;
|
}
|
else
|
{
|
//删除模式
|
dicNewRoom.Remove(room.Id);
|
}
|
}
|
return dicNewRoom;
|
}
|
|
#endregion
|
|
|
#region ■ 获取分享缓存方法___________________
|
|
/// <summary>
|
/// 从缓存当中获取分享的设备
|
/// </summary>
|
/// <param name="i_deviceKey">设备的主键</param>
|
/// <returns></returns>
|
public CommonDevice GetShardDeviceFromMemory(string i_deviceKey)
|
{
|
if (this.DicDevices.ContainsKey(i_deviceKey) == true)
|
{
|
return this.DicDevices[i_deviceKey];
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 从缓存当中获取分享的场景
|
/// </summary>
|
/// <param name="i_sceneId">场景ID</param>
|
/// <returns></returns>
|
public SceneUI GetShardSceneFromMemory(int i_sceneId)
|
{
|
if (this.DicScenes.ContainsKey(i_sceneId) == true)
|
{
|
return this.DicScenes[i_sceneId];
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 从缓存当中获取分享的房间
|
/// </summary>
|
/// <returns></returns>
|
public Dictionary<string, Room> GetShardRoomFromMemory()
|
{
|
return this.DicRooms;
|
}
|
|
/// <summary>
|
/// 从缓存当中获取分享的房间
|
/// </summary>
|
/// <param name="i_roomId">房间ID</param>
|
/// <returns></returns>
|
public Room GetShardRoomFromMemory(string i_roomId)
|
{
|
if (this.DicRooms.ContainsKey(i_roomId) == true)
|
{
|
return this.DicRooms[i_roomId];
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 从缓存当中获取分享的楼层
|
/// </summary>
|
/// <returns></returns>
|
public Dictionary<string, string> GetShardFloorFormMemory()
|
{
|
return this.DicFloor;
|
}
|
|
#endregion
|
|
#region ■ 一般方法___________________________
|
|
/// <summary>
|
/// 获取分享文件的内容
|
/// </summary>
|
/// <param name="fileName">文件名称(不是全路径)</param>
|
/// <returns></returns>
|
private byte[] GetShardFileContent(string fileName)
|
{
|
string fullName = System.IO.Path.Combine(HdlFileNameResourse.DownLoadShardDirectory, fileName);
|
if (System.IO.File.Exists(fullName) == false)
|
{
|
return null;
|
}
|
var varByte = HdlFileLogic.Current.ReadFileByteContent(fullName);
|
return varByte;
|
}
|
|
/// <summary>
|
/// 清空共享缓存
|
/// </summary>
|
public void Dispone()
|
{
|
this.DicDevices = null;
|
this.DicScenes.Clear();
|
this.DicRooms.Clear();
|
this.DicShardKeys.Clear();
|
this.DicFloor.Clear();
|
|
//清空文件夹
|
string strDir = HdlFileNameResourse.DownLoadShardDirectory;
|
HdlFileLogic.Current.CreateDirectory(strDir, true);
|
|
m_Current = null;
|
}
|
|
#endregion
|
|
#region ■ 结构体类___________________________
|
|
/// <summary>
|
/// 接收分享数据
|
/// </summary>
|
private class ReceiveShardInfoResult
|
{
|
/// <summary>
|
/// 文件名字
|
/// </summary>
|
public string FileName = string.Empty;
|
/// <summary>
|
/// 更新时间
|
/// </summary>
|
public string CreateTime = string.Empty;
|
/// <summary>
|
/// 主键
|
/// </summary>
|
public string Id = string.Empty;
|
}
|
|
#endregion
|
}
|
}
|
