~wjc/HomeApp.git

New file
			@@ -0,0 +1,921 @@
			using Shared.Common;
			using System;
			using System.Collections.Generic;
			using System.Collections.Specialized;
			using System.IO;
			using System.Net;
			using System.Text;

			namespace Shared.Phone.UserCenter
			{
			/// <summary>
			/// 备份业务的逻辑
			/// </summary>
			public class HdlBackupLogic
			{
			#region ■ 变量声明___________________________

			/// <summary>
			/// 备份业务的逻辑
			/// </summary>
			private static HdlBackupLogic m_Current = null;
			/// <summary>
			/// 备份业务的逻辑
			/// </summary>
			public static HdlBackupLogic Current
			{
			get
			{
			if (m_Current == null)
			{
			m_Current = new HdlBackupLogic();
			}
			return m_Current;
			}
			}

			#endregion

			#region ■ 获取备份名字列表___________________

			/// <summary>
			/// 从云端获取备份数据的名字列表
			/// </summary>
			/// <param name="ZigbeeBackupType">0:App手动备份 1: App 自动备份 2：网关手动备份 3:网关自动备份</param>
			/// <param name="ZigbeeUniqueId">网关的唯一Id,获取网关备份需要</param>
			/// <param name="getOptionBackup">是否获取功能备份</param>
			/// <returns></returns>
			public List<BackupListNameInfo> GetBackupListNameFromDB(int ZigbeeBackupType = 0, string ZigbeeUniqueId = null, bool getOptionBackup = false)
			{
			//备份名字很少的内存，可以直接一次性全部取完
			var pra = new GetBackupListPra();
			pra.BackupType = ZigbeeBackupType;
			pra.GatewayUniqueId = ZigbeeUniqueId;
			pra.PageSetting.Page = 1;
			pra.PageSetting.PageSize = 99999;
			//获取控制主人账号的Token
			pra.LoginAccessToken = UserCenterLogic.GetConnectMainToken();

			//访问接口
			string result = UserCenterLogic.GetResponseDataByRequestHttps("App/GetHomeDataBackupPagger", true, pra);
			if (string.IsNullOrEmpty(result) == true)
			{
			return null;
			}

			var data = Newtonsoft.Json.JsonConvert.DeserializeObject<GetBackupListResult>(result);
			var list = new List<BackupListNameInfo>();
			foreach (var data2 in data.PageData)
			{
			if (ZigbeeUniqueId != null && data2.GatewayUniqueId != ZigbeeUniqueId)
			{
			continue;
			}
			if (getOptionBackup == false && data2.BackupName == DirNameResourse.OptionBackupName)
			{
			//不获取功能备份
			continue;
			}
			list.Add(data2);
			}
			return list;
			}

			/// <summary>
			/// <para>从云端获取备份的文件，然后存入本地指定的临时文件夹</para>
			/// <para>返回文件夹名字(里面存放着全部的文件),返回null时，代表失败</para>
			/// </summary>
			/// <param name="BackupClassId">BackupClassId</param>
			/// <param name="IsGatewayAutoBackup">当前获取是否为网关自动备份</param>
			/// <param name="ZigbeeUniqueId">ZigbeeUniqueId 网关的唯一Id(当IsGatewayBackup=true时，此参数必须提供</param>
			/// <returns></returns>
			public string GetBackFileFromDBAndSetToLocation(string BackupClassId, bool IsGatewayAutoBackup = false, string ZigbeeUniqueId = null)
			{
			//不允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = false;
			UserCenterResourse.AccountOption.AppCanSignout = false;

			//首先先创建一个临时文件夹,存在文件则清空
			string newDir = DirNameResourse.DownLoadBackupTempDirectory;
			HdlFileLogic.Current.CreateDirectory(newDir, true);

			//获取这个备份下面有多少个文件
			List<string> listFile = GetBackFileIDFromDB(BackupClassId, IsGatewayAutoBackup, ZigbeeUniqueId);
			if (listFile == null)
			{
			//关闭进度条
			ProgressFormBar.Current.Close();
			//允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = true;
			UserCenterResourse.AccountOption.AppCanSignout = true;
			return null;
			}

			var pra = new LoadBackInfoPra();
			pra.BackupClassId = BackupClassId;
			pra.IsGatewayAutoBackup = IsGatewayAutoBackup;
			pra.GatewayUniqueId = ZigbeeUniqueId;
			//获取控制主人账号的Token
			pra.LoginAccessToken = UserCenterLogic.GetConnectMainToken();

			//一个个的下载文件
			int listFileCount = listFile.Count;
			for (int i = 0; i < listFile.Count; i++)
			{
			string fileName = listFile[i];
			//账号已经退出
			if (HdlCheckLogic.Current.IsAccountLoginOut() == true)
			{
			//关闭进度条
			ProgressFormBar.Current.Close();
			//允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = true;
			UserCenterResourse.AccountOption.AppCanSignout = true;
			return null;
			}

			//★设置需要获取的文件名字★
			pra.BackupFileName = fileName;
			var result = UserCenterLogic.GetByteResponseDataByRequestHttps("App/DownloadSomeDataBackup", true, pra, null, true);
			if (result == null)
			{
			//关闭进度条
			ProgressFormBar.Current.Close();
			//允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = true;
			UserCenterResourse.AccountOption.AppCanSignout = true;
			return null;
			}
			//将输入写入本地的临时文件夹
			HdlFileLogic.Current.SaveTextToFile(System.IO.Path.Combine(newDir, fileName), System.Text.Encoding.UTF8.GetString(result));
			//设置进度值
			ProgressFormBar.Current.SetValue(i + 1, listFileCount);
			}

			//允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = true;
			UserCenterResourse.AccountOption.AppCanSignout = true;

			return newDir;
			}

			/// <summary>
			/// 从云端获取全部的备份文件的名字
			/// </summary>
			/// <param name="BackupClassId">BackupClassId</param>
			/// <param name="IsGatewayAutoBackup">当前获取是否为网关自动备份</param>
			/// <param name="ZigbeeUniqueId">ZigbeeUniqueId 网关的唯一Id(当IsGatewayBackup=true时，此参数必须提供</param>
			/// <returns></returns>
			private List<string> GetBackFileIDFromDB(string BackupClassId, bool IsGatewayAutoBackup, string ZigbeeUniqueId)
			{
			var pra = new LoadBackInfoPra();
			pra.BackupClassId = BackupClassId;
			pra.PageSetting.PageSize = 999999;
			pra.PageSetting.Page = 1;
			pra.IsGatewayAutoBackup = IsGatewayAutoBackup;
			pra.GatewayUniqueId = ZigbeeUniqueId;
			//获取控制主人账号的Token
			pra.LoginAccessToken = UserCenterLogic.GetConnectMainToken();

			//首先先获取云端有什么文件
			string result = UserCenterLogic.GetResponseDataByRequestHttps("App/GetHomeDataBackupUploadListPagger", true, pra);
			if (string.IsNullOrEmpty(result) == true)
			{
			return null;
			}
			var fileListData = Newtonsoft.Json.JsonConvert.DeserializeObject<LoadBackInfoResult>(result);

			//获取文件名字
			List<string> listFileName = new List<string>();
			foreach (LoadBackupFileNameInfo file in fileListData.PageData)
			{
			listFileName.Add(file.BackupFileName);
			}
			return listFileName;
			}

			#endregion

			#region ■ 创建备份___________________________

			/// <summary>
			/// 创建一个备份名字(成功时返回备份的主键ID，失败时返回null)
			/// </summary>
			/// <param name="backupName">备份名字</param>
			/// <param name="ManualBackupType">手动备份类型(0:App手动备份,2：网关手动备份)</param>
			/// <param name="ZigbeeUniqueId">网关的唯一Id,当ManualBackupType=2时,此值不能为空!</param>
			/// <returns></returns>
			public string CreatNewBackupNameToDB(string backupName, int ManualBackupType = 0, string ZigbeeUniqueId = null)
			{
			var pra = new AddBackUpNamePra();
			pra.BackupName = backupName;
			pra.ManualBackupType = ManualBackupType;
			pra.GatewayUniqueId = ZigbeeUniqueId;
			//获取控制主人账号的Token
			pra.LoginAccessToken = UserCenterLogic.GetConnectMainToken();

			var result = UserCenterLogic.GetResponseDataByRequestHttps("App/AddHomeAppGatewayName", true, pra);
			if (string.IsNullOrEmpty(result) == true)
			{
			return null;
			}
			var data = Newtonsoft.Json.JsonConvert.DeserializeObject<AddBackupNameResult>(result);

			return data.BackupClassId;
			}

			#endregion

			#region ■ 上传备份___________________________

			/// <summary>
			/// 上传本地所有文件到云端(函数内部有进度条)
			/// </summary>
			/// <param name="BackupClassId">备份主键ID</param>
			/// <param name="ManualBackupType">手动备份类型(0:App手动备份,2：网关手动备份)</param>
			/// <param name="upPath">指定上传的是哪个文件夹的文件(全路径),不指定时，上传的是本地路径下的文件</param>
			/// <param name="showBar">是否设置显示进度条</param>
			/// <returns></returns>
			public bool UpLoadBackupFileToDB(string BackupClassId, int ManualBackupType = 0, string upPath = "", bool showBar = true)
			{
			List<string> listAllFile = null;
			//文件夹的全路径
			string fullDir = string.Empty;
			string localTemplateName = string.Empty;
			if (upPath == string.Empty)
			{
			//将模板数据保存到到指定的文件夹中
			var templateName = TemplateData.TemplateCommonLogic.Current.GetNewTemplateFileName();
			var templateFile = TemplateData.TemplateCommonLogic.Current.SaveTemplateDataToFile(templateName, "HomeTemplate");

			//将模板bin文件移动到备份文件夹中
			localTemplateName = System.IO.Path.Combine(Config.Instance.FullPath, templateName);
			try { System.IO.File.Move(templateFile, localTemplateName); }
			catch (Exception ex) { HdlLogLogic.Current.WriteLog(ex, "移动模板失败"); }

			//获取本地文件
			listAllFile = HdlFileLogic.Current.GetRootPathListFile();
			fullDir = Common.Config.Instance.FullPath;
			}
			else
			{
			listAllFile = HdlFileLogic.Current.GetFileFromDirectory(upPath);
			fullDir = upPath;
			}
			if (listAllFile.Count == 0)
			{
			return true;
			}

			//普通文件，可以一次性上传多个的
			List<string> listNormalFile = new List<string>();
			//图片文件，这个东西很大，需要独立出来
			List<string> listPicFile = new List<string>();

			foreach (string fileName in listAllFile)
			{
			//判断指定文件是否需要上传(根目录的才判断)
			if (upPath == string.Empty && this.IsNotUpLoadFile(fileName) == true)
			{
			continue;
			}
			if (fileName.EndsWith(".png") == true
			\|\| fileName.EndsWith(".bin") == true)
			{
			//图片文件
			listPicFile.Add(fileName);
			continue;
			}
			listNormalFile.Add(fileName);
			}

			//开启进度条
			int listFileCount = listPicFile.Count + listNormalFile.Count;
			if (showBar == true)
			{
			//开启进度条正在上传备份文件
			ProgressFormBar.Current.Start();
			ProgressFormBar.Current.SetMsg(Language.StringByID(R.MyInternationalizationString.uBackupFileUploading));
			}

			//不允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = false;
			UserCenterResourse.AccountOption.AppCanSignout = false;

			//你说为什么这里不分一个函数出来（理论上是分函数出来的）
			//是因为如果分函数的话，会出现双重异步，导致主线程的进度条的百分比永远定死0%
			for (int i = 0; i < listNormalFile.Count; i++)
			{
			string file = listNormalFile[i];
			//账号已经退出
			if (HdlCheckLogic.Current.IsAccountLoginOut() == true)
			{
			//关闭进度条
			ProgressFormBar.Current.Close();
			//允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = true;
			UserCenterResourse.AccountOption.AppCanSignout = true;
			if (localTemplateName != string.Empty)
			{
			//删除掉这个模板文件
			HdlFileLogic.Current.DeleteFile(localTemplateName);
			}
			return false;
			}
			//整理数据
			var datainfo = new FileInfoData();
			datainfo.BackupFileName = file;
			string fullFileName = System.IO.Path.Combine(fullDir, file);
			datainfo.BackupFileContent = HdlFileLogic.Current.ReadFileByteContent(fullFileName);

			var list = new List<FileInfoData>();
			list.Add(datainfo);

			//执行上传
			bool falge = DoUpLoadInfoToDB(BackupClassId, list, ManualBackupType);
			if (falge == false)
			{
			//关闭进度条
			ProgressFormBar.Current.Close();
			//允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = true;
			UserCenterResourse.AccountOption.AppCanSignout = true;
			if (localTemplateName != string.Empty)
			{
			//删除掉这个模板文件
			HdlFileLogic.Current.DeleteFile(localTemplateName);
			}
			return false;
			}
			//设置进度值
			ProgressFormBar.Current.SetValue(i + 1, listFileCount);
			}

			for (int i = 0; i < listPicFile.Count; i++)
			{
			string file = listPicFile[i];
			//账号已经退出
			if (HdlCheckLogic.Current.IsAccountLoginOut() == true)
			{
			//关闭进度条
			ProgressFormBar.Current.Close();
			//允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = true;
			UserCenterResourse.AccountOption.AppCanSignout = true;
			if (localTemplateName != string.Empty)
			{
			//删除掉这个模板文件
			HdlFileLogic.Current.DeleteFile(localTemplateName);
			}
			return false;
			}

			var listPic = new List<string>();
			listPic.Add(file);

			//上传本地图片文件到云端
			bool result = UpLoadBigBackupFileToDB(fullDir, listPic, BackupClassId, ManualBackupType);
			if (result == false)
			{
			//关闭进度条
			ProgressFormBar.Current.Close();
			//允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = true;
			UserCenterResourse.AccountOption.AppCanSignout = true;
			if (localTemplateName != string.Empty)
			{
			//删除掉这个模板文件
			HdlFileLogic.Current.DeleteFile(localTemplateName);
			}
			return false;
			}
			//设置进度值
			ProgressFormBar.Current.SetValue(i + 1 + listNormalFile.Count, listFileCount);
			}

			if (localTemplateName != string.Empty)
			{
			//删除掉这个模板文件
			HdlFileLogic.Current.DeleteFile(localTemplateName);
			}

			//进度条关闭
			ProgressFormBar.Current.Close();
			//允许按系统的返回键
			Shared.Common.CommonPage.BackKeyCanClick = true;
			UserCenterResourse.AccountOption.AppCanSignout = true;

			return true;
			}

			/// <summary>
			/// 执行上传到云端
			/// </summary>
			/// <param name="BackupClassId">备份主键ID</param>
			/// <param name="listData">上传的数据</param>
			/// <param name="ManualBackupType">手动备份类型(0:App手动备份,2：网关手动备份)</param>
			/// <returns></returns>
			private bool DoUpLoadInfoToDB(string BackupClassId, List<FileInfoData> listData, int ManualBackupType = 0)
			{
			var upData = new UpLoadDataPra();
			upData.ManualBackupType = ManualBackupType;
			upData.BackupClassId = BackupClassId;
			upData.UploadSubFileLists = listData;
			//获取控制主人账号的Token
			upData.LoginAccessToken = UserCenterLogic.GetConnectMainToken();

			bool falge = UserCenterLogic.GetResultStatuByRequestHttps("App/UploadHomeAppGatewaySubFiles", true, upData, null, true);
			if (falge == false)
			{
			return false;
			}
			return true;
			}

			/// <summary>
			/// 上传本地图片文件到云端
			/// </summary>
			/// <param name="fullDir">文件夹的全路径</param>
			/// <param name="listPicFile">图片文件列表</param>
			/// <param name="BackupClassId">备份主键ID</param>
			/// <param name="ManualBackupType">手动备份类型(0:App手动备份,2：网关手动备份)</param>
			/// <returns></returns>
			private bool UpLoadBigBackupFileToDB(string fullDir, List<string> listPicFile, string BackupClassId, int ManualBackupType = 0)
			{
			foreach (string fileName in listPicFile)
			{
			string fullName = System.IO.Path.Combine(fullDir, fileName);

			NameValueCollection nvc = new NameValueCollection();
			nvc.Add("RequestVersion", Common.CommonPage.RequestVersion);
			nvc.Add("LoginAccessToken", UserCenterLogic.GetConnectMainToken());
			nvc.Add("HomeId", Shared.Common.Config.Instance.Home.Id);
			nvc.Add("BackupClassId", BackupClassId);
			nvc.Add("ManualBackupType", ManualBackupType.ToString());
			nvc.Add("IsOtherAccountCtrl", Common.Config.Instance.Home.IsOthreShare.ToString());

			string base64 = GetBase64Text(fullName);
			nvc.Add("UploadSubFileLists[0].BackupFileName", fileName);
			nvc.Add("UploadSubFileLists[0].BackupFileContent", base64);

			bool result = UpLoadBigBackupFileToDB("App/UploadHomeAppGatewaySubFiles", fullName, nvc);
			if (result == false)
			{
			return false;
			}
			}
			return true;
			}

			/// <summary>
			/// 上传大文件
			/// </summary>
			/// <param name="RequestName">请求接口</param>
			/// <param name="fullFileName">文件名字(含路径)</param>
			/// <param name="nvc"></param>
			/// <returns></returns>
			private bool UpLoadBigBackupFileToDB(string RequestName, string fullFileName, NameValueCollection nvc)
			{
			string paramName = "file";
			string contentType = "application/octet-stream";
			string requestUrl = string.Empty;
			//启用管理员权限
			if (Config.Instance.Home.IsOthreShare == true)
			{
			requestUrl = $"{Config.Instance.AdminRequestBaseUrl}/{RequestName}";
			}
			else
			{
			requestUrl = $"{CommonPage.RequestHttpsHost}/{RequestName}";
			}

			string boundary = "---------------------------" + DateTime.Now.Ticks.ToString("x");
			byte[] boundarybytes = System.Text.Encoding.ASCII.GetBytes("\r\n--" + boundary + "\r\n");

			HttpWebRequest wr = (HttpWebRequest)WebRequest.Create(requestUrl);
			wr.ContentType = "multipart/form-data; boundary=" + boundary;
			wr.Method = "POST";
			wr.KeepAlive = true;
			wr.Credentials = System.Net.CredentialCache.DefaultCredentials;

			Stream rs = wr.GetRequestStream();

			string formdataTemplate = "Content-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}";
			foreach (string key in nvc.Keys)
			{
			rs.Write(boundarybytes, 0, boundarybytes.Length);
			string formitem = string.Format(formdataTemplate, key, nvc[key]);
			byte[] formitembytes = System.Text.Encoding.UTF8.GetBytes(formitem);
			rs.Write(formitembytes, 0, formitembytes.Length);
			}
			rs.Write(boundarybytes, 0, boundarybytes.Length);

			string headerTemplate = "Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"\r\nContent-Type: {2}\r\n\r\n";
			string header = string.Format(headerTemplate, paramName, fullFileName, contentType);
			byte[] headerbytes = System.Text.Encoding.UTF8.GetBytes(header);
			rs.Write(headerbytes, 0, headerbytes.Length);

			FileStream fileStream = new FileStream(fullFileName, FileMode.Open, FileAccess.Read);
			byte[] buffer = new byte[4096];
			int bytesRead = 0;
			while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) != 0)
			{
			rs.Write(buffer, 0, bytesRead);
			}
			fileStream.Close();

			byte[] trailer = System.Text.Encoding.ASCII.GetBytes("\r\n--" + boundary + "--\r\n");
			rs.Write(trailer, 0, trailer.Length);
			rs.Close();

			WebResponse wresp = null;
			try
			{
			wresp = wr.GetResponse();
			Stream stream2 = wresp.GetResponseStream();
			StreamReader reader2 = new StreamReader(stream2);

			string result = reader2.ReadToEnd();
			var data = Newtonsoft.Json.JsonConvert.DeserializeObject<Shared.Common.ResponseEntity.ResponsePack>(result);

			return UserCenterLogic.CheckNotEorrorMsg(data, requestUrl);
			}
			catch
			{
			return false;
			}
			finally
			{
			if (wresp != null)
			{
			wresp.Close();
			wresp = null;
			}
			wr = null;
			}
			}

			#endregion

			#region ■ 上传Log备份________________________

			/// <summary>
			/// 上传Log备份(隐匿功能)
			/// </summary>
			/// <returns></returns>
			public bool UpLoadLogBackup()
			{
			string upPath = DirNameResourse.LogDirectory;
			if (HdlFileLogic.Current.GetFileFromDirectory(upPath).Count == 0)
			{
			//没有Log文件
			return true;
			}

			ProgressFormBar.Current.Start();
			ProgressFormBar.Current.SetMsg("正在上传Log文件");

			//从云端获取数据
			var pageData = HdlBackupLogic.Current.GetBackupListNameFromDB(0, null, true);
			if (pageData == null)
			{
			ProgressFormBar.Current.Close();
			return false;
			}
			string backId = string.Empty;
			for (int i = 0; i < pageData.Count; i++)
			{
			if (pageData[i].BackupName == DirNameResourse.OptionBackupName)
			{
			//获取功能备份的ID
			backId = pageData[i].Id;
			break;
			}
			}
			if (backId == string.Empty)
			{
			//创建新的备份
			backId = HdlBackupLogic.Current.CreatNewBackupNameToDB(DirNameResourse.OptionBackupName);
			if (backId == null)
			{
			ProgressFormBar.Current.Close();
			return false;
			}
			}
			//上传Log文件
			bool result = this.UpLoadBackupFileToDB(backId, 0, upPath, false);
			if (result == true)
			{
			try
			{
			var listAllFile = HdlFileLogic.Current.GetFileFromDirectory(upPath);
			if (listAllFile.Count > 10)
			{
			listAllFile.Sort();
			while (listAllFile.Count >= 10)
			{
			System.IO.File.Delete(listAllFile[0]);
			listAllFile.RemoveAt(0);
			}
			}
			}
			catch { }
			}
			ProgressFormBar.Current.Close();

			HdlThreadLogic.Current.RunMain(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Tip, "Log上传成功");
			contr.Show();
			});

			return result;
			}

			/// <summary>
			/// 上传东西到隐匿功能备份
			/// </summary>
			/// <param name="fileName"></param>
			/// <param name="byteData"></param>
			/// <returns></returns>
			public bool UpLoadByteDataToOptionBackup(string fileName, byte[] byteData)
			{
			ProgressFormBar.Current.Start();
			ProgressFormBar.Current.SetMsg("正在上传文件");

			//从云端获取数据
			var pageData = HdlBackupLogic.Current.GetBackupListNameFromDB(0, null, true);
			if (pageData == null)
			{
			ProgressFormBar.Current.Close();
			HdlThreadLogic.Current.RunMain(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Tip, "获取功能备份失败");
			contr.Show();
			});
			return false;
			}
			string backId = string.Empty;
			for (int i = 0; i < pageData.Count; i++)
			{
			if (pageData[i].BackupName == DirNameResourse.OptionBackupName)
			{
			//获取功能备份的ID
			backId = pageData[i].Id;
			break;
			}
			}
			if (backId == string.Empty)
			{
			//创建新的备份
			backId = this.CreatNewBackupNameToDB(DirNameResourse.OptionBackupName);
			if (backId == null)
			{
			ProgressFormBar.Current.Close();
			HdlThreadLogic.Current.RunMain(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Tip, "创建功能备份失败");
			contr.Show();
			});
			return false;
			}
			}
			//上传Log文件
			var datainfo = new FileInfoData();
			datainfo.BackupFileName = fileName;
			datainfo.BackupFileContent = byteData;

			var list = new List<FileInfoData>();
			list.Add(datainfo);

			//执行上传
			bool falge = DoUpLoadInfoToDB(backId, list, 0);
			//关闭进度条
			ProgressFormBar.Current.Close();

			if (falge == false)
			{
			HdlThreadLogic.Current.RunMain(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Tip, "文件上传成功");
			contr.Show();
			});
			return false;
			}
			HdlThreadLogic.Current.RunMain(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Tip, "文件上传成功");
			contr.Show();
			});

			return true;
			}

			#endregion

			#region ■ 读取隐匿功能配置___________________

			/// <summary>
			/// 读取隐匿功能配置(不要在意返回值)
			/// </summary>
			/// <returns></returns>
			public bool LoadHideOption()
			{
			//先初始化
			UserCenterResourse.HideOption = new HideOptionInfo();
			if (UserCenterResourse.UserInfo.AuthorityNo != 1 && UserCenterResourse.UserInfo.AuthorityNo != 2)
			{
			return true;
			}

			//无视错误
			IMessageCommon.Current.IgnoreError = true;
			//从云端获取数据
			var pageData = this.GetBackupListNameFromDB(0, null, true);
			if (pageData == null)
			{
			//恢复
			IMessageCommon.Current.IgnoreError = false;
			return false;
			}
			string backId = string.Empty;
			for (int i = 0; i < pageData.Count; i++)
			{
			if (pageData[i].BackupName == DirNameResourse.OptionBackupName)
			{
			//获取功能备份的ID
			backId = pageData[i].Id;
			break;
			}
			}
			if (backId == string.Empty)
			{
			//没有功能配置
			IMessageCommon.Current.IgnoreError = false;
			return true;
			}
			//获取这个备份下面有多少个文件
			List<string> listFile = GetBackFileIDFromDB(backId, false, null);
			if (listFile == null)
			{
			//恢复
			IMessageCommon.Current.IgnoreError = false;
			return false;
			}
			if (listFile.Count == 0)
			{
			//恢复
			IMessageCommon.Current.IgnoreError = false;
			return true;
			}

			//检测
			string checkKeys = UserCenterLogic.EncryptPassword(UserCenterResourse.FileEncryptKey, DirNameResourse.ShowOptionMenuFile + UserCenterResourse.UserInfo.Account);
			if (listFile.Contains(checkKeys) == true)
			{
			//显示主页隐藏菜单(Debug用)
			UserCenterResourse.HideOption.CenterHideMenu = 1;
			}
			checkKeys = UserCenterLogic.EncryptPassword(UserCenterResourse.FileEncryptKey, DirNameResourse.DetailedLogFile + UserCenterResourse.UserInfo.Account);
			if (listFile.Contains(checkKeys) == true)
			{
			//出力详细Log(Debug用)
			UserCenterResourse.HideOption.DetailedLog = 1;
			}
			checkKeys = UserCenterLogic.EncryptPassword(UserCenterResourse.FileEncryptKey, DirNameResourse.DeviceHistoryFile + UserCenterResourse.UserInfo.Account);
			if (listFile.Contains(checkKeys) == true)
			{
			//显示设备历史版本(Debug用)
			UserCenterResourse.HideOption.DeviceHistory = 1;
			}
			checkKeys = UserCenterLogic.EncryptPassword(UserCenterResourse.FileEncryptKey, DirNameResourse.StartDebugAppFile + UserCenterResourse.UserInfo.Account);
			if (listFile.Contains(checkKeys) == true)
			{
			//开启后台调试App功能(Debug用)
			UserCenterResourse.HideOption.StartDebugApp = 1;
			}
			checkKeys = UserCenterLogic.EncryptPassword(UserCenterResourse.FileEncryptKey, DirNameResourse.CheckDeviceTypeFile + UserCenterResourse.UserInfo.Account);
			if (listFile.Contains(checkKeys) == true)
			{
			//开启检测设备Type的(Debug用)
			UserCenterResourse.HideOption.CheckDeviceType = 1;
			}

			//恢复
			IMessageCommon.Current.IgnoreError = false;
			return true;
			}

			#endregion

			#region ■ 读取备份___________________________

			/// <summary>
			/// 读取APP备份文档(函数内部有进度条)
			/// </summary>
			/// <param name="BackupClassId"></param>
			public bool LoadAppBackupInfo(string BackupClassId)
			{
			//打开进度条正在获取备份文件列表
			ProgressFormBar.Current.Start();
			ProgressFormBar.Current.SetMsg(Language.StringByID(R.MyInternationalizationString.uBackupFileListGetting));

			//从云端获取备份的文件，然后存入本地的临时文件夹
			string tempDirectory = GetBackFileFromDBAndSetToLocation(BackupClassId);
			if (tempDirectory == null)
			{
			//关闭进度条
			ProgressFormBar.Current.Close();
			return false;
			}

			//清空全部房间
			HdlRoomLogic.Current.DeleteAllRoom();
			//清空本地全部的场景数据
			HdlSceneLogic.Current.DeleteAllLocalScene();
			//如果读取到的文件完全没有问题，则清理本地的文件
			HdlFileLogic.Current.DeleteAllLocationFile(false);

			//清理本地的模板文件
			TemplateData.TemplateCommonLogic.Current.DeleteAllLocalFile();

			//没有错误的话，则移动到当前住宅文件夹下面
			HdlFileLogic.Current.MoveDirectoryFileToHomeDirectory(tempDirectory, true);

			//删除全部的自动备份的本地文件(此函数用于读取自动备份的时候使用)
			HdlAutoBackupLogic.DeleteAllAutoBackupFile();

			//刷新本地缓存
			UserCenterLogic.RefreshAllMemory();

			//关闭进度条
			ProgressFormBar.Current.Close();

			return true;
			}

			#endregion

			#region ■ 删除备份___________________________

			/// <summary>
			/// 删除云端备份
			/// </summary>
			/// <param name="BackupClassId">备份的主键</param>
			/// <returns></returns>
			public bool DeleteDbBackupData(string BackupClassId)
			{
			var Pra = new LoadBackInfoPra();
			Pra.BackupClassId = BackupClassId;
			//获取控制主人账号的Token
			Pra.LoginAccessToken = UserCenterLogic.GetConnectMainToken();

			bool success = UserCenterLogic.GetResultStatuByRequestHttps("App/DelHomeAppGatewayName", true, Pra);

			return success;
			}

			#endregion

			#region ■ 一般方法___________________________

			/// <summary>
			/// 判断是否是应该上传的文件
			/// </summary>
			/// <param name="file"></param>
			/// <returns></returns>
			private bool IsNotUpLoadFile(string file)
			{
			if (file.StartsWith("Device_") == true
			\|\| file.StartsWith("Gateway_") == true
			\|\| file.StartsWith("Room_") == true
			\|\| file.StartsWith("Scene_") == true)
			{
			//设备,网关,房间,场景文件不需要上传,它已经保存在bin模板文件中
			return true;
			}
			return false;
			}

			/// <summary>
			/// 将文件转为Base64字符串
			/// </summary>
			/// <param name="fileName"></param>
			/// <returns></returns>
			private string GetBase64Text(string fileName)
			{
			string path = Config.Instance.FullPath;
			string fullName = System.IO.Path.Combine(path, fileName);

			FileStream fs = File.OpenRead(fullName);
			byte[] buff = new byte[fs.Length];
			fs.Read(buff, 0, buff.Length);
			fs.Close();

			string base64 = Convert.ToBase64String(buff);
			return base64;
			}

			#endregion
			}
			}