public void ChangeManager(DBItemType type)
{
//App.Entities.SaveChanges();
switch (type)
{
case DBItemType.Macro:
CurrentType = DBItemType.Macro;
ManagedList = new ObservableCollection <DBItem>(ListMacros);
break;
case DBItemType.Meta:
CurrentType = DBItemType.Meta;
ManagedList = new ObservableCollection <DBItem>(ListMetas);
break;
case DBItemType.Environment:
CurrentType = DBItemType.Environment;
ManagedList = new ObservableCollection <DBItem>(ListEnvironments);
break;
case DBItemType.Template:
default:
CurrentType = DBItemType.Template;
ManagedList = new ObservableCollection <DBItem>(ListTemplates);
break;
}
ManagedItem = null;
FirePropertyChanged("HasManagedList");
}
public VMDependencyManagment(DBItemType type_available, Meta current)
{
ManagedMeta = current;
ManagedItemType = DBItemType.Meta;
ListDependencies = Linq.DependenciesList(current, type_available);
Init(type_available);
}
private void Init(DBItemType type)
{
ListAvailables = VMHelper.SetListFromType(type);
DependencyType = type;
CommandeAjouter = new RelayCommand(btn_Ajouter);
CommandeRetirer = new RelayCommand(btn_Retirer);
}
// Constructors
public VMDependencyManagment(DBItemType type_available, Template t)
{
ManagedTemplate = t;
ManagedItemType = DBItemType.Template;
ListDependencies = Linq.DependenciesList(t, type_available);
Init(type_available);
}
public VMDependencyManagment(DBItemType type_available, LTG_Entity.Environment current)
{
ManagedEnvironment = current;
ManagedItemType = DBItemType.Environment;
ListDependencies = Linq.DependenciesList(current, type_available);
Init(type_available);
}
public static void CanSetItemTypeTest(DBItemType type, bool isError, bool answer)
{
var instance = new DBItemSettingDescDatabase();
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
bool result = false;
var errorOccured = false;
try
{
result = instance.CanSetItemType(type);
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
if (errorOccured)
{
return;
}
// 結果が意図した値と一致すること
Assert.AreEqual(result, answer);
// プロパティ変更通知が発火していないこと
Assert.AreEqual(changedPropertyList.Count, 0);
}
public void SetManager(DBItemType type)
{
TargetGrid.Children.Clear();
((VMManages)DataContext).ChangeManager(type);
switch (type)
{
case DBItemType.Macro:
_ucMacros = new UCMacros();
TargetGrid.Children.Add(_ucMacros);
break;
case DBItemType.Meta:
_ucMeta = new UCMeta();
TargetGrid.Children.Add(_ucMeta);
break;
case DBItemType.Environment:
_ucEnv = new UCEnvironments();
TargetGrid.Children.Add(_ucEnv);
break;
case DBItemType.Template:
default:
_ucTemplates = new UCTemplates();
TargetGrid.Children.Add(_ucTemplates);
break;
}
// Send change to manager
}
public static ObservableCollection <DBItem> SetListFromType(DBItemType type)
{
// Return the list of Objects in DB according to DBItemType
ObservableCollection <DBItem> Liste = null;
switch (type)
{
case DBItemType.Template:
Liste = new ObservableCollection <DBItem>(App.Entities.Templates);
break;
case DBItemType.Macro:
Liste = new ObservableCollection <DBItem>(App.Entities.Macroes);
break;
case DBItemType.Package:
Liste = new ObservableCollection <DBItem>(App.Entities.Packages);
break;
case DBItemType.Meta:
Liste = new ObservableCollection <DBItem>(App.Entities.Metas);
break;
case DBItemType.Environment:
Liste = new ObservableCollection <DBItem>(App.Entities.Environments);
break;
default:
break;
}
return(Liste);
}
/// <summary>
/// 設定種別 & 種別順列
/// </summary>
/// <param name="readStatus">読み込み経過状態</param>
/// <param name="itemTypes">取得した項目種別リスト格納先</param>
private void ReadValueType(BinaryReadStatus readStatus, out List <DBItemType> itemTypes)
{
var length = readStatus.ReadInt();
readStatus.IncreaseIntOffset();
var countDic = new Dictionary <DBItemType, int>
{
{ DBItemType.Int, 0 },
{ DBItemType.String, 0 }
};
itemTypes = new List <DBItemType>();
for (var i = 0; i < length; i++)
{
var settingCode = readStatus.ReadInt();
readStatus.IncreaseIntOffset();
var itemType = DBItemType.FromValue(settingCode);
// 項目タイプ数集計
countDic[itemType]++;
// 種別順位は無視する
itemTypes.Add(itemType);
}
}
static public ObservableCollection <DBItem> DependenciesList(Macro m, DBItemType type)
{
ObservableCollection <DBItem> list = new ObservableCollection <DBItem>();
foreach (Package p in m.Packages)
{
list.Add(p);
}
return(list);
}
public static void ItemTypeTest(DBItemSpecialSettingType settingType, DBItemType type, bool isSetError)
{
var specialDesc = new DBItemSpecialSettingDesc();
specialDesc.ChangeValueType(settingType, null);
var instance = new DBItemSetting
{
SpecialSettingDesc = specialDesc
};
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var errorOccured = false;
try
{
instance.ItemType = type;
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isSetError);
errorOccured = false;
try
{
var _ = instance.SpecialSettingDesc;
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーが発生しないこと
Assert.IsFalse(errorOccured);
// 意図したとおりプロパティ変更通知が発火していること
if (isSetError)
{
Assert.AreEqual(changedPropertyList.Count, 0);
}
else
{
Assert.AreEqual(changedPropertyList.Count, 1);
Assert.IsTrue(changedPropertyList[0].Equals(nameof(DBItemSetting.ItemType)));
}
}
private static DBItemValue MakeInstance(DBItemType type)
{
if (type == DBItemType.Int)
{
return(new DBItemValue(0));
}
if (type == DBItemType.String)
{
return(new DBItemValue(""));
}
throw new ArgumentException();
}
public static void StringValueTest(DBItemType type, bool isError)
{
var instance = MakeInstance(type);
var errorOccured = false;
try
{
var _ = instance.StringValue;
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
}
public static void ValueTest(DBItemType itemType, bool isError)
{
var instance = new DatabaseItemDesc();
var changedPropertyList = new List <string>();
instance.PropertyChanged += (sender, args) => { changedPropertyList.Add(args.PropertyName); };
var errorOccured = false;
try
{
instance.ItemType = itemType;
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーフラグが一致すること
Assert.AreEqual(errorOccured, isError);
if (!errorOccured)
{
var setValue = instance.ItemType;
// セットした値と取得した値が一致すること
Assert.IsTrue(setValue.Equals(itemType));
}
// 意図したとおりプロパティ変更通知が発火していること
if (errorOccured)
{
Assert.AreEqual(changedPropertyList.Count, 0);
}
else
{
Assert.AreEqual(changedPropertyList.Count, 1);
Assert.IsTrue(changedPropertyList[0].Equals(nameof(DatabaseItemDesc.ItemType)));
}
}
static public ObservableCollection <DBItem> DependenciesList(Meta m, DBItemType type)
{
ObservableCollection <DBItem> list = new ObservableCollection <DBItem>();
switch (type)
{
case DBItemType.Macro:
foreach (Macro ma in m.Macroes)
{
list.Add(ma);
}
break;
case DBItemType.Package:
foreach (Package p in m.Packages)
{
list.Add(p);
}
break;
case DBItemType.Meta:
foreach (Meta m2 in m.Metas)
{
list.Add(m2);
}
break;
case DBItemType.Environment:
foreach (LTG_Entity.Environment e in m.Environments)
{
list.Add(e);
}
break;
default:
break;
}
return(list);
}
static public ObservableCollection <DBItem> DependenciesList(Template t, DBItemType type)
{
ObservableCollection <DBItem> list = new ObservableCollection <DBItem>();
switch (type)
{
case DBItemType.Macro:
foreach (TemplateMacro tm in t.TemplateMacroes)
{
list.Add(tm.Macro);
}
break;
case DBItemType.Package:
foreach (TemplatePackage tp in t.TemplatePackages)
{
list.Add(tp.Package);
}
break;
case DBItemType.Meta:
foreach (TemplateMeta tm in t.TemplateMetas)
{
list.Add(tm.Meta);
}
break;
case DBItemType.Environment:
foreach (TemplateEnvironment te in t.TemplateEnvironments)
{
list.Add(te.Environment);
}
break;
default:
break;
}
return(list);
}
/// <summary>
/// 設定種別 & 種別順列
/// </summary>
/// <param name="status">読み込み経過状態</param>
/// <param name="itemTypes">取得した項目種別リスト格納先</param>
private void ReadValueType(FileReadStatus status, out List <DBItemType> itemTypes)
{
var length = status.ReadInt();
status.IncreaseIntOffset();
Logger.Debug(FileIOMessage.SuccessRead(typeof(DBDataSettingReader),
"項目数", length));
var countDic = new Dictionary <DBItemType, int>
{
{ DBItemType.Int, 0 },
{ DBItemType.String, 0 }
};
itemTypes = new List <DBItemType>();
for (var i = 0; i < length; i++)
{
var settingCode = status.ReadInt();
status.IncreaseIntOffset();
var itemType = DBItemType.FromValue(settingCode);
Logger.Debug(FileIOMessage.SuccessRead(typeof(DBDataSettingReader),
$" 項目{i,2}設定種別", itemType));
// 項目タイプ数集計
countDic[itemType]++;
// 種別順位は無視する
itemTypes.Add(itemType);
}
Logger.Debug(FileIOMessage.EndCommonRead(
typeof(DBDataSettingReader), "項目設定種別"));
}
private IDictionary <string, DBItemType> GetDBItemTypes()
{
string query = "SELECT * FROM ItemType";
IDictionary <string, DBItemType> itemTypes = new Dictionary <string, DBItemType>();
if (connection.State == System.Data.ConnectionState.Open)
{
SqlCommand cmd = new SqlCommand(query, connection);
SqlDataReader dataReader = cmd.ExecuteReader();
while (dataReader.Read())
{
int id = dataReader.GetInt32(0);
string name = dataReader.GetString(1);
DBItemType it = new DBItemType(id, name);
itemTypes.Add(name, it);
}
dataReader.Close();
}
return(itemTypes);
}
public static void TypeTest(DBItemType type)
{
var instance = MakeInstance(type);
DBItemType resultType = null;
var errorOccured = false;
try
{
resultType = instance.Type;
}
catch (Exception ex)
{
logger.Exception(ex);
errorOccured = true;
}
// エラーが発生しないこと
Assert.IsFalse(errorOccured);
// 項目種別が正しく取得できること
Assert.AreEqual(resultType, type);
}
static public ObservableCollection <DBItem> DependenciesList(LTG_Entity.Environment e, DBItemType type)
{
ObservableCollection <DBItem> list = new ObservableCollection <DBItem>();
foreach (Package p in e.Packages)
{
list.Add(p);
}
return(list);
}
