public void PrimitiveCollectionPrototypes(bool possibleValues)
{
// Arrange
var serialization = possibleValues
? new PossibleValuesSerialization(null, new ValueProviderExecutor(new ValueProviderExecutorSettings().AddDefaultValueProvider()))
: (ICustomSerialization) new DefaultSerialization();
// Act
var encoded = EntryConvert.EncodeClass(typeof(ListDummy), serialization);
// Assert
var doubles = encoded.SubEntries[1];
Assert.AreEqual(nameof(EntryValueType.Double), doubles.Value.Possible[0]);
Assert.AreEqual(1, doubles.Prototypes.Count);
if (possibleValues)
{
Assert.AreEqual(3, doubles.Prototypes[0].Value.Possible.Length);
}
else
{
Assert.IsNull(doubles.Prototypes[0].Value.Possible);
}
var enums = encoded.SubEntries[2];
Assert.AreEqual(3, enums.Value.Possible.Length);
Assert.AreEqual(3, enums.Prototypes.Count);
for (int i = 0; i < 3; i++)
{
Assert.AreEqual(enums.Value.Possible[i], enums.Prototypes[i].Value.Current);
}
}
public void MethodLocalization()
{
// Arrange
var methodClass = new LocalizedMethodDummyClass();
// Act
Thread.CurrentThread.CurrentUICulture = _germanCulture;
var entriesGerman = EntryConvert.EncodeMethods(methodClass).ToArray();
Thread.CurrentThread.CurrentUICulture = _invariantCulture;
var entriesInvariant = EntryConvert.EncodeMethods(methodClass).ToArray();
// Assert
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.InitiateWorldTermination), _germanCulture), entriesGerman[0].DisplayName);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.InitiateWorldTerminationDescription), _germanCulture), entriesGerman[0].Description);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.EvacuatePeopleParam), _germanCulture), entriesGerman[0].Parameters.SubEntries[0].DisplayName);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.EvacuatePeopleParamDescription), _germanCulture), entriesGerman[0].Parameters.SubEntries[0].Description);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.NameOfTerminatorParam), _germanCulture), entriesGerman[0].Parameters.SubEntries[1].DisplayName);
Assert.IsNull(entriesGerman[0].Parameters.SubEntries[1].Description);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.InitiateWorldTermination), _invariantCulture), entriesInvariant[0].DisplayName);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.InitiateWorldTerminationDescription), _invariantCulture), entriesInvariant[0].Description);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.EvacuatePeopleParam), _invariantCulture), entriesInvariant[0].Parameters.SubEntries[0].DisplayName);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.EvacuatePeopleParamDescription), _invariantCulture), entriesInvariant[0].Parameters.SubEntries[0].Description);
Assert.AreEqual(strings.ResourceManager.GetString(nameof(strings.NameOfTerminatorParam), _invariantCulture), entriesInvariant[0].Parameters.SubEntries[1].DisplayName);
Assert.IsNull(entriesInvariant[0].Parameters.SubEntries[1].Description);
}
public IProductRecipe ConvertRecipeBack(RecipeModel recipe, IProductType productType)
{
IProductRecipe productRecipe;
if (recipe.Id == 0)
{
var type = ReflectionTool.GetPublicClasses <IProductRecipe>(t => t.Name == recipe.Type).First();
productRecipe = (IProductRecipe)Activator.CreateInstance(type);
}
else
{
productRecipe = RecipeManagement.Get(recipe.Id);
}
productRecipe.Name = recipe.Name;
productRecipe.Revision = recipe.Revision;
productRecipe.State = recipe.State;
// Only load workplan if it changed
var workplanRecipe = productRecipe as IWorkplanRecipe;
if (workplanRecipe != null && workplanRecipe.Workplan?.Id != recipe.WorkplanId)
{
workplanRecipe.Workplan = WorkplanManagement.LoadWorkplan(recipe.WorkplanId);
}
if (productRecipe.Product == null)
{
productRecipe.Product = productType;
}
switch (recipe.Classification)
{
case RecipeClassificationModel.Unset:
productRecipe.Classification = RecipeClassification.Unset;
break;
case RecipeClassificationModel.Default:
productRecipe.Classification = RecipeClassification.Default;
break;
case RecipeClassificationModel.Alternative:
productRecipe.Classification = RecipeClassification.Alternative;
break;
case RecipeClassificationModel.Intermediate:
productRecipe.Classification = RecipeClassification.Intermediate;
break;
case RecipeClassificationModel.Part:
productRecipe.Classification = RecipeClassification.Part;
break;
default:
throw new ArgumentOutOfRangeException();
}
EntryConvert.UpdateInstance(productRecipe, recipe.Properties, RecipeSerialization);
return(productRecipe);
}
public void PropertyLocalization()
{
var resourceManager = new ResourceManager(typeof(strings));
var germanCulture = new CultureInfo("de");
var invariantCulture = new CultureInfo("en");
// Switch to german
Thread.CurrentThread.CurrentUICulture = germanCulture;
var expectedDisplayPropName = resourceManager.GetString(nameof(strings.PropDisplayAttribute_Name), germanCulture);
var expectedDisplayPropDescription = resourceManager.GetString(nameof(strings.PropDisplayAttribute_Description), germanCulture);
var encoded = EntryConvert.EncodeClass(typeof(LocalizedClass));
Assert.AreEqual(expectedDisplayPropName, encoded.SubEntries[0].DisplayName);
Assert.AreEqual(expectedDisplayPropDescription, encoded.SubEntries[0].Description);
Assert.AreEqual(LocalizedClass.PropDisplayNameAttributeDisplayName, encoded.SubEntries[1].DisplayName);
// Switch to invariant
Thread.CurrentThread.CurrentUICulture = invariantCulture;
expectedDisplayPropName = resourceManager.GetString(nameof(strings.PropDisplayAttribute_Name), invariantCulture);
expectedDisplayPropDescription = resourceManager.GetString(nameof(strings.PropDisplayAttribute_Description), invariantCulture);
encoded = EntryConvert.EncodeClass(typeof(LocalizedClass));
Assert.AreEqual(expectedDisplayPropName, encoded.SubEntries[0].DisplayName);
Assert.AreEqual(expectedDisplayPropDescription, encoded.SubEntries[0].Description);
Assert.AreEqual(LocalizedClass.PropDisplayNameAttributeDisplayName, encoded.SubEntries[1].DisplayName);
}
public Entry InvokeMethod(string moduleName, MethodEntry method)
{
Entry result = null;
var serverModule = GetModuleFromManager(moduleName);
if (serverModule != null && method != null)
{
try
{
result = EntryConvert.InvokeMethod(serverModule.Console, method,
CreateEditorSerializeSerialization(serverModule));
}
catch (Exception e)
{
result = new Entry
{
Description = $"Error while invoking function: {method.DisplayName}",
DisplayName = "Error description",
Identifier = "0",
Value = new EntryValue {
Current = e.Message, Type = EntryValueType.String
}
};
}
}
else
{
var ctx = WebOperationContext.Current;
// ReSharper disable once PossibleNullReferenceException
ctx.OutgoingResponse.StatusCode = HttpStatusCode.NotFound;
}
return(result);
}
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 SetConfig(string moduleName, SaveConfigRequest request)
{
try
{
var module = GetModuleFromManager(moduleName);
var serialization = CreateSerialization(module);
var config = GetConfig(module, true);
EntryConvert.UpdateInstance(config, request.Config.Root, serialization);
ConfigManager.SaveConfiguration(config, request.UpdateMode == ConfigUpdateMode.UpdateLiveAndSave);
if (request.UpdateMode == ConfigUpdateMode.SaveAndReincarnate)
{
// This has to be done parallel so we can also reincarnate the Maintenance itself
ParallelOperations.ExecuteParallel(() => ModuleManager.ReincarnateModule(module));
}
}
catch (Exception ex)
{
Logger.LogException(LogLevel.Warning, ex, "Failed to save 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
}
}
private ReferenceTypeModel ConvertReferenceProperty(PropertyInfo property, IDictionary <string, List <Type> > overrides)
{
var referenceAttr = property.GetCustomAttribute <ResourceReferenceAttribute>();
var displayName = property.GetDisplayName();
// Create reference model from property information and optional attribute
var referenceModel = new ReferenceTypeModel
{
Name = property.Name,
DisplayName = !string.IsNullOrEmpty(displayName) ? displayName : property.Name,
Description = property.GetDescription(),
Role = referenceAttr.Role,
RelationType = referenceAttr.RelationType,
IsRequired = referenceAttr.IsRequired,
IsCollection = typeof(IEnumerable <IResource>).IsAssignableFrom(property.PropertyType)
};
// Get type constraints
Type targetType = property.PropertyType;
if (referenceModel.IsCollection)
{
targetType = EntryConvert.ElementType(targetType);
}
var typeConstraints = MergeTypeConstraints(property, targetType, overrides);
referenceModel.SupportedTypes = TypeController.SupportedTypes(typeConstraints).Select(t => t.Name).ToArray();
return(referenceModel);
}
private void UpdateCollection(IList value, IEnumerable <PartModel> parts)
{
// Track which part links are still represented by the models
var unused = new List <IProductPartLink>(value.OfType <IProductPartLink>());
// Iterate over the part models
// Create or update the part links
var elemType = value.GetType().GetGenericArguments()[0];
foreach (var partModel in parts)
{
var match = unused.Find(r => r.Id == partModel.Id);
if (match == null)
{
match = (IProductPartLink)Activator.CreateInstance(elemType);
value.Add(match);
}
else
{
unused.Remove(match);
}
EntryConvert.UpdateInstance(match, partModel.Properties);
match.Product = (ProductType)ProductManager.LoadType(partModel.Product.Id);
}
// Clear all values no longer present in the model
foreach (var link in unused)
{
value.Remove(link);
}
}
public void CreateInstanceWithArray()
{
// Arrange
var type = typeof(ArrayDummy);
var encoded = EntryConvert.EncodeClass(type);
var entry1 = encoded.SubEntries[0];
var entry2 = encoded.SubEntries[1];
for (var i = 1; i <= 5; i++)
{
var newInstance = entry1.Prototypes[0].Instantiate();
newInstance.Value.Current = (1 + i).ToString();
entry1.SubEntries.Add(newInstance);
}
for (var i = 1; i <= 5; i++)
{
var newInstance = entry2.Prototypes[0].Instantiate();
newInstance.Value.Current = "Number: " + i;
entry2.SubEntries.Add(newInstance);
}
// Act
var dummy = EntryConvert.CreateInstance <ArrayDummy>(encoded);
// Assert
for (var i = 1; i <= 5; i++)
{
Assert.AreEqual(i + 1, dummy.Array[i - 1]);
Assert.AreEqual("Number: " + i, dummy.Keys[i - 1]);
}
}
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 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);
}
/// <summary>
/// Convert ResourceModel back to resource and/or update its properties
/// </summary>
public Resource FromModel(ResourceModel model, HashSet <Resource> resourcesToSave, Resource resource = null)
{
// Break recursion if we converted this instance already
// Try to load by real id first
if (_resourceCache.ContainsKey(model.Id))
{
return(_resourceCache[model.Id]);
}
// Otherwise by reference id
if (model.Id == 0 && _resourceCache.ContainsKey(model.ReferenceId))
{
return(_resourceCache[model.ReferenceId]);
}
// Only fetch resource object if it was not given
if (resource == null)
{
resource = model.Id == 0
? _resourceGraph.Instantiate(model.Type)
: _resourceGraph.Get(model.Id);
}
// Write to cache because following calls might only have an empty reference
if (model.Id == 0)
{
_resourceCache[model.ReferenceId] = resource;
}
else
{
_resourceCache[model.Id] = resource;
}
// Do not copy values from partially loaded models
if (model.PartiallyLoaded)
{
return(resource);
}
// Add to list if object was created or modified
if (model.Id == 0 || model.DifferentFrom(resource, _serialization))
{
resourcesToSave.Add(resource);
}
// Copy standard properties
resource.Name = model.Name;
resource.Description = model.Description;
// Copy extended properties
EntryConvert.UpdateInstance(resource.Descriptor, model.Properties, _serialization);
// Set all other references
UpdateReferences(resource, resourcesToSave, model);
return(resource);
}
private IProductType ConvertProductBack(ProductModel product)
{
// Fetch instance and copy base values
ProductType converted;
if (product.Id == 0)
{
converted = (ProductType)ProductManager.CreateType(product.Type);
}
else
{
converted = (ProductType)ProductManager.LoadType(product.Id);
}
converted.Identity = new ProductIdentity(product.Identifier, product.Revision);
converted.Name = product.Name;
converted.State = product.State;
// Copy extended properties
var properties = converted.GetType().GetProperties();
EntryConvert.UpdateInstance(converted, product.Properties, ProductSerialization);
ConvertFilesBack(converted, product, properties);
// Save recipes
var recipes = product.Recipes.Select(r => ConvertRecipeBack(r, converted)).ToList();
RecipeManagement.Save(product.Id, recipes);
// Convert parts
foreach (var partConnector in product.Parts)
{
var prop = properties.First(p => p.Name == partConnector.Name);
var value = prop.GetValue(converted);
if (partConnector.IsCollection)
{
UpdateCollection((IList)value, partConnector.Parts);
}
else if (partConnector.Parts.Length == 1)
{
if (value == null)
{
value = Activator.CreateInstance(prop.PropertyType);
prop.SetValue(converted, value);
}
UpdateReference((IProductPartLink)value, partConnector.Parts[0]);
}
else if (partConnector.Parts.Length == 0)
{
prop.SetValue(converted, null);
}
}
return(converted);
}
public ProductDefinitionModel ConvertProductType(Type productType)
{
return(new()
{
Name = productType.Name,
DisplayName = productType.GetDisplayName() ?? productType.Name,
BaseDefinition = productType.BaseType?.Name,
Properties = EntryConvert.EncodeClass(productType, ProductSerialization)
});
}
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"]);
}
/// <summary>
/// Check if a property is a collection of primitives
/// </summary>
private static bool IsPrimitiveCollection(Type memberType)
{
if (!EntryConvert.IsCollection(memberType))
{
return(false);
}
var elementType = EntryConvert.ElementType(memberType);
return(EntryConvert.ValueOrStringType(elementType));
}
public IProductRecipe ConvertRecipeBack(RecipeModel recipe, IProductRecipe productRecipe, IProductType productType)
{
productRecipe.Name = recipe.Name;
productRecipe.Revision = recipe.Revision;
productRecipe.State = recipe.State;
// Only load workplan if it changed
var workplanRecipe = productRecipe as IWorkplanRecipe;
if (workplanRecipe != null && workplanRecipe.Workplan?.Id != recipe.WorkplanId)
{
workplanRecipe.Workplan = WorkplanManagement.LoadWorkplan(recipe.WorkplanId);
}
if (productRecipe.Product == null)
{
productRecipe.Product = productType;
}
EntryConvert.UpdateInstance(productRecipe, recipe.Properties, RecipeSerialization);
// Do not update a clones classification
if (productRecipe.Classification.HasFlag(RecipeClassification.Clone))
{
return(productRecipe);
}
switch (recipe.Classification)
{
case RecipeClassificationModel.Unset:
productRecipe.Classification = RecipeClassification.Unset;
break;
case RecipeClassificationModel.Default:
productRecipe.Classification = RecipeClassification.Default;
break;
case RecipeClassificationModel.Alternative:
productRecipe.Classification = RecipeClassification.Alternative;
break;
case RecipeClassificationModel.Intermediate:
productRecipe.Classification = RecipeClassification.Intermediate;
break;
case RecipeClassificationModel.Part:
productRecipe.Classification = RecipeClassification.Part;
break;
default:
throw new ArgumentOutOfRangeException();
}
return(productRecipe);
}
private IImportParameters ConvertParametersBack(string importerName, Entry currentParameters, bool updateFirst = false)
{
var importer = Manager.Importers.First(i => i.Name == importerName);
var parameters = (IImportParameters)EntryConvert.UpdateInstance(importer.Parameters, currentParameters);
if (updateFirst)
{
parameters = importer.Update(parameters);
}
return(parameters);
}
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 MethodEntry[] GetMethods(string moduleName)
{
var methods = new MethodEntry[] {};
var serverModule = GetModuleFromManager(moduleName);
if (serverModule?.Console != null)
{
methods = EntryConvert.EncodeMethods(serverModule.Console, CreateEditorSerializeSerialization(serverModule)).ToArray();
}
return(methods);
}
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 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()
});
}
private object ConvertParametersBack(string importerName, Entry currentParameters)
{
var oldParameters = _productManagement.Importers.FirstOrDefault(i => i.Key == importerName).Value;
if (oldParameters == null)
{
return(null);
}
var parameters = EntryConvert.UpdateInstance(oldParameters, currentParameters);
return(parameters);
}
/// <summary>
/// Get all reference overrides from a resources properties
/// </summary>
private static Dictionary <string, List <Type> > GetReferenceOverrides(IEnumerable <PropertyInfo> properties)
{
// TODO Type wrappers in AL5
var referenceOverrides = (from prop in properties
let overrideAtt = prop.GetCustomAttribute <ReferenceOverrideAttribute>()
where overrideAtt != null
let targetType = typeof(IEnumerable <IResource>).IsAssignableFrom(prop.PropertyType)
? EntryConvert.ElementType(prop.PropertyType) : prop.PropertyType
group targetType by overrideAtt.Source into g
select new { g.Key, overrides = g.ToList() }).ToDictionary(v => v.Key, v => v.overrides);
return(referenceOverrides);
}
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);
}
