public void AddMultipleRelations()
{
var class1 = new Class1().Modl();
class1.MultipleRelation.Add(new Class2());
class1.MultipleRelation.Add(new Class2());
class1.Save();
foreach (var class2 in class1.MultipleRelation)
{
class2.Save();
}
Assert.Equal(2, class1.MultipleRelation.Count());
Assert.Equal(class1.Id(), class1.MultipleRelation.First().SingleRelation.Id);
Assert.Equal(class1.Id(), class1.MultipleRelation.First().SingleRelation.Val.Id());
var loadedClass1 = Modl <Class1> .Get(class1.Id());
Assert.Equal(2, loadedClass1.MultipleRelation.Count());
Assert.Equal(loadedClass1.Id(), loadedClass1.MultipleRelation.First().SingleRelation.Id);
Assert.Equal(loadedClass1.Id(), loadedClass1.MultipleRelation.First().SingleRelation.Val.Id());
foreach (var class2 in class1.MultipleRelation)
{
var loadedClass2 = Modl <Class2> .Get(class2.Id());
Assert.NotNull(loadedClass2.SingleRelation.Val);
Assert.Equal(2, loadedClass2.SingleRelation.Val.MultipleRelation.Count());
Assert.True(loadedClass2.SingleRelation.Val.MultipleRelation.Any(x => x.Id() == loadedClass2.Id()));
}
}
public void Save()
{
var testClass = new CustomIdIntClass();
Assert.Throws <InvalidIdException>(() => testClass.Save());
var id = 2472;
testClass.CustomId = id;
testClass.Save();
Assert.False(testClass.IsNew());
Assert.False(testClass.IsModified());
Assert.True(id == testClass.Id());
Assert.Equal(id, testClass.CustomId);
var loadedTestClass = Modl <CustomIdIntClass> .Get(id);
Assert.Equal(id, loadedTestClass.CustomId);
Assert.True(id == loadedTestClass.Id());
Assert.Equal(id, loadedTestClass.CustomId);
Assert.False(loadedTestClass.IsNew());
Assert.False(loadedTestClass.IsModified());
Assert.Throws <InvalidIdException>(() => loadedTestClass.Id(4544));
Assert.Throws <InvalidIdException>(() =>
{
loadedTestClass.CustomId = 4544;
loadedTestClass.Save();
});
}
//public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
protected override object CreateModel(ControllerContext controllerContext, ModelBindingContext bindingContext, System.Type modelType)
{
var id = bindingContext.ValueProvider.GetValue(bindingContext.ModelName + "." + Modl <M> .Definitions.IdProperty.PropertyName);
if (id == null)
{
id = bindingContext.ValueProvider.GetValue(Modl <M> .Definitions.IdProperty.PropertyName);
}
if (id != null)
{
return(Modl <M> .Get(id.AttemptedValue));
}
return(Modl <M> .New());
//if (bindingContext.ModelType.GetInterface("IModl") != null && value != null)
//{
// if (MvcHelper.IsNumeric(value.AttemptedValue))
// {
// var method = bindingContext.ModelType.GetMethods(BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Public).Single(x => x.Name == "Get" && x.GetParameters()[0].ParameterType == typeof(int));
// return method.Invoke(null, new object[] { Convert.ToInt32(value.AttemptedValue), true });
// }
//}
//return base.BindModel(controllerContext, bindingContext);
}
public void CRUDExplicitId()
{
Manufacturer m1 = Modl <Manufacturer> .New(Guid.NewGuid());
Assert.False(m1.IsModified());
m1.Name = "BMW";
Assert.True(m1.IsModified());
m1.Save();
Assert.False(m1.IsNew());
Assert.False(m1.IsModified());
Manufacturer m2 = Modl <Manufacturer> .Get(m1.ManufacturerID);
AssertEqual(m1, m2);
m2.Name = "Mercedes";
Assert.Equal("Mercedes", m2.Name);
m2.Save();
Manufacturer m3 = Modl <Manufacturer> .Get(m1.ManufacturerID);
Assert.Equal("Mercedes", m3.Name);
m3.Delete();
Assert.True(m3.IsDeleted());
Assert.Throws <NotFoundException>(() => Modl <Manufacturer> .Get(m1.ManufacturerID));
}
public void Save()
{
var testClass = new CustomIdStringClass();
Assert.Throws <InvalidIdException>(() => testClass.Save());
var id = Guid.NewGuid().ToString();
testClass.CustomId = id;
testClass.Save();
Assert.False(testClass.IsNew());
Assert.False(testClass.IsModified());
Assert.True(id == testClass.Id());
Assert.Equal(id, testClass.CustomId);
var loadedTestClass = Modl <CustomIdStringClass> .Get(id);
Assert.Equal(id, loadedTestClass.CustomId);
Assert.True(id == loadedTestClass.Id());
Assert.Equal(id, loadedTestClass.CustomId);
Assert.False(loadedTestClass.IsNew());
Assert.False(loadedTestClass.IsModified());
Assert.Throws <InvalidIdException>(() => loadedTestClass.Id(Guid.NewGuid().ToString()));
Assert.Throws <InvalidIdException>(() =>
{
loadedTestClass.CustomId = Guid.NewGuid().ToString();
loadedTestClass.Save();
});
}
public void AddSingleRelationWithoutModlValue()
{
var class2 = new Class3().Modl();
class2.SingleRelation = new Class1();
class2.Save();
class2.SingleRelation.Save();
Assert.NotNull(class2.SingleRelation);
Assert.Equal(1, class2.SingleRelation.MultipleRelation.Count());
Assert.Equal(class2.Id(), class2.SingleRelation.MultipleRelation.First().Id());
var loadedClass2 = Modl <Class3> .Get(class2.Id());
Assert.NotNull(loadedClass2.SingleRelation);
Assert.Equal(1, loadedClass2.SingleRelation.MultipleRelation.Count());
Assert.Equal(loadedClass2.Id(), loadedClass2.SingleRelation.MultipleRelation.First().Id());
var loadedClass1 = Modl <Class1> .Get(class2.SingleRelation.Id());
Assert.Equal(1, loadedClass1.MultipleRelation.Count());
Assert.Equal(loadedClass1.Id(), loadedClass1.MultipleRelation.First().SingleRelation.Id);
Assert.Equal(loadedClass1.Id(), loadedClass1.MultipleRelation.First().SingleRelation.Val.Id());
}
//[TestCleanup]
//public void Cleanup()
//{
// foreach (var obj in Modl<CustomIdIntClass>.GetAll())
// obj.Delete();
//}
private void Cleanup(int id)
{
if (Modl <CustomIdIntClass> .Exists(id))
{
Modl <CustomIdIntClass> .Get(id).Delete();
}
}
public static Modl CreateMODLFile(SBUltimateModel model)
{
Modl modl = new Modl();
modl.ModelEntries = new ModlEntry[model.Meshes.Count];
Dictionary <string, int> subindex = new Dictionary <string, int>();
int i = 0;
foreach (var mesh in model.Meshes)
{
var entry = new ModlEntry();
modl.ModelEntries[i++] = entry;
if (!subindex.ContainsKey(mesh.Name))
{
subindex.Add(mesh.Name, 0);
}
entry.MeshName = mesh.Name;
entry.SubIndex = subindex[mesh.Name];
if (mesh.Material != null)
{
entry.MaterialLabel = mesh.Material.Label;
}
else
{
SBConsole.WriteLine("Warning: Missing material");
}
subindex[mesh.Name]++;
SBConsole.WriteLine($"Creating modl entry: {entry.MeshName} {entry.SubIndex} {entry.MaterialLabel}");
}
return(modl);
}
public override void Open()
{
if (Ssbh.TryParseSsbhFile(AbsolutePath, out SsbhFile ssbhFile))
{
if (ssbhFile is Modl modl)
{
model = modl;
}
}
}
public void CRUD()
{
//Modl<Car>.Settings.ConfigurePipeline(new JsonModl<Car>(), new FileModl<Car>());
//ModlConfig.GlobalSettings.Serializer = new JsonModl();
//ModlConfig.GlobalSettings.Endpoint = new FileModl();
//Modl<Manufacturer>.Settings.Serializer = new JsonModl();
//Modl<Manufacturer>.Settings.Endpoint = new FileModl();
//Car car = Modl<Car>.New();
var car = new Car();
Assert.False(car.IsModified());
car.Name = "M3";
car.Manufacturer.Val = new Manufacturer("BMW");
car.Type = new CarType();
car.Type.Description = "Sedan";
car.Tags = new List <string>();
car.Tags.Add("Nice");
car.Tags.Add("Fast");
car.Tags.Add("Blue");
car.Tags.Add("Awful");
Assert.Equal("Sedan", car.Type.Description);
Assert.True(car.IsModified());
car.Save();
Assert.False(car.IsNew());
Assert.False(car.IsModified());
car.Manufacturer.Val.Save();
Car car2 = Modl <Car> .Get(car.Id);
AssertEqual(car, car2);
Assert.Equal("Sedan", car2.Type.Description);
car2.Manufacturer.Val.Name = "Mercedes";
Assert.Equal("Mercedes", car2.Manufacturer.Val.Name);
car2.Manufacturer.Val.Save();
Car car3 = Modl <Car> .Get(car.Id);
Assert.Equal("Mercedes", car3.Manufacturer.Val.Name);
car3.Delete();
Assert.True(car3.IsDeleted());
Assert.False(car3.Manufacturer.Val.IsDeleted());
car3.Manufacturer.Val.Delete();
Assert.True(car3.Manufacturer.Val.IsDeleted());
Assert.Throws <NotFoundException>(() => Modl <Car> .Get(car.Id));
}
public void Save()
{
var testClass = new EmptyClass();
var id = testClass.Id();
testClass.Save();
Assert.False(testClass.IsNew());
Assert.False(testClass.IsModified());
Assert.Equal(id, testClass.Id());
var loadedTestClass = Modl <EmptyClass> .Get(id);
Assert.Equal(id, loadedTestClass.Id());
Assert.False(loadedTestClass.IsNew());
Assert.False(loadedTestClass.IsModified());
}
public void List()
{
var modl = new CustomIdStringClass().Id(Guid.NewGuid().ToString()).Save();
var modl2 = new CustomIdStringClass().Id(Guid.NewGuid().ToString()).Save();
var modlList = Modl <CustomIdStringClass> .List().ToList();
Assert.NotEqual(0, modlList.Count);
Assert.True(modlList.Any(x => x as string == modl.Id().Get <string>()));
Assert.True(modlList.Any(x => x as string == modl2.Id().Get <string>()));
var modlList2 = Modl <CustomIdStringClass> .List <string>().ToList();
Assert.NotEqual(0, modlList2.Count);
Assert.True(modlList2.Any(x => x == modl.Id().Get <string>()));
Assert.True(modlList2.Any(x => x == modl2.Id().Get <string>()));
}
public void List()
{
var modl = new EmptyClass().Save();
var modl2 = new EmptyClass().Save();
var modlList = Modl <EmptyClass> .List().ToList();
Assert.NotEqual(0, modlList.Count);
Assert.True(modlList.Any(x => x == modl.Id()));
Assert.True(modlList.Any(x => x == modl2.Id()));
var modlList2 = Modl <EmptyClass> .List <Guid>().ToList();
Assert.NotEqual(0, modlList2.Count);
Assert.True(modlList2.Any(x => x == modl.Id()));
Assert.True(modlList2.Any(x => x == modl2.Id()));
}
public void TestRaces()
{
var testClass = new ThreadClass1();
testClass.Save();
var id = testClass.Id();
Parallel.For(0, 10, i =>
{
var test = Modl <ThreadClass1> .Get(id);
SetAndTest(test, 100);
SetAndTest(test, 200);
SetAndTest(test, 300);
SetAndTest(test, 400);
SetAndTest(test, 500);
});
}
public void SetIdExplicit()
{
var id = Guid.NewGuid();
Manufacturer m1 = Modl <Manufacturer> .New(id);
m1.Name = "Audi";
Assert.Equal(id, m1.ManufacturerID);
m1.Save();
Assert.Equal(id, m1.ManufacturerID);
var m2 = Modl <Manufacturer> .Get(m1.ManufacturerID.ToString());
AssertEqual(m1, m2);
m2.Save();
Assert.Equal(id, m2.ManufacturerID);
m2.Delete();
}
public void TestRaces()
{
Settings.GlobalSettings.InstanceSeparation = InstanceSeparation.Custom;
Settings.GlobalSettings.CustomInstanceSeparationDictionary = () => GetDictionary(Thread.CurrentThread.ManagedThreadId);
var testClass = new PerRequestThreadClass();
testClass.Save();
var id = testClass.Id();
Parallel.For(0, 10, i =>
{
var test = Modl <PerRequestThreadClass> .Get(id);
SetAndTest(test, 100);
SetAndTest(test, 200);
SetAndTest(test, 300);
SetAndTest(test, 400);
SetAndTest(test, 500);
});
}
public void GetAll()
{
foreach (var m in Modl <CustomIdStringClass> .GetAll())
{
m.Delete();
}
var modlList = Modl <CustomIdStringClass> .GetAll().ToList();
Assert.Equal(0, modlList.Count);
var modl = new CustomIdStringClass().Id(Guid.NewGuid().ToString()).Save();
var modl2 = new CustomIdStringClass().Id(Guid.NewGuid().ToString()).Save();
modlList = Modl <CustomIdStringClass> .GetAll().ToList();
Assert.Equal(2, modlList.Count);
Assert.True(modlList.Any(x => x.Id() == modl.Id()));
Assert.True(modlList.Any(x => x.Id() == modl2.Id()));
}
public void CreateNew()
{
var testClass = new EmptyClass();
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
testClass = Modl <EmptyClass> .New();
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
var id = Guid.NewGuid();
testClass = Modl <EmptyClass> .New(id);
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
Assert.True(id == testClass.Id());
}
public void GetAll()
{
foreach (var m in Modl <EmptyClass> .GetAll())
{
m.Delete();
}
var modlList = Modl <EmptyClass> .GetAll().ToList();
Assert.Equal(0, modlList.Count);
var modl = new EmptyClass().Save();
var modl2 = new EmptyClass().Save();
modlList = Modl <EmptyClass> .GetAll().ToList();
Assert.Equal(2, modlList.Count);
Assert.True(modlList.Any(x => x.Id() == modl.Id()));
Assert.True(modlList.Any(x => x.Id() == modl2.Id()));
}
public void Save()
{
var testClass = new AutomaticIdGuidClass();
var id = testClass.Id();
testClass.Save();
Assert.False(testClass.IsNew());
Assert.False(testClass.IsModified());
Assert.Equal(id, testClass.Id());
Assert.True(id == testClass.CustomId);
var loadedTestClass = Modl <AutomaticIdGuidClass> .Get(id);
Assert.True(id == loadedTestClass.CustomId);
Assert.Equal(id, loadedTestClass.Id());
Assert.True(id == loadedTestClass.CustomId);
Assert.False(loadedTestClass.IsNew());
Assert.False(loadedTestClass.IsModified());
Assert.Throws <InvalidIdException>(() => loadedTestClass.Id(Guid.NewGuid()));
}
public void CreateNew()
{
var testClass = new CustomIdIntClass();
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
testClass = Modl <CustomIdIntClass> .New();
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
var id = 3433;
testClass = Modl <CustomIdIntClass> .New(id);
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
Assert.True(id == testClass.Id());
Assert.Equal(id, testClass.CustomId);
}
public RNumdl(Modl modl, RSkeleton skeleton, Matl material, NumsbhNode meshNode, NuhlpbNode hlpbNode, Dictionary <string, Texture> textureByName)
{
Modl = modl;
Skeleton = skeleton;
Material = material;
TextureByName = textureByName;
if (meshNode != null)
{
RenderModel = meshNode.GetRenderModel(Skeleton);
}
if (Material != null)
{
UpdateMaterials();
}
if (Skeleton != null)
{
hlpbNode?.AddToRenderSkeleton(Skeleton);
UpdateBinds();
}
}
public RNumdl(Modl modl, RSkeleton skeleton, Matl matl, NumshbNode meshNode, NuhlpbNode hlpbNode, XmbNode modelXmb, XmbNode lodXmb,
Dictionary <string, RTexture> textureByName)
{
Modl = modl;
Skeleton = skeleton;
Matl = matl;
ModelXmb = modelXmb?.Xmb;
LodXmb = lodXmb?.Xmb;
TextureByName = textureByName;
if (meshNode != null)
{
RenderModel = meshNode.GetRenderModel(Skeleton);
}
UpdateMaterials(matl);
if (Skeleton != null)
{
hlpbNode?.AddToRenderSkeleton(Skeleton);
}
}
public void CreateNew()
{
var testClass = new CustomIdStringClass();
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
testClass = Modl <CustomIdStringClass> .New();
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
var id = Guid.NewGuid().ToString();
testClass = Modl <CustomIdStringClass> .New(id);
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
Assert.True(id == testClass.Id());
Assert.Equal(id, testClass.CustomId);
}
public void CreateNew()
{
var testClass = new AutomaticIdGuidClass();
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
testClass = Modl <AutomaticIdGuidClass> .New();
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
var id = Guid.NewGuid();
testClass = Modl <AutomaticIdGuidClass> .New(id);
Assert.True(testClass.IsNew());
Assert.False(testClass.IsModified());
Assert.True(testClass.Id().Equals(id));
Assert.True(id == testClass.Id());
Assert.Equal(id, testClass.CustomId);
}
public void CoreStuff()
{
Assert.Equal("Id", Modl <Car> .Definitions.IdProperty.PropertyName);
var car = Modl <Car> .New();
Assert.True(car.IsNew());
Assert.False(car.IsModified());
car.Name = "Audi";
Assert.True(car.IsNew());
Assert.True(car.IsModified());
car = new Car();
Assert.True(car.IsNew());
Assert.False(car.IsModified());
car.Name = "Audi";
Assert.True(car.IsNew());
Assert.True(car.IsModified());
car = new Car().Modl().Modl().Modl().Modl();
Assert.True(car.IsNew());
Assert.False(car.IsModified());
car.Name = "Audi";
Assert.True(car.IsNew());
Assert.True(car.IsModified());
//car.Save();
car = Modl <Car> .New();
car.Manufacturer.Val = new Manufacturer("BMW");
Assert.True(car.IsNew());
Assert.True(car.IsModified());
Assert.Equal("BMW", car.Manufacturer.Val.Name);
Assert.True(car.Manufacturer.Val.IsNew());
Assert.True(car.Manufacturer.Val.IsModified());
}
