/// <summary>
        /// 把[BaseData对象]转换为[Data对象]
        /// </summary>
        /// <param name="_baseData">要转换的BaseData对象</param>
        /// <returns>转换后的Data对象</returns>
        public static BugData BaseDataToData(BugBaseData _baseData)
        {
            if (_baseData != null)
            {
                BugData _data = new BugData();

                _data.Id   = _baseData.Id;
                _data.Name = new HighlightText()
                {
                    Text = _baseData.Name, Highlight = ""
                };
                _data.Progress      = (ProgressType)_baseData.Progress;
                _data.Priority      = (PriorityType)_baseData.Priority;
                _data.CreateTime    = new DateTime(_baseData.CreateTime[0], _baseData.CreateTime[1], _baseData.CreateTime[2], _baseData.CreateTime[3], _baseData.CreateTime[4], _baseData.CreateTime[5]);
                _data.SolveTime     = new DateTime(_baseData.SolveTime[0], _baseData.SolveTime[1], _baseData.SolveTime[2], _baseData.SolveTime[3], _baseData.SolveTime[4], _baseData.SolveTime[5]);
                _data.UpdateTime    = new DateTime(_baseData.UpdateTime[0], _baseData.UpdateTime[1], _baseData.UpdateTime[2], _baseData.UpdateTime[3], _baseData.UpdateTime[4], _baseData.UpdateTime[5]);
                _data.UpdateNumber  = _baseData.UpdateNumber;
                _data.TemperamentId = _baseData.TemperamentId;
                _data.IsDelete      = _baseData.IsDelete;

                return(_data);
            }
            else
            {
                return(null);
            }
        }
        /// <summary>
        /// 把[Data对象]转换为[BaseData对象]
        /// </summary>
        /// <param name="_data">要转换的Data对象</param>
        /// <returns>转换后的BaseData对象</returns>
        public static BugBaseData DataToBaseData(BugData _data)
        {
            if (_data != null)
            {
                BugBaseData _baseData = new BugBaseData();

                _baseData.Id         = _data.Id;
                _baseData.Name       = _data.Name.Text;
                _baseData.Progress   = (int)_data.Progress;
                _baseData.Priority   = (int)_data.Priority;
                _baseData.CreateTime = new List <int>()
                {
                    _data.CreateTime.Year, _data.CreateTime.Month, _data.CreateTime.Day, _data.CreateTime.Hour, _data.CreateTime.Minute, _data.CreateTime.Second
                };
                _baseData.SolveTime = new List <int>()
                {
                    _data.SolveTime.Year, _data.SolveTime.Month, _data.SolveTime.Day, _data.SolveTime.Hour, _data.SolveTime.Minute, _data.SolveTime.Second
                };
                _baseData.UpdateTime = new List <int>()
                {
                    _data.UpdateTime.Year, _data.UpdateTime.Month, _data.UpdateTime.Day, _data.UpdateTime.Hour, _data.UpdateTime.Minute, _data.UpdateTime.Second
                };
                _baseData.UpdateNumber  = _data.UpdateNumber;
                _baseData.TemperamentId = _data.TemperamentId;
                _baseData.IsDelete      = _data.IsDelete;

                return(_baseData);
            }
            else
            {
                return(null);
            }
        }
Esempio n. 3
0
        /// <summary>
        /// 保存所有的Bug
        /// </summary>
        /// <param name="_modeType">项目模式的类型</param>
        public void SaveBugs(ModeType _modeType)
        {
            /* 保存 */
            try
            {
                //获取所有的Bug
                ObservableCollection <BugData> _bugDatas = BugDatas;

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

                    //把BugBaseData转换为json
                    string _bugsJsonText = JsonMapper.ToJson(_bugBaseDatas);

                    //Bug文件的路径(文件夹+文件名+后缀)
                    string _bugsFilePath = BugFolderPath + "/Bugs" + AppManager.Systems.ProjectSystem.OtherFileSuffix;

                    //把json文件保存到[Bugs.json]文件里
                    File.WriteAllText(_bugsFilePath, _bugsJsonText, Encoding.Default);
                    break;



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

            /* 如果有错误,就输出错误 */
            catch (Exception e)
            {
                //输出错误
                AppManager.Uis.ErrorUi.UiControl.TipContent = e.ToString();
                AppManager.Uis.ErrorUi.OpenOrClose(true);
            }
        }
Esempio n. 4
0
        /// <summary>
        /// 保存一个Bug
        /// </summary>
        /// <param name="_modeType">项目模式的类型</param>
        /// <param name="_bugId">要保存的Bug的编号</param>
        public void SaveBug(ModeType _modeType, long _bugId)
        {
            /* 保存 */
            try
            {
                //判断项目的模式
                switch (_modeType)
                {
                //如果项目是[默认模式]:把所有的Bug,保存到/Bug/Bugs.json文件中
                case ModeType.Default:
                    SaveBugs(ModeType.Default);
                    break;



                //如果项目是[协同合作模式]:把每一个Bug,分别保存到/Bug/Bug - 20200119080230555.json文件中
                case ModeType.Collaboration:
                    //通过Id取到Bug
                    BugData _bugData = GetBugData(_bugId);

                    if (_bugData != null)
                    {
                        //把BugData转换为BugBaseData
                        BugBaseData _bugBaseData = BugBaseData.DataToBaseData(_bugData);

                        //把BugBaseData转换为json
                        string _bugJsonText = JsonMapper.ToJson(_bugBaseData);

                        //Bug文件的路径(文件夹+文件名+后缀)
                        string _bugFilePath = BugFolderPath + "/Bug - " + _bugBaseData.Id + AppManager.Systems.ProjectSystem.OtherFileSuffix;

                        //把json文件保存到[Bug - BugId.json]文件里
                        File.WriteAllText(_bugFilePath, _bugJsonText, Encoding.Default);
                    }
                    break;
                }
            }

            /* 如果有错误,就输出错误 */
            catch (Exception e)
            {
                //输出错误
                AppManager.Uis.ErrorUi.UiControl.TipContent = e.ToString();
                AppManager.Uis.ErrorUi.OpenOrClose(true);
            }
        }
Esempio n. 5
0
        /// <summary>
        /// 备份[Bug]
        ///(备份[Bug/Bugs.json]文件)
        /// </summary>
        public void BackupBug()
        {
            /* 格式:Backup/Bug/年月日时分秒.json */

            try
            {
                /*创建[Backup/Bug]文件夹(_projectFolderPath/Backup/Bug/)*/
                DirectoryInfo _bugBackupDirectoryInfo = new DirectoryInfo(BugBackupFolderPath);
                //如果没有文件夹,就创建文件夹
                if (_bugBackupDirectoryInfo.Exists == false)
                {
                    _bugBackupDirectoryInfo.Create();
                }

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

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



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

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



                /* 进行备份 */
                //取到所有的Bug数据
                ObservableCollection <BugData> _bugDatas = AppManager.Systems.BugSystem.BugDatas;

                //把BugData转换为BugBaseData
                List <BugBaseData> _bugBaseDatas = new List <BugBaseData>();
                for (int i = 0; i < _bugDatas.Count; i++)
                {
                    BugBaseData _bugBaseData = BugBaseData.DataToBaseData(_bugDatas[i]);
                    if (_bugBaseData != null)
                    {
                        _bugBaseDatas.Add(_bugBaseData);
                    }
                }

                //把BugBaseData转换为json
                string _bugsJsonText = JsonMapper.ToJson(_bugBaseDatas);

                //把json文件保存到[Bugs.json]文件里
                File.WriteAllText(_bugFilePath, _bugsJsonText, Encoding.Default);
            }
            catch (Exception e)
            {
            }
        }
Esempio n. 6
0
        /// <summary>
        /// 读取一个Bug
        /// </summary>
        /// <param name="_modeType">项目模式的类型</param>
        /// <param name="_bugFilePath">要读取的Bug的编号</param>
        public void LoadBug(ModeType _modeType, long _bugId)
        {
            /* 读取 */
            try
            {
                //判断项目的模式
                switch (_modeType)
                {
                //如果项目是[默认模式]:所有的Bug,都在/Bug/Bugs.json文件中
                case ModeType.Default:
                    LoadBugs(ModeType.Default);
                    break;



                //如果项目是[协同合作模式]:每一个Bug,分别在/Bug/Bug - 20200119080230555.json文件中
                case ModeType.Collaboration:
                    //Bug文件的路径(文件夹+文件名+后缀)
                    string _bugFilePath = BugFolderPath + "/Bug - " + _bugId + AppManager.Systems.ProjectSystem.OtherFileSuffix;

                    //FileInfo类 用于读取文件信息
                    FileInfo _bugFileInfo = new FileInfo(_bugFilePath);

                    /* 判断文件是否存在 */
                    if (_bugFileInfo.Exists == true)    //如果存在
                    {
                        //读取[Bug]的Json文本中的内容
                        string _bugJsonText = File.ReadAllText(_bugFilePath);

                        //然后把Json文本解析成BugBaseData对象
                        BugBaseData _bugBaseData = null;
                        try
                        {
                            _bugBaseData = JsonMapper.ToObject <BugBaseData>(_bugJsonText);
                        }
                        catch (Exception e)
                        {
                        }

                        //把BugBaseData对象,转化为BugData对象
                        BugData _bugData = BugBaseData.BaseDataToData(_bugBaseData);

                        //如果BugData的完整度为true
                        if (BugData.VerifyIntegrity(_bugData) == true)
                        {
                            //把BugData对象赋值
                            BugData _oldBugData = GetBugData(_bugData.Id); //通过BugId获取到旧的Bug对象
                            if (_oldBugData != null)                       //如果有旧的Bug对象
                            {
                                //如果旧的Bug和新的Bug有不同的地方
                                if (BugData.Compare(CompareType.All, _bugData, _oldBugData) == false)
                                {
                                    //修改旧的Bug对象的值
                                    _oldBugData.Name.Text     = _bugData.Name.Text;
                                    _oldBugData.Progress      = _bugData.Progress;
                                    _oldBugData.Priority      = _bugData.Priority;
                                    _oldBugData.CreateTime    = _bugData.CreateTime;
                                    _oldBugData.SolveTime     = _bugData.SolveTime;
                                    _oldBugData.UpdateTime    = _bugData.UpdateTime;
                                    _oldBugData.UpdateNumber  = _bugData.UpdateNumber;
                                    _oldBugData.TemperamentId = _bugData.TemperamentId;
                                    _oldBugData.IsDelete      = _bugData.IsDelete;
                                }
                            }
                            else
                            {
                                BugDatas.Add(_bugData);    //把读取到的Bug对象,添加到列表中
                            }
                        }
                    }
                    break;
                }
            }

            /* 如果有错误,就输出错误 */
            catch (Exception e)
            {
                //输出错误
                AppManager.Uis.ErrorUi.UiControl.TipContent = e.ToString();
                AppManager.Uis.ErrorUi.OpenOrClose(true);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// 读取所有的Bug
        /// </summary>
        /// <param name="_modeType">项目模式的类型</param>
        public void LoadBugs(ModeType _modeType)
        {
            /* 读取 */
            try
            {
                //判断项目的模式
                switch (_modeType)
                {
                //如果项目是[默认模式]:所有的Bug,都在/Bug/Bugs.json文件中
                case ModeType.Default:
                    //Bug文件的路径(文件夹+文件名+后缀)
                    string _bugsFilePath = BugFolderPath + "/Bugs" + AppManager.Systems.ProjectSystem.OtherFileSuffix;

                    //FileInfo类 用于读取文件信息
                    FileInfo _fileInfo = new FileInfo(_bugsFilePath);

                    /* 判断文件是否存在 */
                    if (_fileInfo.Exists == true)    //如果存在
                    {
                        //读取[Bug]的Json文本中的内容
                        string _bugsJsonText = File.ReadAllText(_bugsFilePath);

                        //然后把Json文本解析成BugBaseData对象
                        List <BugBaseData> _bugBaseDatas = JsonMapper.ToObject <List <BugBaseData> >(_bugsJsonText);

                        //创建BugData对象的集合
                        ObservableCollection <BugData> _bugs = new ObservableCollection <BugData>();

                        //把BugBaseData对象,转化为BugData对象
                        if (_bugBaseDatas != null)
                        {
                            for (int i = 0; i < _bugBaseDatas.Count; i++)
                            {
                                BugData _bug = BugBaseData.BaseDataToData(_bugBaseDatas[i]);
                                if (_bug != null)
                                {
                                    _bugs.Add(_bug);
                                }
                            }
                        }

                        //把BugData对象赋值
                        BugDatas = _bugs;
                    }

                    break;



                //如果项目是[协同合作模式]:每一个Bug,分别在/Bug/Bug - 20200119080230555.json文件中
                case ModeType.Collaboration:
                    //取到Bug文件夹 的信息
                    DirectoryInfo _bugDirectoryInfo = new DirectoryInfo(BugFolderPath);

                    //如果文件夹存在
                    if (_bugDirectoryInfo.Exists == true)
                    {
                        //获取到Bug文件夹内所有的文件 的信息
                        FileInfo[] _bugFileInfos = _bugDirectoryInfo.GetFiles();

                        //遍历所有的Bug文件
                        for (int i = 0; i < _bugFileInfos.Length; i++)
                        {
                            //取到Bug文件的名字
                            string _bugFileName = Path.GetFileNameWithoutExtension(_bugFileInfos[i].FullName);

                            //把[Bug文件的名字]转换为[BugId]
                            _bugFileName = _bugFileName.Replace("Bug - ", "");
                            long _bugId     = -1;
                            bool _isParseOk = long.TryParse(_bugFileName, out _bugId);    //把string转换为long

                            //如果转换成功
                            if (_isParseOk == true)
                            {
                                //就读取这个Bug
                                LoadBug(ModeType.Collaboration, _bugId);
                            }
                        }
                    }

                    break;
                }
            }
            catch (Exception e)
            {
                //输出错误
                AppManager.Uis.ErrorUi.UiControl.TipContent = e.ToString();
                AppManager.Uis.ErrorUi.OpenOrClose(true);
            }
        }
Esempio n. 8
0
        /// <summary>
        /// 同步[Bug]
        /// (当有[Bug]文件更改时,2秒后,把已经修改的文件,进行同步)
        /// </summary>
        /// <param name="_syncBugIds">需要同步的所有Bug编号</param>
        /// <param name="_changeTypes">改变的类型(key:Bug的编号;value:改变的类型)</param>
        /// <param name="_logs">同步的日志</param>
        private void SyncBug(List <long> _syncBugIds, out Dictionary <long, ChangeType> _changeTypes, out List <string> _logs)
        {
            //out
            _logs        = new List <string>();                 //所有的日志
            _changeTypes = new Dictionary <long, ChangeType>(); //改变的类型



            //遍历所有需要同步的Bug
            for (int i = 0; i < _syncBugIds.Count; i++)
            {
                //Bug的编号
                long _bugId = _syncBugIds[i];



                /* 取到当前的数据 */
                //取到当前Bug的数据
                BugData _oldBugData = BugData.Copy(AppManager.Systems.BugSystem.GetBugData(_bugId));
                if (_oldBugData != null)
                {
                    _oldBugData.Name = _oldBugData.Name.Copy();
                }



                /* 读取Bug数据 */
                //Bug文件的路径(文件夹+文件名+后缀)
                string _bugFilePath = AppManager.Systems.ProjectSystem.BugFolderPath + "/Bug - " + _bugId + AppManager.Systems.ProjectSystem.OtherFileSuffix;

                string      _bugJsonText;
                BugBaseData _bugBaseData = null;
                BugData     _newBugData  = null;

                try
                {
                    //读取[Bug]的Json文本中的内容
                    _bugJsonText = File.ReadAllText(_bugFilePath);

                    //然后把Json文本解析成BugBaseData对象
                    _bugBaseData = JsonMapper.ToObject <BugBaseData>(_bugJsonText);

                    //把BugBaseData对象,转化为BugData对象(取到新的Bug数据)
                    _newBugData = BugBaseData.BaseDataToData(_bugBaseData);
                }
                catch (Exception e)
                {
                }


                /* 对比2个Bug的修改 */

                //如果是添加一个Bug,或者是修改一个Bug,或者是IsDelete为true的删除Bug
                if ((_oldBugData != null && _newBugData != null) ||
                    (_oldBugData == null && _newBugData != null))
                {
                    //如果新的Bug是完整的
                    if (BugData.VerifyIntegrity(_newBugData))
                    {
                        //如果旧的Bug和新的Bug有区别
                        if (BugData.Compare(CompareType.All, _oldBugData, _newBugData) == false)
                        {
                            //读取这个Bug文件
                            AppManager.Systems.BugSystem.LoadBug(ModeType, _bugId);



                            //获取Bug的更改
                            ChangeType _changeType = CompareOldBugAndNewBug(_oldBugData, _newBugData);

                            //获取Log
                            string _log = GenerateBugSyncLogText(_oldBugData, _newBugData, _changeType);



                            //把改变的类型加入到字典中
                            _changeTypes.Add(_bugId, _changeType);

                            //把_log加入到_logs中
                            if (_log != null && _log != "")
                            {
                                _logs.Add(_log);
                            }
                        }
                    }
                }


                //如果是直接删除文件的删除Bug
                else if (_oldBugData != null && _newBugData == null)
                {
                    //判断Bug文件是否存在
                    FileInfo _bugFileInfo = new FileInfo(_bugFilePath);

                    //如果Bug文件已被删除
                    if (_bugFileInfo.Exists == false)
                    {
                        //标记为已删除
                        AppManager.Systems.BugSystem.GetBugData(_bugId).IsDelete = true;



                        //获取Bug的更改
                        ChangeType _changeType = CompareOldBugAndNewBug(_oldBugData, _newBugData);

                        //获取Log
                        string _log = GenerateBugSyncLogText(_oldBugData, _newBugData, _changeType);



                        //把改变的类型加入到字典中
                        _changeTypes.Add(_bugId, _changeType);

                        //把_log加入到_logs中
                        if (_log != null && _log != "")
                        {
                            _logs.Add(_log);
                        }
                    }
                }
            }
        }