/// <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);
            }
        }
示例#2
0
        /// <summary>
        /// 保存所有记录
        /// </summary>
        /// <param name="_modeType">项目模式的类型</param>
        public void SaveRecords(ModeType _modeType)
        {
            /* 保存 */
            try
            {
                //获取所有的Record
                ObservableCollection <RecordData> _recordDatas = RecordDatas;

                //判断项目的模式
                switch (_modeType)
                {
                //如果项目是[默认模式]:把所有的Record,保存到/Record/Records.json文件中
                case ModeType.Default:
                    //把RecordData转换为RecordBaseData
                    List <RecordBaseData> _recordBaseDatas = new List <RecordBaseData>();
                    for (int i = 0; i < _recordDatas.Count; i++)
                    {
                        RecordBaseData _recordBaseData = RecordBaseData.DataToBaseData(_recordDatas[i]);
                        if (_recordBaseData != null)
                        {
                            _recordBaseDatas.Add(_recordBaseData);
                        }
                    }

                    //把RecordBaseData转换为json
                    string _recordsJsonText = JsonMapper.ToJson(_recordBaseDatas);

                    //Record文件的路径(文件夹+文件名+后缀)
                    string _recordsFilePath = RecordFolderPath + "/Records" + AppManager.Systems.ProjectSystem.OtherFileSuffix;

                    //把json文件保存到[Records.json]文件里
                    File.WriteAllText(_recordsFilePath, _recordsJsonText, Encoding.Default);
                    break;



                //如果项目是[协同合作模式]:把每一个Record,分别保存到/Record/Record - 20200119080230555.json文件中
                case ModeType.Collaboration:
                    for (int i = 0; i < _recordDatas.Count; i++)
                    {
                        SaveRecord(ModeType.Collaboration, _recordDatas[i].Id);
                    }
                    break;
                }
            }

            /* 如果有错误,就输出错误 */
            catch (Exception e)
            {
                //输出错误
                AppManager.Uis.ErrorUi.UiControl.TipContent = e.ToString();
                AppManager.Uis.ErrorUi.OpenOrClose(true);
            }
        }
示例#3
0
        /// <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>
        /// 把[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);
            }
        }
示例#5
0
        /// <summary>
        /// 备份[Record]
        ///(备份[Record/Records.json]文件)
        /// </summary>
        public void BackupRecord()
        {
            /* 格式:Backup/Record/年月日时分秒.json */
            try
            {
                /*创建[Backup/Record]文件夹(_projectFolderPath/Backup/Record/)*/
                DirectoryInfo _recordBackupDirectoryInfo = new DirectoryInfo(RecordBackupFolderPath);
                //如果没有文件夹,就创建文件夹
                if (_recordBackupDirectoryInfo.Exists == false)
                {
                    _recordBackupDirectoryInfo.Create();
                }

                /*获取【Record】文件的个数(如果文件超过10个,就删除最早创建的那个文件)*/
                FileInfo[] _recordBackupFileInfos = _recordBackupDirectoryInfo.GetFiles();
                if (_recordBackupFileInfos != null && _recordBackupFileInfos.Length > 10)
                {
                    //找到Record备份文件中,最早创建的那个文件
                    FileInfo _firstFileInfo = FindFirstBackupFile(_recordBackupFileInfos);

                    //删除最早的1个文件
                    if (_firstFileInfo != null)
                    {
                        File.Delete(_firstFileInfo.FullName);
                    }
                }



                /* 获取要备份的文件的路径 */
                //当前的时间(年月日时分秒)
                string _nowDateTimeString = DateTimeTool.DateTimeToString(DateTime.UtcNow, TimeFormatType.YearMonthDayHourMinuteSecondMillisecond);

                //文件的备份路径
                string _recordFilePath = RecordBackupFolderPath + "/"
                                         + _nowDateTimeString + AppManager.Systems.ProjectSystem.OtherFileSuffix;



                /* 进行备份 */
                //取到所有的Record数据
                ObservableCollection <RecordData> _recordDatas = AppManager.Systems.RecordSystem.RecordDatas;

                //把RecordData转换为RecordBaseData
                List <RecordBaseData> _recordBaseDatas = new List <RecordBaseData>();
                for (int i = 0; i < _recordDatas.Count; i++)
                {
                    RecordBaseData _recordBaseData = RecordBaseData.DataToBaseData(_recordDatas[i]);
                    if (_recordBaseData != null)
                    {
                        _recordBaseDatas.Add(_recordBaseData);
                    }
                }

                //把RecordBaseData转换为json
                string _recordsJsonText = JsonMapper.ToJson(_recordBaseDatas);

                //把json文件保存到[Records.json]文件里
                File.WriteAllText(_recordFilePath, _recordsJsonText, Encoding.Default);
            }
            catch (Exception e)
            {
            }
        }
示例#6
0
        /// <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);
            }
        }
示例#7
0
        /// <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);
            }
        }
示例#8
0
        /// <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);
                        }
                    }
                }
            }
        }