public BookResult readControl([FromBody] CompositeObject compositeObject)
{
Book book = compositeObject.book;
User user = compositeObject.user;
return(bookOperation.readControl(user, book));
}
public CompositeObject Find(Guid id)
{
CompositeObject cachedObject = null;
Trace.WriteLine("InMemoryCompositeObjectCache.Find: locking localStorage");
lock (localStorage)
{
if (localStorage.ContainsKey(id))
{
cachedObject = localStorage[id];
}
}
Trace.WriteLine("InMemoryCompositeObjectCache.Find: localStorage lock released");
if (cachedObject != null)
{
return(cachedObject);
}
object lockHandle;
cachedObject = FindAndLock(id, lockTimespan, out lockHandle);
Unlock(id, lockHandle);
return(cachedObject);
}
public void Detach(CompositeObject obj)
{
foreach (var setter in Setters)
{
setter.UnsetValue(obj);
}
}
public UserOperationResult readListUpdate([FromBody] CompositeObject compositeObject)
{
User user = compositeObject.user;
Book book = compositeObject.book;
return(userOperation.readListUpdate(user, book));
}
public override void Changed <T>(CompositeObject obj, T oldVal, T newVal)
{
if (EqualityComparer <T> .Default.Equals(oldVal, newVal))
{
return;
}
if (obj is not Visual v)
{
throw new InvalidOperationException();
}
if (Options.HasFlag(PropertyOptions.AffectsMeaure))
{
v.InvalidateMeasure();
}
if (Options.HasFlag(PropertyOptions.AffectsArrange))
{
v.InvalidateArrange();
}
if (Options.HasFlag(PropertyOptions.AffectsRender))
{
v.Invalidate();
}
if (Options.HasFlag(PropertyOptions.AffectsParentRender))
{
v.VisualParent?.Invalidate();
}
base.Changed(obj, oldVal, newVal);
}
public BookResult incrementLikeCount([FromBody] CompositeObject compositeObject)
{
Book book = compositeObject.book;
User user = compositeObject.user;
return(bookOperation.incrementLikeCount(book, user));
}
public void NotSupportedValueException()
{
CompositeObject model = new CompositeObject(new SingleModel("Doe"));
string json = formatter.Serialize(model);
Assert.IsNotNull(json);
}
public void MainTest()
{
// Persisting
using (var session = Domain.OpenSession()) {
using (var t = session.OpenTransaction()) {
var c = new Container();
var co = new CompositeObject();
co.Name = "SomeName";
co.Value = 12d;
c.CompositeObject = co;
Assert.IsNotNull(c.CompositeObject);
Assert.IsNotNull(c.CompositeObjectHandler);
Assert.AreEqual(co.Name, c.CompositeObject.Name);
Assert.AreEqual(co.Value, c.CompositeObject.Value);
Assert.AreEqual(co.Name, c.CompositeObjectHandler.Name);
Assert.AreEqual(co.Value, c.CompositeObjectHandler.Value);
t.Complete();
}
}
// Fetching
using (var session = Domain.OpenSession()) {
using (var t = session.OpenTransaction()) {
var c = session.Query.All <Container>().First();
Assert.IsNotNull(c.CompositeObject);
Assert.IsNotNull(c.CompositeObjectHandler);
var co = c.CompositeObject;
Assert.AreEqual(co.Name, c.CompositeObject.Name);
Assert.AreEqual(co.Value, c.CompositeObject.Value);
Assert.AreEqual(co.Name, c.CompositeObjectHandler.Name);
Assert.AreEqual(co.Value, c.CompositeObjectHandler.Value);
// Rollback
}
}
// Querying
using (var session = Domain.OpenSession()) {
using (var t = session.OpenTransaction()) {
var c = session.Query.All <Container>().Where(i => i.CompositeObject.Name == "SomeName").FirstOrDefault();
Assert.IsNotNull(c);
Assert.AreEqual("SomeName", c.CompositeObject.Name);
// Rollback
}
}
}
public void Should_return_0_for_both_member_is_null()
{
var instance0 = new CompositeObject {
Value = null
};
var instance1 = new CompositeObject {
Value = null
};
instance0.CompareTo(instance1).Should().Be(0);
}
public void Should_return_1_for_other_member_is_null()
{
var instance0 = new CompositeObject {
Value = new CompositeChildValue {
Value1 = 1
}
};
var instance1 = new CompositeObject {
Value = null
};
instance0.CompareTo(instance1).Should().Be(1);
}
public void Should_return_minus1_for_self_member_is_null()
{
var instance0 = new CompositeObject {
Value = null
};
var instance1 = new CompositeObject {
Value = new CompositeChildValue {
Value1 = 2
}
};
instance0.CompareTo(instance1).Should().Be(-1);
}
public void UnsetValue(CompositeObject obj)
{
if (_wasSet)
{
var propToUnset = PropertyManager.Instance.GetProperties(obj.GetType())
.FirstOrDefault(p => p.PropName == Property);
obj.SetValue(propToUnset, Value);
_oldValue = CompositeObjectProperty.UnsetValue;
_wasSet = false;
}
}
public bool Matches(CompositeObject obj)
{
if (_typeName is not null)
{
if (!_classes.Any() || obj is not IStylable stylable)
{
return(obj.GetType().Name == _typeName);
}
return(MatchClasses(stylable));
}
return(false);
}
public void CompositeObject_Initialization()
{
var compositeObjectId = new Guid("3C7BEEC3-9418-49CF-9B63-6309EB9154AA");
var changeSetId1 = new Guid("E84DDA60-F418-4F11-91DE-773CEE47B2C8");
var timeStamp1 = DateTimeOffset.UtcNow.Ticks;
var dateTime1 = DateTimeOffset.UtcNow.Ticks;
var compositeObjectAttributeValues1 = new[]
{
attributeValueFactory.Create(() => TestCompositeBusinessObjectStatic.Int32Property, CompositeObjectTestData.TestValues.Int32Value),
attributeValueFactory.Create(() => TestCompositeBusinessObjectStatic.StringProperty, CompositeObjectTestData.TestValues.StringValue)
};
var simpleObjectId = new Guid("25E5692F-2262-4013-B668-15EA40F83A9B");
var simpleObjectChangeSetId1 = new Guid("89E51585-1FF9-458F-9C9D-E66B3EB1F8EC");
var simpleObjectAttributeValues1 = new[]
{
attributeValueFactory.Create(() => TestCompositeBusinessObjectStatic.Int64Property, CompositeObjectTestData.TestValues.Int64Value),
attributeValueFactory.Create(() => TestCompositeBusinessObjectStatic.EnumProperty, CompositeObjectTestData.TestValues.EnumValue)
};
var simpleObjectChangeSet1 = new CreateSimpleObjectChangeSet(simpleObjectChangeSetId1, simpleObjectId, simpleObjectAttributeValues1, simpleObjectTypeId, null);
SimpleObjectChangeSet[] simpleObjectChangeSets = { simpleObjectChangeSet1 };
var changeSet1 = new CreateCompositeObjectChangeSet(compositeObjectId, changeSetId1, timeStamp1, compositeObjectTypeId,
simpleObjectChangeSets, compositeObjectAttributeValues1, userId, dateTime1);
var changeSets = new[] { changeSet1 };
var compositeObject = new CompositeObject(changeSets, businessObjectDefinitionProvider);
Assert.AreEqual(compositeObjectTypeId, compositeObject.CompositeObjectTypeId);
Assert.AreEqual(compositeObjectId, compositeObject.Id);
Assert.AreEqual(changeSetId1, compositeObject.Revision);
Assert.AreEqual(new DateTimeOffset(dateTime1, new TimeSpan(0)), compositeObject.LastModified);
Assert.AreEqual(compositeObjectAttributeValues1.Length, compositeObject.Attributes.Count);
Assert.AreEqual(CompositeObjectTestData.TestValues.Int32Value, compositeObject.Attribute(() => TestCompositeBusinessObjectStatic.Int32Property));
Assert.AreEqual(CompositeObjectTestData.TestValues.StringValue, compositeObject.Attribute(() => TestCompositeBusinessObjectStatic.StringProperty));
Assert.AreEqual(1, compositeObject.SimpleObjects.Count);
var simpleObject = compositeObject.SimpleObjects[simpleObjectId];
Assert.AreEqual(simpleObjectTypeId, simpleObject.SimpleObjectTypeId);
Assert.AreEqual(simpleObjectId, simpleObject.Id);
Assert.AreEqual(changeSetId1, simpleObject.Revision);
Assert.AreEqual(simpleObjectAttributeValues1.Length, simpleObject.Attributes.Count);
Assert.AreEqual(CompositeObjectTestData.TestValues.Int64Value, simpleObject.Attribute(() => TestCompositeBusinessObjectStatic.Int64Property));
Assert.AreEqual(CompositeObjectTestData.TestValues.EnumValue, simpleObject.Attribute(() => TestCompositeBusinessObjectStatic.EnumProperty));
}
public void MemberWiseDeepClone_Test_2()
{
//Arrange
AirlineCompany airCompany = new AirlineCompany("Momola Airlines", 12555, "here_must_be_64base_string_immage", "fhf53dg5525", "aAS23", 12565);
Administrator admin = new Administrator("John", "65df56dfd56f", 7254, airCompany);
Customer customer = new Customer("Nadgad", "Konstantinski", "not a house nor a street", "22333222356", "355-353-530", "image_image_where_are_you", "sdf54sf54sdf", 4587);
Flight flight = new Flight {
AIRLINECOMPANY_ID = 1, DEPARTURE_TIME = DateTime.Now, DESTINATION_COUNTRY_CODE = 123, ID = 21, IDENTIFIER = "sg546rfgv54fgv54", LANDING_TIME = DateTime.Now.AddDays(5).AddHours(8).AddMinutes(55), ORIGIN_COUNTRY_CODE = 446, REMAINING_TICKETS = 568
};
Country country = new Country {
COUNTRY_NAME = "Bolivia", ID = 658, IDENTIFIER = "fgb52df54dg54dgv", admin = admin
};
CheckingObject checkingObj = new CheckingObject(customer, flight, country);
CompositeObject original = new CompositeObject(admin, airCompany, checkingObj);
checkingObj.composite = original;
original.checking = checkingObj;
//Act
CompositeObject clonedObject = original.MemberWiseDeepClone();
var deepCloned = clonedObject;
var shallowCloned = original.SimpleMemberWiseClone();
//Assert
Assert.IsNotNull(deepCloned);
Assert.IsFalse(ReferenceEquals(original, deepCloned));
Assert.That(original.AirCompany == deepCloned.AirCompany);
Assert.AreEqual(original.AirCompany, deepCloned.AirCompany);
string str = string.Empty;
var originalFields = original.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Instance);
var deepClonedFields = deepCloned.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Instance);
Assert.AreEqual(originalFields.Length, deepClonedFields.Length);
for (int i = 0; i < originalFields.Length; i++)
{
str += $"{originalFields[i].Name}: {originalFields[i].GetValue(original)}";
//Assert.AreEqual(originalFields[i].GetValue(original), deepClonedFields[i].GetValue(deepCloned));
}
var originalAdministrator = original.GetType().GetField("_administrator", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Instance).GetValue(original);
var deepClonedAdministrator = deepCloned.GetType().GetField("_administrator", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Instance).GetValue(deepCloned);
Assert.AreEqual(originalAdministrator, deepClonedAdministrator);
Assert.AreEqual(original.CheckingObject.composite.AirCompany, deepCloned.CheckingObject.composite.AirCompany);
//Failing the test
//Assert.AreEqual(original.CheckingObject, deepCloned.CheckingObject);
}
public bool TryAttach(CompositeObject obj)
{
bool attached = false;
var props = PropertyManager.Instance.GetProperties(obj.GetType());
foreach (var setter in Setters.Where(s => props.Any(p => p.PropName == s.Property)))
{
setter.SetValue(obj);
attached = true;
}
return(attached);
}
public void Should_return_CompareTo_result_for_type_with_subclass_of_generated_code_as_member()
{
var instance0 = new CompositeObject {
Value = new CompositeChildValue {
Value1 = 1
}
};
var instance1 = new CompositeObject {
Value = new CompositeChildValue {
Value1 = 2
}
};
instance0.CompareTo(instance1)
.Should().Be(instance0.Value.Value1.CompareTo(instance1.Value.Value1));
}
public void SetValue(CompositeObject owner,
CompositeObjectProperty prop,
IPropertyValue value)
{
Dictionary <CompositeObjectProperty, IPropertyValue> props;
if (!_valueStorage.TryGetValue(owner, out props))
{
props = new Dictionary <CompositeObjectProperty, IPropertyValue>();
_valueStorage.Add(owner, props);
}
var oldValue = props[prop];
props[prop] = value;
oldValue.OnDetached(owner, prop);
value.OnAttached(owner, prop);
}
internal static IReadOnlyCollection <PriorityStyle> GetStylesForElement(this Widget owner,
CompositeObject obj)
{
int i = 0;
var styles = owner.Styles.Where(s => s.Selector.Matches(obj))
.Select(s => new PriorityStyle(s, i));
owner.TraverseTop <Widget>(w =>
{
i++;
styles = styles.Concat(w.Styles.Where(s => s.Selector.Matches(obj))
.Select(s => new PriorityStyle(s, i)));
return(false);
});
return(styles.ToArray());
}
public void SetValue(CompositeObject obj)
{
var propToSet = PropertyManager.Instance.GetProperties(obj.GetType())
.FirstOrDefault(p => p.PropName == Property);
if (propToSet is null)
{
throw new Exception();
}
_wasSet = obj.IsPropertySet(propToSet);
if (_wasSet)
{
_oldValue = obj.GetValue <IPropertyValue>(propToSet);
}
obj.SetValue(propToSet, Value);
}
public T Coerce <T>(CompositeObject obj, T value)
{
if (_coerceFunc is null)
{
return(value);
}
if (obj is TOwner owner &&
value is TValue val)
{
TValue coerced = _coerceFunc.Invoke(owner, val);
if (coerced is T converted)
{
return(converted);
}
}
throw new InvalidCastException();
}
public virtual void Changed <T>(CompositeObject obj, T oldVal, T newVal)
{
if (_changeValueFunc is null ||
EqualityComparer <T> .Default.Equals(oldVal, newVal))
{
return;
}
if (obj is TOwner owner)
{
//It was fun but it should be simplified...
TValue oldValue = GetValue <TValue, T>(oldVal);
TValue newValue = GetValue <TValue, T>(newVal);
_changeValueFunc.Invoke(owner, oldValue, newValue);
return;
}
throw new InvalidCastException();
}
public CompositeObject Get(Guid ownerId, Guid compositeObjectId)
{
var cachedObject = compositeObjectCache.Find(compositeObjectId);
if (cachedObject != null)
{
return(cachedObject);
}
object lockHandle;
compositeObjectCache.FindAndLock(compositeObjectId, lockTimespan, out lockHandle);
var changeSets = changeSetStorage.GetChangeSets(compositeObjectId);
var compositeObject = new CompositeObject(changeSets, businessObjectDefinitionProvider);
compositeObjectCache.PutAndUnlock(compositeObject, lockHandle);
return(compositeObject);
}
public void PutAndUnlock(CompositeObject compositeObject, object lockHandle)
{
var utcNow = DateTimeOffset.UtcNow;
Trace.WriteLine("InMemoryCompositeObjectCache.PutAndUnlock: locking globalStorage");
lock (globalStorage){
if (!globalStorage.ContainsKey(compositeObject.Id))
{
throw new ArgumentException("There is no such CompositeObject in cache");
}
var cacheObject = globalStorage[compositeObject.Id];
if (cacheObject.LockHandle != (Guid)lockHandle)
{
throw new ArgumentException("Incorrect lock");
}
if (cacheObject.ExpirationDateTime < utcNow)
{
throw new ArgumentException("Lock expired");
}
var bytes = compositeObject.Serialize();
globalStorage[compositeObject.Id] = new CacheObject(bytes, null, null);
Trace.WriteLine("InMemoryCompositeObjectCache.PutAndUnlock: locking localStorage");
lock (localStorage)
{
localStorage[compositeObject.Id] = compositeObject;
}
Trace.WriteLine("InMemoryCompositeObjectCache.PutAndUnlock: localStorage lock released");
}
Trace.WriteLine("InMemoryCompositeObjectCache.PutAndUnlock: globalStorage lock released");
}
public void OnDetached(CompositeObject owner, CompositeObjectProperty prop)
{
Detached?.Invoke(owner, prop);
}
public void OnChanged(CompositeObject owner, CompositeObjectProperty prop)
{
Changed?.Invoke(owner, prop);
}
public TestClient(CompositeObject composite, TestClientOptions options)
{
Composite = composite;
Options = options;
}
public TestClient(Uri uri, CompositeObject composite, TestClientOptions options)
{
Uri = uri;
Composite = composite;
Options = options;
}
public IPropertyValue GetValue(CompositeObject owner,
CompositeObjectProperty prop)
{
return(_valueStorage[owner][prop]);
}
public bool IsSet(CompositeObject obj,
CompositeObjectProperty prop)
{
return(_valueStorage[obj][prop] is not UnsetValue);
}
