/// <summary>
/// 把[Data对象]转换为[BaseData对象]
/// </summary>
/// <param name="_data">要转换的Data对象</param>
/// <returns>转换后的BaseData对象</returns>
public static RecordBaseData DataToBaseData(RecordData _data)
{
if (_data != null)
{
RecordBaseData _baseData = new RecordBaseData();
_baseData.Id = _data.Id;
_baseData.BugId = _data.BugId;
_baseData.ReplyId = _data.ReplyId;
_baseData.Content = _data.Content;
_baseData.Time = new List <int>()
{
_data.Time.Year, _data.Time.Month, _data.Time.Day, _data.Time.Hour, _data.Time.Minute, _data.Time.Second
};
_baseData.Images = ObservableCollectionTool.ObservableCollectionToList(_data.Images);
_baseData.IsDelete = _data.IsDelete;
return(_baseData);
}
else
{
return(null);
}
}
/// <summary>
/// 复制一个RecordData对象
/// </summary>
/// <param name="_recordData">要复制哪个？</param>
/// <returns>复制出来的RecordData对象</returns>
public static RecordData Copy(RecordData _recordData)
{
if (_recordData == null)
{
return(null);
}
else
{
RecordData _copyRecordData = new RecordData();
_copyRecordData.Id = _recordData.Id;
_copyRecordData.BugId = _recordData.BugId;
_copyRecordData.ReplyId = _recordData.ReplyId;
_copyRecordData.Content = _recordData.Content;
_copyRecordData.Time = _recordData.Time;
_copyRecordData.IsDelete = _recordData.IsDelete;
_copyRecordData.Images = new ObservableCollection <string>();
for (int i = 0; i < _recordData.Images.Count; i++)
{
_copyRecordData.Images.Add(_recordData.Images[i]);
}
return(_copyRecordData);
}
}
/// <summary>
/// 清除（删除）所有要删除的图片文件
/// </summary>
private void DeleteImageFile()
{
//取到图片文件夹的信息
DirectoryInfo _imageDirectoryInfo = new DirectoryInfo(AppManager.Systems.ImageSystem.ImageFolderPath);
//取到所有的图片文件
FileInfo[] _imageFileInfos = _imageDirectoryInfo.GetFiles();
//容器：所有要删除的图片文件
List <FileInfo> _deleteImageFileInfos = new List <FileInfo>();
//遍历所有的图片文件
for (int i = 0; i < _imageFileInfos.Length; i++)
{
try
{
//取到图片文件的名字
string _fileName = Path.GetFileNameWithoutExtension(_imageFileInfos[i].FullName);
//把[图片名字]转换为[RecordId]
long _recordId = AppManager.Systems.ImageSystem.ImageFileNameToRecordId(_fileName);
//如果转换成功
if (_recordId > -1)
{
//获取这个记录文件
RecordData _recordData = AppManager.Systems.RecordSystem.GetRecordData(_recordId);
//如果这个记录被标记为删除
if (_recordData != null && _recordData.IsDelete == true)
{
//标记这个图片为要删除的图片
_deleteImageFileInfos.Add(_imageFileInfos[i]);
}
}
}
catch (Exception e)
{
}
}
//删除所有已经删除的记录文件
for (int i = 0; i < _deleteImageFileInfos.Count; i++)
{
try
{
File.Delete(_deleteImageFileInfos[i].FullName);
}
catch (Exception e)
{
}
}
}
/// <summary>
/// 这个方法，用于触发 ClickRecordListItemDeleteButton 路由事件
/// </summary>
/// <param name="_source">触发事件的RecordData对象</param>
private void OnClickRecordListItemDeleteButton(RecordData _source)
{
//创建路由事件参数
RoutedPropertyChangedEventArgs <RecordData> args = new RoutedPropertyChangedEventArgs <RecordData>(_source, _source);
//设置这是哪个路由事件？
args.RoutedEvent = BugUiControl.ClickRecordListItemDeleteButtonEvent;
args.Source = _source;
//引发这个路由事件
RaiseEvent(args);
}
/// <summary>
/// 验证完整性
/// （验证1个Record的完整性。
/// 如果Record是完整的，代表这个Record是有效的；
/// 如果Record是不完整的，代表Record文件还没有同步完，或者是Record文件已损坏）
/// </summary>
/// <param name="_recordData">要验证的Record</param>
/// <returns>Record是否是完整的</returns>
public static bool VerifyIntegrity(RecordData _recordData)
{
if (_recordData == null ||
_recordData.Id < 0 || _recordData.BugId < 0 || _recordData.ReplyId < 0)
{
return(false);
}
else
{
return(true);
}
}
/// <summary>
/// 获取Bug的数据
/// (通过记录，获取记录所在的Bug数据)
/// </summary>
/// <param name="_recordData">记录的数据</param>
/// <returns>记录所在的Bug数据</returns>
public BugData GetBugData(RecordData _recordData)
{
if (_recordData != null)
{
//根据记录，获取Bug
BugData _bugData = GetBugData(_recordData.BugId);
return(_bugData);
}
else
{
return(null);
}
}
/// <summary>
/// 添加图片
/// </summary>
/// <param name="_recordId">记录的编号</param>
/// <param name="_imagePath">图片的完整路径（包括文件夹+文件名+文件后缀）</param>
public void AddImageFile(long _recordId, string _imagePath)
{
//通过RecordId，获取到Bug对象
RecordData _recordData = AppManager.Systems.RecordSystem.GetRecordData(_recordId);
//保存图片，并获取到图片的新名字
string _newImageName = this.CopyImageFile(_imagePath, _recordData);
//然后，把新的图片名字，添加到记录里
_recordData.Images.Add(_newImageName);
//更新Ui
_recordData.BearRecordItemData.ImagePaths = AppManager.Systems.ImageSystem.GetImagePaths(_recordData.Images);
}
/// <summary>
/// 当点击[确认]按钮时
/// </summary>
public void ClickYesButton()
{
//获取Bug和记录
RecordData _recordData = UiControl.Data as RecordData;
//删除记录
AppManager.Systems.RecordSystem.RemoveRecord(_recordData);
//关闭界面
this.OpenOrClose(false);
//清空Bug
UiControl.Data = null;
}
/// <summary>
/// 保存1个记录
/// </summary>
/// <param name="_modeType">项目模式的类型</param>
/// <param name="_recordId">要保存的Record的编号</param>
public void SaveRecord(ModeType _modeType, long _recordId)
{
/* 保存 */
try
{
//判断项目的模式
switch (_modeType)
{
//如果项目是[默认模式]：把所有的Record，保存到/Record/Records.json文件中
case ModeType.Default:
SaveRecords(_modeType);
break;
//如果项目是[协同合作模式]：把每一个Record，分别保存到/Record/Record - 20200119080230555.json文件中
case ModeType.Collaboration:
//通过Id取到Record
RecordData _recordData = GetRecordData(_recordId);
if (_recordData != null)
{
//把RecordData转换为RecordBaseData
RecordBaseData _recordBaseData = RecordBaseData.DataToBaseData(_recordData);
//把RecordBaseData转换为json
string _recordJsonText = JsonMapper.ToJson(_recordBaseData);
//Record文件的路径（文件夹+文件名+后缀）
string _recordFilePath = RecordFolderPath + "/Record - " + _recordBaseData.Id + AppManager.Systems.ProjectSystem.OtherFileSuffix;
//把json文件保存到[Record - RecordId.json]文件里
File.WriteAllText(_recordFilePath, _recordJsonText, Encoding.Default);
}
break;
}
}
/* 如果有错误，就输出错误 */
catch (Exception e)
{
//输出错误
AppManager.Uis.ErrorUi.UiControl.TipContent = e.ToString();
AppManager.Uis.ErrorUi.OpenOrClose(true);
}
}
/// <summary>
/// 获取[Record]日志的文字
/// （通过比较新Record和旧Record的区别，来生成日志的文字）
/// </summary>
/// <param name="_oldRecordData">旧的Record数据</param>
/// <param name="_newRecordData">新的Record数据</param>
/// <param name="_changeType">改变的类型</param>
/// <returns>Record的修改信息</returns>
private string GenerateRecordSyncLogText(RecordData _oldRecordData, RecordData _newRecordData, ChangeType _changeType)
{
//容器：Record的日志
string _log = "";
//取到Bug
BugData _oldBugData = AppManager.Systems.BugSystem.GetBugData(_oldRecordData);
BugData _newBugData = AppManager.Systems.BugSystem.GetBugData(_newRecordData);
//判断是否有修改？
switch (_changeType)
{
//如果是[新建Record]
case ChangeType.Add:
//文字：添加 聊天记录: [Bug：XXXXXXXXX]
if (_newBugData != null)
{
_log = AddString + " " + RecordString + ": [Bug：" + StringTool.Clamp(_newBugData.Name.Text, 25) + "]";
}
else if (_oldBugData != null)
{
_log = AddString + " " + RecordString + ": [Bug：" + StringTool.Clamp(_oldBugData.Name.Text, 25) + "]";
}
break;
//如果是[删除Record]
case ChangeType.Delete:
//文字：添加 聊天记录: [Bug：XXXXXXXXX]
if (_newBugData != null)
{
_log = DeleteString + " " + RecordString + ": [Bug：" + StringTool.Clamp(_newBugData.Name.Text, 25) + "]";
}
else if (_oldBugData != null)
{
_log = DeleteString + " " + RecordString + ": [Bug：" + StringTool.Clamp(_oldBugData.Name.Text, 25) + "]";
}
break;
}
//返回值
return(_log);
}
/// <summary>
/// 比较2个Record数据
/// </summary>
/// <param name="_compareType">是比较所有的属性，还是只比较编号？</param>
/// <param name="_recordData1">第1个Record数据</param>
/// <param name="_recordData2">第2个Record数据</param>
/// <returns>2个Record数据是否相同？</returns>
public static bool Compare(CompareType _compareType, RecordData _recordData1, RecordData _recordData2)
{
if (_recordData1 == null || _recordData2 == null)
{
return(false);
}
//是否相同？
bool _isSame = false;
//比较
switch (_compareType)
{
case CompareType.Id:
if (_recordData1.Id == _recordData2.Id)
{
_isSame = true;
}
else
{
_isSame = false;
}
break;
case CompareType.All:
if (_recordData1.Id == _recordData2.Id && _recordData1.BugId == _recordData2.BugId &&
_recordData1.ReplyId == _recordData2.ReplyId && _recordData1.Content == _recordData2.Content &&
_recordData1.Time == _recordData2.Time && _recordData1.IsDelete == _recordData2.IsDelete)
{
_isSame = true;
}
else
{
_isSame = false;
}
break;
}
//返回值
return(_isSame);
}
/// <summary>
/// 复制图片
/// (复制1张图片到Image文件夹，并把图片的名字更改为ImageId.png)
/// </summary>
/// <param name="_imagePath">图片的完整路径（包括文件夹+文件名+文件后缀）</param>
/// <param name="_recordData">这个图片是属于哪个记录的？</param>
/// <returns>返回：图片的新名字(ImageId.png)</returns>
private string CopyImageFile(string _imagePath, RecordData _recordData)
{
try
{
//获取文件的信息
FileInfo _fileInfo = new FileInfo(_imagePath);
//容器：图片的新名字
string _newImageName = "";
//如果这个文件存在
if (_fileInfo.Exists == true)
{
//图片的名字(Extension属性是文件名的后缀名)
_newImageName = _recordData.Id.ToString();
//图片的新路径
string _newImagePath = ImageFolderPath + "/" + _newImageName + _fileInfo.Extension;
_newImagePath = FileTool.AvoidSameFile(_newImagePath);
//取到新的图片名字
_newImageName = Path.GetFileNameWithoutExtension(_newImagePath) + _fileInfo.Extension;
//然后把原图片，复制到新的路径地址上
byte[] _oldImageBytes = File.ReadAllBytes(_imagePath); //取到旧的图片的二进制数据
File.WriteAllBytes(_newImagePath, _oldImageBytes); //把旧图片的二进制信息，写进新图片文件中
}
//返回值
return(_newImageName);
}
catch (Exception e)
{
//输出错误
AppManager.Uis.ErrorUi.UiControl.TipContent = e.ToString();
AppManager.Uis.ErrorUi.OpenOrClose(true);
return("");
}
}
/// <summary>
/// 删除记录
/// (删除Bug中的一条记录)
/// </summary>
public void RemoveRecord(RecordData _recordData)
{
//所有记录
ObservableCollection <RecordData> _allRecords = RecordDatas;
ObservableCollection <RecordItemData> _allShowRecords = ShowRecordItemDatas;
//标记要删除的记录
/* (把1个记录文件，标记为要删除的文件)
* (如果不标记，直接删除的话，会报错。所以先标记，然后在下次软件启动的时候，再由[DeleteSystem系统]真正的把文件删除)*/
_recordData.IsDelete = true;
//把记录从ShowRecordItemDatas字段中删除
for (int i = 0; i < _allShowRecords.Count; i++)
{
_allShowRecords.Remove(_recordData.BearRecordItemData);
_allShowRecords.Remove(_recordData.BugRecordItemData);
}
//保存记录
SaveRecord(AppManager.Systems.CollaborationSystem.ModeType, _recordData.Id);
}
/// <summary>
/// 当点击[记录列表的Item]的[删除]按钮的时候
/// </summary>
/// <param name="_source">触发事件的RecordData对象</param>
public void ClickRecordListItemDeleteButton(RecordData _source)
{
//如果用户选择了Bug
if (_source != null)
{
//如果[还要提示]
if (AppManager.Datas.AppData.IsNotAgainShowDeleteRecordTip == false)
{
//显示删除Bug界面
AppManager.Uis.DeleteRecordTipUi.UiControl.Data = _source;
AppManager.Uis.DeleteRecordTipUi.UiControl.Text = StringTool.Clamp(_source.Content, 25);
AppManager.Uis.DeleteRecordTipUi.OpenOrClose(true);
}
//如果[不再提示]
else
{
//直接删除Bug
AppManager.Systems.RecordSystem.RemoveRecord(_source);
}
}
}
/// <summary>
/// 添加记录
/// (往Bug中，添加1条记录)
/// </summary>
/// <param name="_bugData">对哪个BugData进行操作？</param>
/// <param name="_content">记录的内容</param>
/// <param name="_images">图片的路径</param>
public void AddRecord(BugData _bugData, string _content, ObservableCollection <string> _images = null)
{
/* 创建记录 */
//创建记录数据
RecordData _recordData = new RecordData();
_recordData.Id = DateTimeTool.DateTimeToLong(DateTime.UtcNow, TimeFormatType.YearMonthDayHourMinuteSecondMillisecond);
_recordData.BugId = _bugData.Id;
_recordData.Content = _content;
_recordData.Time = DateTime.UtcNow;
//添加到Record数据中
AppManager.Datas.ProjectData.RecordDatas.Add(_recordData);
//保存图片
if (_images != null)
{
//遍历所有的图片
for (int i = 0; i < _images.Count; i++)
{
//保存图片（赋值图片）
AppManager.Systems.ImageSystem.AddImageFile(_recordData.Id, _images[i]);
}
}
//赋值Bug里的ShowRecords属性
AppManager.Systems.RecordSystem.SetShowRecords(_bugData, AppManager.Datas.OtherData.IsShowBugReply);
/* 回复记录 (当Bear说话后，Bug需要回复一句话) */
_recordData.ReplyId = AppManager.Systems.TemperamentSystem.RandomReply(_bugData.TemperamentId);//随机1个回复
/* 保存记录 */
SaveRecord(AppManager.Systems.CollaborationSystem.ModeType, _recordData.Id);
}
/// <summary>
/// 把[BaseData对象]转换为[Data对象]
/// </summary>
/// <param name="_baseData">要转换的BaseData对象</param>
/// <returns>转换后的Data对象</returns>
public static RecordData BaseDataToData(RecordBaseData _baseData)
{
if (_baseData != null)
{
RecordData _data = new RecordData();
_data.Id = _baseData.Id;
_data.BugId = _baseData.BugId;
_data.ReplyId = _baseData.ReplyId;
_data.Content = _baseData.Content;
_data.Time = new DateTime(_baseData.Time[0], _baseData.Time[1], _baseData.Time[2], _baseData.Time[3], _baseData.Time[4], _baseData.Time[5]);
_data.Images = ObservableCollectionTool.ListToObservableCollection(_baseData.Images);
_data.IsDelete = _baseData.IsDelete;
return(_data);
}
else
{
return(null);
}
}
/// <summary>
/// 比较[旧Record]和[新Record]
/// （看下新Record相对旧Record来说，进行了哪些修改？）
/// </summary>
/// <param name="_oldRecordData">旧的Record</param>
/// <param name="_newRecordData">新的Record</param>
/// <returns>修改了什么？</returns>
public ChangeType CompareOldRecordAndNewRecord(RecordData _oldRecordData, RecordData _newRecordData)
{
/* [新建Record] ：
* 第一种情况：Old为空，New不为空
* 第二种情况：Old不为空，New不为空，Old已删除，New未删除*/
if ((_oldRecordData == null && _newRecordData != null && _newRecordData.IsDelete != true) ||
(_oldRecordData != null && _newRecordData != null && _oldRecordData.IsDelete == true && _newRecordData.IsDelete != true))
{
return(ChangeType.Add);
}
/* [删除Record] :
* 第一种情况：Old不为空，并且New为空
* 第二种情况：Old不为空，并且Old不为true，并且New不为空，并且New为true*/
else if ((_oldRecordData != null && _newRecordData == null && _oldRecordData.IsDelete != true) ||
(_oldRecordData != null && _newRecordData != null && _oldRecordData.IsDelete != true && _newRecordData.IsDelete == true))
{
return(ChangeType.Delete);
}
return(ChangeType.None);
}
/// <summary>
/// 当点击[记录列表的Item]的[图片]按钮的时候
/// </summary>
/// <param name="_imagePath">点击的 图片的路径</param>
/// <param name="_source">触发事件的RecordData对象</param>
public void ClickRecordListItemImageButton(string _imagePath, RecordData _source)
{
//打开[图片界面]
AppManager.Systems.ImageSystem.ShowImagePath = _imagePath;
AppManager.Uis.ImageUi.OpenOrClose(true);
}
/// <summary>
/// 读取所有记录
/// </summary>
/// <param name="_modeType">项目模式的类型</param>
public void LoadRecords(ModeType _modeType)
{
try
{
//判断项目的模式
switch (_modeType)
{
//如果项目是[默认模式]：所有的Record，都在/Record/Records.json文件中
case ModeType.Default:
//Record文件的路径（文件夹+文件名+后缀）
string _recordsFilePath = RecordFolderPath + "/Records" + AppManager.Systems.ProjectSystem.OtherFileSuffix;
//FileInfo类 用于读取文件信息
FileInfo _recordsFileInfo = new FileInfo(_recordsFilePath);
/* 判断文件是否存在 */
if (_recordsFileInfo.Exists == true) //如果存在
{
//读取[Record]的Json文本中的内容
string _recordsJsonText = File.ReadAllText(_recordsFilePath);
//然后把Json文本解析成RecordBaseData对象
List <RecordBaseData> _recordBaseDatas = JsonMapper.ToObject <List <RecordBaseData> >(_recordsJsonText);
//创建RecordData对象的集合
ObservableCollection <RecordData> _recordDatas = new ObservableCollection <RecordData>();
//把BugBaseData对象，转化为BugData对象
if (_recordBaseDatas != null)
{
for (int i = 0; i < _recordBaseDatas.Count; i++)
{
RecordData _recordData = RecordBaseData.BaseDataToData(_recordBaseDatas[i]);
if (_recordData != null)
{
_recordDatas.Add(_recordData);
}
}
}
//把[RecordData对象]赋值到[列表]中
RecordDatas = _recordDatas;
}
break;
//如果项目是[协同合作模式]：每一个Record，分别在/Record/Record - 20200119080230555.json文件中
case ModeType.Collaboration:
//取到Record文件夹 的信息
DirectoryInfo _recordDirectoryInfo = new DirectoryInfo(RecordFolderPath);
//获取到Record文件夹内所有的文件 的信息
FileInfo[] _recordFileInfos = _recordDirectoryInfo.GetFiles();
//遍历所有的Record文件
for (int i = 0; i < _recordFileInfos.Length; i++)
{
//取到Record文件的名字
string _recordFileName = Path.GetFileNameWithoutExtension(_recordFileInfos[i].FullName);
//把[Record文件的名字]转换为[RecordId]
_recordFileName = _recordFileName.Replace("Record - ", "");
long _recordId = -1;
bool _isParseOk = long.TryParse(_recordFileName, out _recordId); //把string转换为long
//如果转换成功
if (_isParseOk == true)
{
//就读取这个Record
LoadRecord(ModeType.Collaboration, _recordId);
}
}
break;
}
}
/* 如果有错误，就输出错误 */
catch (Exception e)
{
//输出错误
AppManager.Uis.ErrorUi.UiControl.TipContent = e.ToString();
AppManager.Uis.ErrorUi.OpenOrClose(true);
}
}
/// <summary>
/// 读取1个记录
/// </summary>
/// <param name="_modeType">项目模式的类型</param>
/// <param name="_recordId">Record的编号（通过Record的编号，来读取记录）</param>
public void LoadRecord(ModeType _modeType, long _recordId)
{
try
{
//判断项目的模式
switch (_modeType)
{
//如果项目是[默认模式]：所有的Record，都在/Record/Records.json文件中
case ModeType.Default:
LoadRecords(_modeType);
break;
//如果项目是[协同合作模式]：每一个Record，分别在/Record/Record - 20200119080230555.json文件中
case ModeType.Collaboration:
//Record文件的路径（文件夹+文件名+后缀）
string _recordFilePath = RecordFolderPath + "/Record - " + _recordId + AppManager.Systems.ProjectSystem.OtherFileSuffix;
//FileInfo类 用于读取文件信息
FileInfo _recordFileInfo = new FileInfo(_recordFilePath);
/* 判断文件是否存在 */
if (_recordFileInfo.Exists == true) //如果存在
{
//读取[Record]的Json文本中的内容
string _recordJsonText = File.ReadAllText(_recordFilePath);
//然后把Json文本解析成RecordBaseData对象
RecordBaseData _recordBaseData = null;
try
{
_recordBaseData = JsonMapper.ToObject <RecordBaseData>(_recordJsonText);
}
catch (Exception e)
{
}
//把BugBaseData对象，转化为BugData对象
RecordData _recordData = RecordBaseData.BaseDataToData(_recordBaseData);
//如果RecordData的完整度为true
if (RecordData.VerifyIntegrity(_recordData) == true)
{
//把[RecordData对象]赋值到[列表]中
RecordData _oldRecordData = GetRecordData(_recordData.Id); //通过BugId获取到旧的Record对象
if (_oldRecordData != null) //如果有旧的Record对象
{
//如果旧的Record和新的Record有不同的地方
if (RecordData.Compare(CompareType.All, _recordData, _oldRecordData) == false)
{
//修改旧的Record对象的值
_oldRecordData.BugId = _recordData.BugId;
_oldRecordData.ReplyId = _recordData.ReplyId;
_oldRecordData.Content = _recordData.Content;
_oldRecordData.Time = _recordData.Time;
_oldRecordData.IsDelete = _recordData.IsDelete;
_oldRecordData.Images = _recordData.Images;
}
}
else
{
RecordDatas.Add(_recordData); //把读取到的Record对象，添加到列表中
}
}
}
break;
}
}
catch (Exception e)
{
//输出错误
AppManager.Uis.ErrorUi.UiControl.TipContent = e.ToString();
AppManager.Uis.ErrorUi.OpenOrClose(true);
}
}
/// <summary>
/// 同步
/// （当有文件更改时，3秒后，把已经修改的文件，进行同步）
/// </summary>
/// <returns>是否有新的数据被同步？（true代表，有数据被同步了；false代表，这次的修改没有数据被同步）</returns>
public bool Sync()
{
if (ModeType != ModeType.Collaboration)
{
return(false);
}
/* 获取数据 */
List <long> _syncBugIds = SyncBugIds;
List <long> _syncRecordIds = SyncRecordIds;
/* 清除数据 */
SyncBugIds = new List <long>();
SyncRecordIds = new List <long>();
/* 数据容器 */
List <string> _bugLogs; //Bug的日志
List <string> _recordLogs; //记录的日志
Dictionary <long, ChangeType> _bugChangeTypes; //Bug的改变
Dictionary <long, ChangeType> _recordChangeTypes; //记录的改变
/*同步*/
SyncBug(_syncBugIds, out _bugChangeTypes, out _bugLogs);
SyncRecord(_syncRecordIds, out _recordChangeTypes, out _recordLogs);
/*更新Ui：Bug*/
if (_bugLogs.Count > 0)
{
/* 重新排列 */
//重新获取Bug的个数+页数
AppManager.Systems.BugSystem.CalculatedBugsNumber();
AppManager.Systems.PageSytem.CalculatedPagesNumber();
//重新排序
AppManager.Systems.SortSystem.Sort();
//重新过滤
AppManager.Systems.SearchSystem.Filter();
//重新计算页数
AppManager.Systems.PageSytem.CalculatedPagesNumber();
/*更新Ui*/
foreach (long _bugId in _bugChangeTypes.Keys)//遍历所有的改变
{
//获取Bug数据
BugData _bugData = AppManager.Systems.BugSystem.GetBugData(_bugId);
//获取改变
ChangeType _changeType = ChangeType.None;
_bugChangeTypes.TryGetValue(_bugId, out _changeType);
//判断Bug的改变
if (_bugData != null)
{
switch (_changeType)
{
//如果是[添加Bug]
case ChangeType.Add:
//把Bug插入到当前的页面中
AppManager.Systems.PageSytem.Insert(_bugData);
break;
//如果是[删除Bug]
case ChangeType.Delete:
//并且正在显示这个Bug的话
if (AppManager.Uis.BugUi.UiControl.Visibility == Visibility.Visible &&
AppManager.Datas.OtherData.ShowBugItemData != null &&
AppManager.Datas.OtherData.ShowBugItemData.Data.Id == _bugId &&
_bugId > -1)
{
//关闭修改Bug的界面
if (AppManager.Uis.ChangeBugUi.UiControl.Visibility == Visibility.Visible)
{
AppManager.Uis.ChangeBugUi.OpenOrClose(false);
}
//关闭Bug的界面
AppManager.Uis.BugUi.OpenOrClose(false);
//如果MainUi没有打开
if (AppManager.Uis.MainUi.UiControl.Visibility == Visibility.Collapsed)
{
//就打开ListUi
AppManager.Uis.ListUi.OpenOrClose(true);
}
}
break;
//如果是[修改Bug]
case ChangeType.Change:
//显示BugItem的GoToPage按钮
int _pageNumber = AppManager.Systems.PageSytem.GetPageNumber(_bugData); //获取到Bug的新页码
_bugData.ItemData.GoToPageNumber = _pageNumber; //显示跳转的页码
break;
}
}
}
}
/*更新Ui：Record*/
if (_recordLogs.Count > 0)
{
/*更新Ui*/
foreach (long _recordId in _recordChangeTypes.Keys)
{
//获取Record数据
RecordData _recordData = AppManager.Systems.RecordSystem.GetRecordData(_recordId);
//获取Bug数据
BugData _bugData = AppManager.Systems.BugSystem.GetBugData(_recordData);
//如果Bug是正在显示的Bug，那么就刷新BugUi的记录
if (AppManager.Datas.OtherData.ShowBugItemData != null &&
_bugData != null &&
AppManager.Datas.OtherData.ShowBugItemData.Data.Id == _bugData.Id)
{
//刷新记录
AppManager.Systems.RecordSystem.SetShowRecords(_bugData, AppManager.Datas.OtherData.IsShowBugReply);
}
}
}
/*日志*/
if (_bugLogs.Count > 0 || _recordLogs.Count > 0)
{
//这次的日志
string _syncLogText = "";
//时间
_syncLogText += "【" + DateTimeTool.DateTimeToString(DateTime.Now, TimeFormatType.YearMonthDayHourMinuteSecond) + "】";
//Bug的日志
for (int i = 0; i < _bugLogs.Count; i++)
{
_syncLogText += "\n" + " " + "(" + (i + 1) + ") " + _bugLogs[i];
}
//Record的日志
for (int i = 0; i < _recordLogs.Count; i++)
{
_syncLogText += "\n" + " " + "(" + (i + 1) + ") " + _recordLogs[i];
}
//提行
_syncLogText += "\n\n\n";
//刷新Ui
SyncLogText = _syncLogText + SyncLogText;
}
/*时间和次数*/
if (_bugLogs.Count > 0 || _recordLogs.Count > 0)
{
SyncNumber += 1;
LastSyncDateTime = DateTime.UtcNow;
}
/* 返回值 */
if (_bugLogs.Count > 0 || _recordLogs.Count > 0)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// 同步[Record]
/// （当有[Record]文件更改时，2秒后，把已经修改的文件，进行同步）
/// </summary>
/// <param name="_syncRecordIds">需要同步的所有Record编号</param>
/// <param name="_changeTypes">改变的类型（key：Record的编号；value：改变的类型）</param>
/// <param name="_logs">同步的日志</param>
private void SyncRecord(List <long> _syncRecordIds, out Dictionary <long, ChangeType> _changeTypes, out List <string> _logs)
{
//out
_logs = new List <string>(); //所有的日志
_changeTypes = new Dictionary <long, ChangeType>(); //改变的类型
//遍历所有需要同步的Record
for (int i = 0; i < _syncRecordIds.Count; i++)
{
//Record的编号
long _recordId = _syncRecordIds[i];
/* 取到当前的数据 */
//取到当前Record的数据
RecordData _oldRecordData = RecordData.Copy(AppManager.Systems.RecordSystem.GetRecordData(_recordId));
/* 读取Record数据 */
//Record文件的路径（文件夹+文件名+后缀）
string _recordFilePath = AppManager.Systems.ProjectSystem.RecordFolderPath + "/Record - " + _recordId + AppManager.Systems.ProjectSystem.OtherFileSuffix;
string _recordJsonText;
RecordBaseData _recordBaseData = null;
RecordData _newRecordData = null;
try
{
//读取[Record]的Json文本中的内容
_recordJsonText = File.ReadAllText(_recordFilePath);
//然后把Json文本解析成RecordBaseData对象
_recordBaseData = JsonMapper.ToObject <RecordBaseData>(_recordJsonText);
//把RecordBaseData对象，转化为RecordData对象（取到新的Record数据）
_newRecordData = RecordBaseData.BaseDataToData(_recordBaseData);
}
catch (Exception e)
{
}
/* 对比2个Record的修改 */
//如果是添加一个Record，或者是修改一个Record，或者是IsDelete为true的删除Record
if ((_oldRecordData != null && _newRecordData != null) ||
(_oldRecordData == null && _newRecordData != null))
{
//如果新的Record是完整的
if (RecordData.VerifyIntegrity(_newRecordData))
{
//如果旧的Record和新的Record有区别
if (RecordData.Compare(CompareType.All, _oldRecordData, _newRecordData) == false)
{
//读取这个Record文件
AppManager.Systems.RecordSystem.LoadRecord(ModeType, _recordId);
//获取Record的更改
ChangeType _changeType = CompareOldRecordAndNewRecord(_oldRecordData, _newRecordData);
//获取Log
string _log = GenerateRecordSyncLogText(_oldRecordData, _newRecordData, _changeType);
//把改变的类型加入到字典中
_changeTypes.Add(_recordId, _changeType);
//把_log加入到_logs中
if (_log != null && _log != "")
{
_logs.Add(_log);
}
}
}
}
//如果是直接删除文件的删除Record
else if (_oldRecordData != null && _newRecordData == null)
{
//判断Record文件是否存在
FileInfo _recordFileInfo = new FileInfo(_recordFilePath);
//如果Record文件已被删除
if (_recordFileInfo.Exists == false)
{
//标记为已删除
AppManager.Systems.RecordSystem.GetRecordData(_recordId).IsDelete = true;
//获取Record的更改
ChangeType _changeType = CompareOldRecordAndNewRecord(_oldRecordData, _newRecordData);
//获取Log
string _log = GenerateRecordSyncLogText(_oldRecordData, _newRecordData, _changeType);
//把改变的类型加入到字典中
_changeTypes.Add(_recordId, _changeType);
//把_log加入到_logs中
if (_log != null && _log != "")
{
_logs.Add(_log);
}
}
}
}
}
