public Config GetConfig(string moduleName)
{
Logger.Log(LogLevel.Info, "Converting config of plugin {0}", moduleName);
try
{
var module = GetModuleFromManager(moduleName);
var serialization = CreateSerialization(module);
var config = GetConfig(module, false);
var configModel = new Config
{
Root = EntryConvert.EncodeObject(config, serialization)
};
return(configModel);
}
catch (Exception ex)
{
Logger.LogException(LogLevel.Warning, ex, "Failed to convert config of {0}", moduleName);
#if USE_WCF
var ctx = WebOperationContext.Current;
// ReSharper disable once PossibleNullReferenceException
ctx.OutgoingResponse.StatusCode = HttpStatusCode.InternalServerError;
#else
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
#endif
return(null);
}
}
public void AddItemToCollectionWhichIsArray()
{
//Arrange
var dummy = new DummyClassIList();
dummy.Number = 10;
dummy.Name = "Thomas";
dummy.SingleClass = null;
dummy.SubArray = new[] { new SubClass {
Foo = (float)1.2, Enum = DummyEnum.ValueB
} };
dummy.SubList = new List <SubClass> {
new SubClass {
Foo = (float)3.4, Enum = DummyEnum.ValueA
}
};
dummy.SubEnumerable = new List <SubClass> {
new SubClass {
Foo = (float)3.4, Enum = DummyEnum.ValueA
}
};
dummy.SubDictionary = new Dictionary <int, SubClass>();
dummy.SubIList = new int[] { 1, 2, 3, 7 };
var entry = EntryConvert.EncodeObject(dummy);
var x = entry.SubEntries.FirstOrDefault(e => e.Identifier == "SubIList");
x.SubEntries.Add(x.Prototypes.First());
//Act
EntryConvert.UpdateInstance(dummy, entry);
//Assert
Assert.AreEqual(dummy.SubIList.Count, 5);
}
public void ConvertFromModelAndBackToModel()
{
// Arrange
var dummyClass = CreateDummyServer();
var dummyClassClient = new EntryModelDummyClient();
// Act
var serverEntry = EntryConvert.EncodeObject(dummyClass, new DefaultSerialization {
FormatProvider = new CultureInfo("en-us")
});
var clientConverter = EntryToModelConverter.Create <EntryModelDummyClient>(new CultureInfo("en-us"));
clientConverter.FromModel(serverEntry, dummyClassClient);
// Assert
// Check server to client conversion
Assert.AreEqual(73, dummyClassClient.Value);
Assert.AreEqual(true, dummyClassClient.HasAnything);
Assert.AreEqual("0.5", dummyClassClient.Class.Value);
Assert.AreEqual("ValueB", dummyClassClient.Class.Enum);
Assert.AreEqual(2, dummyClassClient.Collection.Count());
Assert.AreEqual(2, dummyClassClient.Dictionary.Count <EntryModelSubClassDummyClient>());
Assert.AreEqual("15.8", dummyClassClient.Dictionary["1"].Value);
Assert.AreEqual("Unset", dummyClassClient.Dictionary["1"].Enum);
Assert.AreEqual("435.2", dummyClassClient.Dictionary["2"].Value);
Assert.AreEqual("ValueA", dummyClassClient.Dictionary["2"].Enum);
// Arrange
dummyClassClient.Value = 174;
dummyClassClient.HasAnything = false;
dummyClassClient.Class.Value = "15.8";
dummyClassClient.Class.Enum = "ValueA";
dummyClassClient.Collection.Remove(dummyClassClient.Collection.First());
dummyClassClient.Collection.First().Value = "90";
dummyClassClient.Collection.First().Enum = "ValueA";
dummyClassClient.Dictionary["1"].Value = "10076";
dummyClassClient.Dictionary["1"].Enum = "ValueB";
dummyClassClient.Dictionary.Remove("2");
// Act
clientConverter.ToModel(dummyClassClient, serverEntry);
EntryConvert.UpdateInstance(dummyClass, serverEntry, new DefaultSerialization {
FormatProvider = new CultureInfo("en-us")
});
// Assert
// Check client to server conversion
Assert.AreEqual(174, dummyClass.Value);
Assert.AreEqual(false, dummyClass.HasAnything);
Assert.AreEqual(15.8f, dummyClass.Class.Value);
Assert.AreEqual(DummyEnum.ValueA, dummyClass.Class.Enum);
Assert.AreEqual(1, dummyClass.Collection.Count);
Assert.AreEqual(90f, dummyClass.Collection.First().Value);
Assert.AreEqual(DummyEnum.ValueA, dummyClass.Collection.First().Enum);
Assert.AreEqual(1, dummyClass.Dictionary.Count);
Assert.AreEqual(10076f, dummyClass.Dictionary[1].Value);
Assert.AreEqual(DummyEnum.ValueB, dummyClass.Dictionary[1].Enum);
}
public void RemoveItemFromEntryDictionary()
{
// Arrange
var dummyClass = CreateDummyServer();
var dummyClient = CreateDummyClient();
// Act
var serverEntry = EntryConvert.EncodeObject(dummyClass, new DefaultSerialization {
FormatProvider = new CultureInfo("en-us")
});
dummyClient.Dictionary.Remove("2");
var clientConverter = EntryToModelConverter.Create <EntryModelDummyClient>(new CultureInfo("en-us"));
clientConverter.ToModel(dummyClient, serverEntry);
// Assert
Assert.AreEqual(1, dummyClient.Dictionary.Count());
Assert.AreEqual("4.6", dummyClient.Dictionary["1"].Value);
Assert.AreEqual("ValueA", dummyClient.Dictionary["1"].Enum);
Assert.AreEqual(1, serverEntry.SubEntries[5].SubEntries.Count);
Assert.AreEqual("4.6", serverEntry.SubEntries[5].SubEntries[0].SubEntries[0].Value.Current);
Assert.AreEqual("ValueA", serverEntry.SubEntries[5].SubEntries[0].SubEntries[1].Value.Current);
}
public void AddItemToEntryCollection()
{
// Arrange
var dummyClass = CreateDummyServer();
var dummyClient = CreateDummyClient();
// Act
var serverEntry = EntryConvert.EncodeObject(dummyClass, new DefaultSerialization {
FormatProvider = new CultureInfo("en-us")
});
dummyClient.Collection.Add(typeof(EntryModelSubClassDummyClient).Name);
var clientConverter = EntryToModelConverter.Create <EntryModelDummyClient>(new CultureInfo("en-us"));
clientConverter.ToModel(dummyClient, serverEntry);
// Assert
Assert.AreEqual(3, dummyClient.Collection.Count());
Assert.IsNull(dummyClient.Collection.Last().Value);
Assert.IsNull(dummyClient.Collection.Last().Enum);
Assert.AreEqual(3, serverEntry.SubEntries[4].SubEntries.Count);
Assert.AreEqual(typeof(EntryModelSubClassDummyClient).Name, serverEntry.SubEntries[4].SubEntries[2].Value.Current);
}
public void FormatProviderTest(string cultureName)
{
// Arrange
var formatProvider = new CultureInfo(cultureName);
var serialization = new DefaultSerialization {
FormatProvider = formatProvider
};
var dummy = new DummyClass
{
Number = 1001,
SingleClass = new SubClass {
Foo = 1.1234f
}
};
// Act
var encoded = EntryConvert.EncodeObject(dummy, serialization);
var dummyDecoded = EntryConvert.CreateInstance <DummyClass>(encoded, serialization);
// Assert
Assert.AreEqual(1001.ToString(formatProvider), encoded.SubEntries[0].Value.Current);
Assert.AreEqual(1.1234f.ToString(formatProvider), encoded.SubEntries[3].SubEntries[0].Value.Current);
Assert.AreEqual(1001, dummyDecoded.Number);
Assert.AreEqual(1.1234f, dummyDecoded.SingleClass.Foo);
}
public void RemoveEntry(CollectionType type, int prefill, int[] removedIndexes)
{
// Arrange
var obj = Prebuild(type, prefill);
var encoded = EntryConvert.EncodeObject(obj);
// Act
var colEntry = CollectionEntry(encoded.SubEntries, type);
if (type == CollectionType.Dictionary)
{
colEntry.SubEntries.RemoveAll(e => removedIndexes.Contains(int.Parse(e.Identifier) - 1));
}
else
{
colEntry.SubEntries.RemoveAll(e => removedIndexes.Contains(int.Parse(e.Identifier)));
}
EntryConvert.UpdateInstance(obj, encoded);
// Assert
var collection = ExtractCollection(type, obj);
var totalSize = prefill - removedIndexes.Length;
Assert.AreEqual(totalSize, collection.Count, "New size invalid");
if (type == CollectionType.Dictionary)
{
var array = (collection as IEnumerable <KeyValuePair <int, SubClass> >).ToArray();
for (var i = 0; i < prefill; i++)
{
if (removedIndexes.Contains(i))
{
continue;
}
var match = array.FirstOrDefault(e => e.Key == i + 1);
Assert.NotNull(match);
}
}
else
{
var array = (collection as IEnumerable <SubClass>).ToArray();
for (var i = 0; i < prefill; i++)
{
if (removedIndexes.Contains(i))
{
continue;
}
var match = array.FirstOrDefault(e => e.Foo == i + 1);
Assert.NotNull(match);
}
}
}
public void UpdateDictionary()
{
// Arrange
var dummy = new DictionaryClass
{
SubDictionary = new Dictionary <string, int>
{
{ "077", 6 },
{ "088", 9 }
},
EnumDictionary = new Dictionary <string, DummyEnum>
{
{ "011", DummyEnum.Unset },
{ "022", DummyEnum.ValueB }
}
};
var encoded = EntryConvert.EncodeObject(dummy);
var entry1 = encoded.SubEntries[1];
var entry2 = encoded.SubEntries[2];
for (var i = 1; i <= 2; i++)
{
var newInstance = entry1.Prototypes[0].Instantiate();
newInstance.Value.Current = (1 + i).ToString();
newInstance.DisplayName = "Key" + i;
entry1.SubEntries.Add(newInstance);
}
entry1.SubEntries[0].Value.Current = "123";
entry1.SubEntries[0].DisplayName = "022";
for (var i = 1; i <= 3; i++)
{
var newInstance = entry2.Prototypes[0].Instantiate();
newInstance.Value.Current = ((DummyEnum)(i % 3)).ToString();
newInstance.DisplayName = "Key_0121" + i;
entry2.SubEntries.Add(newInstance);
}
entry2.SubEntries[0].Value.Current = DummyEnum.ValueA.ToString();
entry2.SubEntries[0].DisplayName = "555";
// Act
EntryConvert.UpdateInstance(dummy, encoded);
// Assert
Assert.AreEqual(5, dummy.EnumDictionary.Count);
Assert.AreEqual(4, dummy.SubDictionary.Count);
Assert.AreEqual(123, dummy.SubDictionary["022"]);
Assert.AreEqual(DummyEnum.ValueA, dummy.EnumDictionary["555"]);
}
public void UpdateEntries(CollectionType type)
{
// Arrange
var obj = Prebuild(type, 3);
var encoded = EntryConvert.EncodeObject(obj);
// Act
var colEntry = CollectionEntry(encoded.SubEntries, type);
if (type == CollectionType.Dictionary)
{
foreach (var entry in colEntry.SubEntries)
{
//change "Key" + 10
entry.DisplayName = "1" + entry.SubEntries[0].Value.Current;
// change "Value"
entry.SubEntries[0].Value.Current = "1" + entry.SubEntries[0].Value.Current;
entry.SubEntries[1].Value.Current = entry.SubEntries[1].Value.Possible[2];
}
EntryConvert.UpdateInstance(obj, encoded);
// Assert
var collection = ExtractCollection(type, obj);
for (var i = 0; i < collection.Count; i++)
{
Assert.IsTrue(obj.SubDictionary.ContainsKey(11 + i));
Assert.AreEqual((float)11 + i, obj.SubDictionary[11 + i].Foo);
Assert.AreEqual(DummyEnum.ValueB, obj.SubDictionary[11 + i].Enum);
}
}
else
{
foreach (var entry in colEntry.SubEntries)
{
entry.SubEntries[0].Value.Current = "1" + entry.SubEntries[0].Value.Current;
entry.SubEntries[1].Value.Current = entry.SubEntries[1].Value.Possible[2];
}
EntryConvert.UpdateInstance(obj, encoded);
// Assert
var collection = ExtractCollection(type, obj);
var array = (collection as IEnumerable <SubClass>).ToArray();
for (var i = 0; i < collection.Count; i++)
{
Assert.AreEqual((float)11 + i, array[i].Foo);
Assert.AreEqual(DummyEnum.ValueB, array[i].Enum);
}
}
}
public void SurviveGetterException()
{
// Arrange
var dummy = new ExceptionDummy();
// Act
var encoded = EntryConvert.EncodeObject(dummy);
// Assert
Assert.NotNull(encoded);
Assert.AreEqual(EntryValueType.Exception, encoded.SubEntries[0].Value.Type);
Assert.NotNull(encoded.SubEntries[0].Value.Current);
}
public void NonLocalized()
{
// Arrange
var dummyClass = new DummyClass();
// Act
Thread.CurrentThread.CurrentUICulture = _germanCulture;
var entriesGerman = EntryConvert.EncodeObject(dummyClass);
// Assert
Assert.AreEqual(nameof(DummyClass.SingleClassNonLocalized), entriesGerman.SubEntries[14].DisplayName);
Assert.IsNull(entriesGerman.SubEntries[14].Description);
}
public ActionResult <ProductCustomization> GetProductCustomization()
{
return(new ProductCustomization
{
ProductTypes = GetProductTypes(),
RecipeTypes = GetRecipeTypes(),
Importers = _productManagement.Importers.Select(i => new ProductImporter
{
Name = i.Key,
Parameters = EntryConvert.EncodeObject(i.Value)
}).ToArray()
});
}
public void UpdatePrimitiveList()
{
// Arrange
var defaultSerialization = new DefaultSerialization {
FormatProvider = new CultureInfo("en-US")
};
var dummy = new ListDummy
{
Number = 0,
DoubleList = new List <double> {
1.7, 2.5, 3
},
EnumList = new List <DummyEnum> {
DummyEnum.ValueA, DummyEnum.Unset, DummyEnum.ValueB
}
};
var encoded = EntryConvert.EncodeObject(dummy, defaultSerialization);
var ent = encoded.SubEntries[1];
var ent2 = encoded.SubEntries[2];
// Act
encoded.SubEntries[0].Value.Current = "5";
ent.SubEntries[1].Value.Current = 12.34d.ToString(defaultSerialization.FormatProvider);
var newInstance = ent.Prototypes[0].Instantiate();
newInstance.Value.Current = 133.7d.ToString(defaultSerialization.FormatProvider);
ent.SubEntries.Add(newInstance);
ent2.SubEntries[1].Value.Current = "ValueB";
newInstance = ent2.Prototypes[0].Instantiate();
newInstance.Value.Current = "ValueA";
ent2.SubEntries.Add(newInstance);
EntryConvert.UpdateInstance(dummy, encoded, defaultSerialization);
// Assert
Assert.AreEqual(5, dummy.Number);
Assert.AreEqual(4, dummy.DoubleList.Count);
Assert.AreEqual(1.7, dummy.DoubleList[0]);
Assert.AreEqual(12.34, dummy.DoubleList[1]);
Assert.AreEqual(3.0, dummy.DoubleList[2]);
Assert.AreEqual(133.7, dummy.DoubleList[3]);
Assert.AreEqual(4, dummy.EnumList.Count);
Assert.AreEqual(DummyEnum.ValueA, dummy.EnumList[0]);
Assert.AreEqual(DummyEnum.ValueB, dummy.EnumList[1]);
Assert.AreEqual(DummyEnum.ValueB, dummy.EnumList[2]);
Assert.AreEqual(DummyEnum.ValueA, dummy.EnumList[3]);
}
public void UpdateArray()
{
// Arrange
var dummy = new ArrayDummy
{
Array = new[] { 2, 5, 7 },
Keys = new[] { "test1_2", "test_02", "1245" },
Enums = new[] { DummyEnum.Unset, DummyEnum.ValueB, DummyEnum.ValueA }
};
// Act
var encoded = EntryConvert.EncodeObject(dummy);
var entry1 = encoded.SubEntries[0];
var entry2 = encoded.SubEntries[1];
var entry3 = encoded.SubEntries[2];
entry1.SubEntries[1].Value.Current = "42";
var instance1 = encoded.SubEntries[0].Prototypes[0].Instantiate();
instance1.Value.Current = "1337";
entry1.SubEntries.Add(instance1);
entry2.SubEntries[2].Value.Current = "hallo";
var instance2 = entry2.Prototypes[0].Instantiate();
instance2.Value.Current = "new_Value";
entry2.SubEntries.Add(instance2);
entry3.SubEntries[0].Value.Current = "ValueA";
var instance3 = entry3.Prototypes[0].Instantiate();
instance3.Value.Current = "ValueB";
entry3.SubEntries.Add(instance3);
EntryConvert.UpdateInstance(dummy, encoded);
// Assert
Assert.AreEqual(4, dummy.Array.Length);
Assert.AreEqual(42, dummy.Array[1]);
Assert.AreEqual(1337, dummy.Array[3]);
Assert.AreEqual(4, dummy.Keys.Length);
Assert.AreEqual("test1_2", dummy.Keys[0]);
Assert.AreEqual("test_02", dummy.Keys[1]);
Assert.AreEqual("hallo", dummy.Keys[2]);
Assert.AreEqual("new_Value", dummy.Keys[3]);
Assert.AreEqual(DummyEnum.ValueA, dummy.Enums[0]);
Assert.AreEqual(DummyEnum.ValueB, dummy.Enums[1]);
Assert.AreEqual(DummyEnum.ValueA, dummy.Enums[2]);
Assert.AreEqual(DummyEnum.ValueB, dummy.Enums[3]);
}
public void MemoryStreamEncode()
{
// Arrange
var testString = "This is a test";
var streamDummy = new MemoryStreamDummy(testString);
// Act
var entry = EntryConvert.EncodeObject(streamDummy);
// Assert
Assert.AreEqual(1, entry.SubEntries.Count);
Assert.AreEqual(EntryValueType.Stream, entry.SubEntries[0].Value.Type);
Assert.AreEqual("VGhpcyBpcyBhIHRlc3Q=", entry.SubEntries[0].Value.Current);
}
public void EncodeReadonlyCollection()
{
// Arrange
var dummy = new ListDummy();
// Act
var encoded = EntryConvert.EncodeObject(dummy);
// Assert
var readList = encoded.SubEntries[3];
Assert.AreEqual(1, readList.SubEntries.Count);
Assert.IsTrue(readList.Value.IsReadOnly);
Assert.IsEmpty(readList.Prototypes);
}
public EntryEditorViewModel()
{
var entryModel = new EntryClass
{
ArrayOfByte = new byte[] { 0x01, 0xF3 },
ChainOfChars = "HelloWorld",
ListSubClass = new List <EntrySubClass>
{
new EntrySubClass
{
AByte = 0x33
}
},
SubClass = new EntrySubClass
{
AByte = 0xE2
},
ListEnum = new List <Visibility>
{
Visibility.Hidden,
Visibility.Visible,
Visibility.Collapsed
},
ListBool = new List <bool>
{
true,
false,
false
},
ListString = new List <string>
{
"Hello",
"World"
},
File = "",
Password = "******"
};
var entry = EntryConvert.EncodeObject(entryModel);
entry.DisplayName = "Root";
EntryViewModels = new EntryViewModel(entry);
ShowExceptionCommand = new RelayCommand(ShowException);
BeginEditCmd = new RelayCommand(BeginEdit);
EndEditCmd = new RelayCommand(EndEdit);
CancelEditCmd = new RelayCommand(CancelEdit);
}
public RecipeModel ConvertRecipe(IRecipe recipe)
{
// Transform to DTO and transmit
var converted = new RecipeModel
{
Id = recipe.Id,
Name = recipe.Name,
Type = recipe.GetType().Name,
State = recipe.State,
Revision = recipe.Revision,
Properties = EntryConvert.EncodeObject(recipe, RecipeSerialization),
IsClone = recipe.Classification.HasFlag(RecipeClassification.Clone)
};
switch (recipe.Classification & RecipeClassification.CloneFilter)
{
case RecipeClassification.Unset:
converted.Classification = RecipeClassificationModel.Unset;
break;
case RecipeClassification.Default:
converted.Classification = RecipeClassificationModel.Default;
break;
case RecipeClassification.Alternative:
converted.Classification = RecipeClassificationModel.Alternative;
break;
case RecipeClassification.Intermediate:
converted.Classification = RecipeClassificationModel.Intermediate;
break;
case RecipeClassification.Part:
converted.Classification = RecipeClassificationModel.Part;
break;
}
var wpRecipe = recipe as IWorkplanRecipe;
if (wpRecipe?.Workplan != null)
{
converted.WorkplanId = wpRecipe.Workplan.Id;
converted.WorkplanModel = ConvertWorkplan(wpRecipe.Workplan);
}
return(converted);
}
public void LocalizedClassDisplay()
{
// Arrange
var subClass = new LocalizedClass();
// Act
Thread.CurrentThread.CurrentUICulture = _germanCulture;
var entriesGerman = EntryConvert.EncodeObject(subClass);
Thread.CurrentThread.CurrentUICulture = _invariantCulture;
var entriesInvariant = EntryConvert.EncodeObject(subClass);
// Assert
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.ClassName), _germanCulture), entriesGerman.DisplayName);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.ClassName), _invariantCulture), entriesInvariant.DisplayName);
}
public void EncodeObject()
{
// Arrange
var dummy = new DummyClass
{
Number = 10,
Name = "Thomas",
SingleClass = null,
SubArray = new[] { new SubClass {
Foo = (float)1.2, Enum = DummyEnum.ValueB
} },
SubList = new List <SubClass> {
new SubClass {
Foo = (float)3.4, Enum = DummyEnum.ValueA
}
},
SubEnumerable = new List <SubClass> {
new SubClass {
Foo = (float)3.4, Enum = DummyEnum.ValueA
}
},
SubDictionary = new Dictionary <int, SubClass>()
};
dummy.SubDictionary.Add(1, new SubClass()
{
Enum = DummyEnum.ValueA, Foo = (float)3.4
});
dummy.SubDictionary.Add(2, new SubClass()
{
Enum = DummyEnum.ValueB, Foo = (float)3.5
});
// Act
var encoded = EntryConvert.EncodeObject(dummy).SubEntries;
var encodedSub = encoded[4].SubEntries[0].SubEntries;
// Assert
DummyAssert(encoded, encodedSub);
var expected = new[] { "10", "Thomas", "10" };
for (var i = 0; i < 3; i++)
{
Assert.AreEqual(expected[i], encoded[i].Value.Current, "Property value missmatch");
}
}
private PartModel ConvertPart(IProductPartLink link)
{
// No link, no DTO!
if (link is null || link.Product is null)
{
return(null);
}
var part = new PartModel
{
Id = link.Id,
Product = ConvertProduct(link.Product, true),
Properties = EntryConvert.EncodeObject(link, ProductSerialization)
};
return(part);
}
private ProductModel ConvertProduct(IProductType productType, bool flat)
{
var converted = _productCache.FirstOrDefault(p => p.Id == productType.Id);
if (converted != null)
{
return(converted);
}
// Base object
var identity = (ProductIdentity)productType.Identity ?? EmptyIdentity;
converted = new ProductModel
{
Id = productType.Id,
Type = productType.GetType().Name,
Name = productType.Name,
State = productType.State,
Identifier = identity.Identifier,
Revision = identity.Revision
};
if (flat)
{
return(converted);
}
// Properties
var properties = productType.GetType().GetProperties();
converted.Properties = EntryConvert.EncodeObject(productType, ProductSerialization);
// Files
converted.Files = ConvertFiles(productType, properties);
// Recipes
var recipes = RecipeManagement.GetAllByProduct(productType);
converted.Recipes = recipes.Select(ConvertRecipe).ToArray();
// Parts
ConvertParts(productType, properties, converted);
_productCache.Add(converted);
return(converted);
}
public void EncodeCollection()
{
// Arrange
var values = new string[] { "Hello", "World" };
// Act
var encoded = EntryConvert.EncodeObject(values);
// Assert
Assert.NotNull(encoded);
Assert.AreEqual(EntryValueType.Collection, encoded.Value.Type);
Assert.AreEqual(2, encoded.SubEntries.Count);
var se = encoded.SubEntries;
Assert.AreEqual(values[0], se[0].Value.Current);
Assert.AreEqual(values[1], se[1].Value.Current);
}
public void MemoryStreamDecode()
{
// Arrange
var testString = "This is a test";
var streamDummy = new MemoryStreamDummy(testString);
var targetStreamDummy = new MemoryStreamDummy("");
var streamInstanceToCheck = targetStreamDummy.MemoryStream;
var entry = EntryConvert.EncodeObject(streamDummy);
// Act
EntryConvert.UpdateInstance(targetStreamDummy, entry);
// Assert
var stringValue = Encoding.UTF8.GetString(targetStreamDummy.MemoryStream.ToArray());
Assert.AreEqual(testString, stringValue);
Assert.AreNotSame(streamInstanceToCheck, targetStreamDummy.MemoryStream);
}
public void MemoryStreamDecodeReuseCurrentStreamInitSizeIsGreaterThanNewData()
{
// Arrange
var testString = "A test";
var dummyString = "12345678912345";
var streamDummy = new MemoryStreamDummy(testString);
var targetStreamDummy = new MemoryStreamDummy(dummyString);
var streamInstanceToCheck = targetStreamDummy.MemoryStream;
var entry = EntryConvert.EncodeObject(streamDummy);
// Act
EntryConvert.UpdateInstance(targetStreamDummy, entry);
// Assert
var stringValue = Encoding.UTF8.GetString(targetStreamDummy.MemoryStream.ToArray());
Assert.AreEqual(testString, stringValue);
Assert.AreSame(streamInstanceToCheck, targetStreamDummy.MemoryStream);
}
/// <summary>
/// Checks if resource and model are equal
/// </summary>
/// <param name="resource"></param>
/// <param name="serialization"></param>
/// <returns></returns>
internal bool DifferentFrom(Resource resource, ICustomSerialization serialization)
{
// Do not compare values that were not transmitted
if (resource.Descriptor == null || PartiallyLoaded)
{
return(false);
}
// Compare obvious base properties
var different = resource.Name != Name || resource.Description != Description;
if (different)
{
return(true);
}
var resourceProperties = EntryConvert.EncodeObject(resource.Descriptor, serialization);
return(!Entry.ValuesEqual(Properties, resourceProperties));
}
public void FileStreamEncode()
{
// Arrange
var testString = "This is a test";
var testFilePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "text.txt");
var streamDummy = new FileStreamDummy(testFilePath, FileMode.Create);
var testBytes = Encoding.UTF8.GetBytes(testString);
streamDummy.FileStream.Write(testBytes, 0, testBytes.Length);
// Act
var entry = EntryConvert.EncodeObject(streamDummy);
// Assert
Assert.AreEqual(1, entry.SubEntries.Count);
Assert.AreEqual(EntryValueType.Stream, entry.SubEntries[0].Value.Type);
Assert.AreEqual("VGhpcyBpcyBhIHRlc3Q=", entry.SubEntries[0].Value.Current);
streamDummy.FileStream.Close();
File.Delete(testFilePath);
}
public ProductModel ConvertProduct(IProductType productType, bool flat)
{
// Base object
var identity = (ProductIdentity)productType.Identity ?? EmptyIdentity;
var converted = new ProductModel
{
Id = productType.Id,
Type = productType.GetType().Name,
Name = productType.Name,
State = productType.State,
Identifier = identity.Identifier,
Revision = identity.Revision
};
if (flat)
{
return(converted);
}
// Properties
var properties = productType.GetType().GetProperties();
converted.Properties = EntryConvert.EncodeObject(productType, ProductSerialization);
// Files
converted.Files = (from property in properties
where property.PropertyType == typeof(ProductFile)
select(ProductFile) property.GetValue(productType)).ToArray();
converted.FileModels = ConvertFiles(productType, properties);
// Recipes
var recipes = RecipeManagement.GetAllByProduct(productType);
converted.Recipes = recipes.Select(ConvertRecipe).ToArray();
// Parts
ConvertParts(productType, properties, converted);
return(converted);
}
public Config GetConfig(string moduleName)
{
Logger.Log(LogLevel.Info, "Converting config of plugin {0}", moduleName);
try
{
var module = GetModuleFromManager(moduleName);
var serialization = CreateSerialization(module);
var config = GetConfig(module, false);
var configModel = new Config
{
Root = EntryConvert.EncodeObject(config, serialization)
};
return(configModel);
}
catch (Exception ex)
{
Logger.LogException(LogLevel.Warning, ex, "Failed to convert config of {0}", moduleName);
HttpHelper.SetStatusCode(HttpStatusCode.InternalServerError);
return(null);
}
}
private EntryModelDummyClient CreateDummyClient()
{
return(new EntryModelDummyClient
{
Value = 76,
HasAnything = false,
Class = new EntryModelSubClassDummyClient {
Value = "0.2", Enum = "Unset"
},
Collection = new EntryCollection <EntryModelSubClassDummyClient>(EntryConvert.EncodeObject(
new EntryModelListHelperDummy
{
Collection = new List <EntryModelSubClassDummyClient>
{
new EntryModelSubClassDummyClient {
Value = "0.8", Enum = "ValueA"
},
new EntryModelSubClassDummyClient {
Value = "0.4", Enum = "Unset"
}
}
}).SubEntries[0]),
Dictionary = new EntryDictionary <EntryModelSubClassDummyClient>(EntryConvert.EncodeObject(
new EntryModelDictionaryHelperDummy
{
Dictionary = new Dictionary <int, EntryModelSubClassDummyClient>
{
{ 1, new EntryModelSubClassDummyClient {
Value = "4.6", Enum = "ValueA"
} },
{ 2, new EntryModelSubClassDummyClient {
Value = "79.1", Enum = "ValueB"
} }
}
}
).SubEntries[0])
});
}
