public void SynonymWordEntitiesHaveAGroupId()
        {
            var entity = new SynonymWordEntity();

            entity.GroupId = 1;
            entity.GroupId.Should().Be(1);
        }
        public void SynonymWordEntitiesHaveACreatedAt()
        {
            var entity = new SynonymWordEntity();
            var date   = new DateTime(2019, 02, 21);

            entity.CreatedAt = date;
            entity.CreatedAt.Should().BeSameDateAs(date);
        }
        public void SynonymWordEntitiesHaveAWord()
        {
            var entity = new SynonymWordEntity();
            var word   = "Test";

            entity.Word = word;
            entity.Word.Should().BeSameAs(word);
        }
 private static SynonymWord CreateSynonymWordFrom(SynonymWordEntity synonymWordEntity)
 {
     // TODO: Reuse domain factory classes when created.
     return(new SynonymWord
     {
         Id = synonymWordEntity.Id,
         GroupId = synonymWordEntity.GroupId,
         Word = synonymWordEntity.Word,
         CreatedAt = synonymWordEntity.CreatedAt
     });
 }
        /// <summary>類語一覧リスト選択時実行コマンド</summary>
        /// <param name="parameter"></param>
        private void ExecuteSelectSynonymWord(object parameter)
        {
            if (parameter == null)
            {
                Logger.Error(CLASS_NAME, "ExecuteSelectSynonymWord", "parameter is null!");
                return;
            }

            SynonymWordEntity selectedWord = ConvertParameterToSynonymWordEntity(parameter);

            if (selectedWord == null)
            {
                Logger.Error(CLASS_NAME, "ExecuteSelectSynonymWord", "selectedWord is null!");
                return;
            }

            SelectedWord = selectedWord;
        }
        /// <summary>類語編集コマンド</summary>
        /// <param name="parameter">RoutedEventArgs:類語リストでのテキストボックス入力値</param>
        private void ExecuteEditSynonymWord(object parameter)
        {
            SynonymWordEntity targetEntity = (SynonymWordEntity)parameter;

            if (targetEntity == null)
            {
                Logger.Error(CLASS_NAME, "ExecuteEditSynonymWord", "targetEntity is null!");
                return;
            }

            if (_model == null)
            {
                Logger.Fatal(CLASS_NAME, "ExecuteEditSynonymWord", "_model is null!");
                return;
            }

            _model.UpdateSynonymWord(targetEntity.WordID, targetEntity.Word);

            // 所属する類語グループの更新日を更新する
            _model.UpdateSynonymGroup(targetEntity.GroupID);

            // 画面表示の更新 ここで実行してしまうと、類語グループをクリックしたときに1クリックで遷移できなくなる(OnPropertyChangedで画面側の更新が走るため)
            // UpdateDisplayGroupsAndWords(targetEntity.GroupID);
        }
예제 #7
0
        /// <summary>クエリによりSynonymWordsEntityを取得する</summary>
        /// <param name="sql"></param>
        /// <param name="synonymWords"></param>
        /// <returns></returns>
        internal bool GetTargetSynonymWords(string sql, out SynonymWordEntity[] synonymWords)
        {
            Logger.Info(CLASS_NAME, "GetTargetSynonymWrods", $"start, SQL[{sql}]");

            synonymWords = null;

            if (string.IsNullOrEmpty(sql))
            {
                Logger.Fatal(CLASS_NAME, "GetTargetSynonymWrods", "sql is null or empty!");
                return(false);
            }

            using (SQLiteDataReader reader = ExecuteQuery(sql))
            {
                if (reader == null)
                {
                    // 実行結果が必ずあるはずなのに、何もないのは異常だろう
                    Logger.Error(CLASS_NAME, "GetTargetSynonymWrods", "reader result is null");
                    return(false);
                }

                List <SynonymWordEntity> synonymWordList = new List <SynonymWordEntity>();
                try
                {
                    // SQLの実行結果をここで格納する
                    while (reader.Read())
                    {
                        // SQLiteのInteger型はInt64->C#ではlong型に値する
                        // 現状、上限値をintの最大値としてID付加時に処理するため、int型に無条件でキャストしてよい
                        int  wordID         = -1;
                        long?nullableWordID = reader["WordID"] as long?;
                        if (nullableWordID != null)
                        {
                            wordID = (int)nullableWordID;
                        }

                        int  groupID         = -1;
                        long?nullableGroupID = reader["GroupID"] as long?;
                        if (nullableGroupID != null)
                        {
                            groupID = (int)nullableGroupID;
                        }

                        string word           = reader["Word"] as string;
                        string wordRegistDate = reader["RegistDate"] as string;
                        string wordUpdateDate = reader["UpdateDate"] as string;

                        SynonymWordEntity synonymWordEntity = new SynonymWordEntity
                        {
                            WordID     = wordID,
                            GroupID    = groupID,
                            Word       = word,
                            RegistDate = wordRegistDate,
                            UpdateDate = wordUpdateDate
                        };
                        synonymWordList.Add(synonymWordEntity);
                    }

                    if (synonymWordList != null)
                    {
                        synonymWords = synonymWordList.ToArray();
                    }

                    return(true);
                }
                catch (Exception e)
                {
                    Logger.Fatal(CLASS_NAME, "GetTargetSynonymWords", e.ToString());
                    return(false);
                }
            }
        }
        public void SynonymWordEntitiesHaveAnId()
        {
            var entity = new SynonymWordEntity();

            entity.Id.Should().BeGreaterOrEqualTo(0);
        }