public override bool IsValid(params ILegalPerson[] persons)
{
var defendant = this.Defendant(persons);
if (defendant == null)
{
return(false);
}
var title = defendant.GetLegalPersonTypeName();
//threats for what is honestly owed is not illegal
if (SubjectProperty?.IsEntitledTo(defendant) ?? false)
{
AddReasonEntry($"{title} {defendant.Name}, is entitled to " +
$"{SubjectProperty?.GetType().Name} " +
$"named '{SubjectProperty?.Name}'");
return(false);
}
if (!base.IsValid(persons))
{
return(false);
}
var threatening = Threatening ?? new ByThreatening();
if (!threatening.IsValid(persons))
{
AddReasonEntryRange(threatening.GetReasonEntries());
return(false);
}
return(true);
}
public SentimentAlert(SubjectProperty subjectProperty, Operator @operator, int value, Subject subject)
{
SubjectProperty = subjectProperty;
Operator = @operator;
this.Value = value;
Subject = subject;
}
public void ObservableTest()
{
var property = new SubjectProperty <int>();
var observer = new TestObserver <int>();
property.Subscribe(observer);
Assert.AreEqual(0, observer.OnNextCount);
property.Value = 10;
Assert.AreEqual(1, observer.OnNextCount);
Assert.AreEqual(10, observer.OnNextLastValue);
property.Value = 20;
Assert.AreEqual(2, observer.OnNextCount);
Assert.AreEqual(20, observer.OnNextLastValue);
var observer2 = new TestObserver <int>();
property.Subscribe(observer2);
Assert.AreEqual(0, observer2.OnNextCount);
property.Value = 30;
Assert.AreEqual(1, observer2.OnNextCount);
Assert.AreEqual(30, observer2.OnNextLastValue);
Assert.AreEqual(3, observer.OnNextCount);
Assert.AreEqual(30, observer.OnNextLastValue);
}
/// <summary>
/// <![CDATA[ The property must be taken from the victim's person or presensece - meaning it was under the victims control. ]]>
/// </summary>
/// <param name="persons"></param>
/// <returns></returns>
protected virtual bool FromVictimPersonOrPresence(ILegalPerson[] persons)
{
if (persons == null || !persons.Any())
{
return(false);
}
var victims = persons.Victims().ToList();
if (!victims.Any())
{
AddReasonEntry(
$"there are not victims among persons {string.Join(",", LegalPerson.GetNames(persons))}");
return(false);
}
var possess = persons.FirstOrDefault(p => SubjectProperty.IsInPossessionOf(p));
foreach (var victim in victims)
{
if (possess == null || possess.Equals(victim) || ReferenceEquals(possess, victim))
{
return(true);
}
AddReasonEntry($"{victim.GetLegalPersonTypeName()} {victim.Name}, " +
$"is not in possession of {possess.GetType().Name} '{possess.Name}'");
}
return(false);
}
public override bool IsValid(params ILegalPerson[] persons)
{
var defendant = this.Defendant(persons);
if (defendant == null)
{
return(false);
}
var title = defendant.GetLegalPersonTypeName();
if (SubjectProperty == null)
{
AddReasonEntry($"{title} {defendant.Name}, {nameof(SubjectProperty)} is null");
return(false);
}
if (SubjectProperty.IsEntitledTo(defendant))
{
AddReasonEntry($"{title} {defendant.Name}, is the owner of property {SubjectProperty}");
return(false);
}
if (!WithoutConsent(persons))
{
return(false);
}
if (!PossessOrEntitle(persons))
{
return(false);
}
return(true);
}
public override bool IsValid(params ILegalPerson[] persons)
{
var defendant = this.Defendant(persons);
if (defendant == null)
{
return(false);
}
var title = defendant.GetLegalPersonTypeName();
if (!WithoutConsent(persons))
{
return(false);
}
if (PropertyOwnerIsSubjectPerson(persons))
{
return(false);
}
if (!IsCauseOfDamage(defendant))
{
AddReasonEntry($"{title} {defendant.Name}, {nameof(IsCauseOfDamage)} is false");
return(false);
}
if (!IsDamaged(SubjectProperty))
{
AddReasonEntry($"property {SubjectProperty?.GetType().Name}, '{SubjectProperty?.Name}', " +
$"{nameof(IsDamaged)} is false");
return(false);
}
return(true);
}
public void ObserverTest()
{
var property = new SubjectProperty <int>();
Assert.AreEqual(0, property.Value);
Observable.Return(1).Subscribe(property);
Assert.AreEqual(1, property.Value);
Observable.Return(2).Subscribe(property);
Assert.AreEqual(2, property.Value);
}
/// <summary>
/// Tests that <see cref="Consent"/> was not given by <see cref="SubjectProperty"/> owner
/// </summary>
/// <param name="persons"></param>
/// <returns></returns>
protected virtual bool WithoutConsent(ILegalPerson[] persons)
{
//is all the dependencies present
if (SubjectProperty?.IsEntitledTo == null || Consent == null ||
persons == null ||
!persons.Any())
{
return(true);
}
//if all the people are licensed or invited then consent is implied by the use of type (label)
if (persons.Where(v => !SubjectProperty.IsEntitledTo(v)).All(p => p is ILicensee))
{
AddReasonEntry($"all non-owner persons implement {nameof(ILicensee)} interface type");
return(false);
}
//did the caller pass in any IVictim types
var victims = persons.Victims().ToList();
if (!victims.Any())
{
return(true);
}
//is any of our victims also the owner of the property
var ownerVictims = victims.Where(v => SubjectProperty.IsEntitledTo(v)).ToList();
if (!ownerVictims.Any())
{
AddReasonEntry($"of {nameof(IVictim)}s named " +
$"{string.Join(",", victims.Select(v => v.Name))}, " +
$"none are found {nameof(SubjectProperty.IsEntitledTo)} as true");
return(true);
}
foreach (var ownerVictim in ownerVictims)
{
var validConsent = Consent.IsValid(ownerVictim);
AddReasonEntryRange(Consent.GetReasonEntries());
//did the owner victim in fact give consent
if (validConsent != ConsentExpectedAs)
{
AddReasonEntry($"owner-{ownerVictim.GetLegalPersonTypeName()} {ownerVictim.Name}, " +
$"{nameof(Consent)} {nameof(IsValid)} " +
$"is {validConsent}, it was expected to be {ConsentExpectedAs} " +
$"for property {SubjectProperty.Name}");
return(false);
}
}
return(true);
}
public void HasValueTest()
{
var property1 = new SubjectProperty <int>();
Assert.AreEqual(false, property1.HasValue);
property1.Value = 1;
Assert.AreEqual(true, property1.HasValue);
var property2 = new SubjectProperty <int>();
Assert.AreEqual(false, property2.HasValue);
property2.OnNext(2);
Assert.AreEqual(true, property2.HasValue);
}
public override bool IsValid(params ILegalPerson[] persons)
{
if (!base.IsValid(persons))
{
return(false);
}
var defendant = this.Defendant(persons);
if (defendant == null)
{
return(false);
}
var title = defendant.GetLegalPersonTypeName();
var ifi = IsFalseImpression(defendant);
var ipot = IsPreventionOfTruth(defendant);
var iftc = IsFailureToCorrect(defendant);
var iuli = IsUndisclosedLegalImpediment(defendant);
if (new[] { ifi, ipot, iftc, iuli }.All(p => p == false))
{
AddReasonEntry($"{title} {defendant.Name}, {nameof(IsFalseImpression)} is {ifi}");
AddReasonEntry($"{title} {defendant.Name}, {nameof(IsPreventionOfTruth)} is {ipot}");
AddReasonEntry($"{title} {defendant.Name}, {nameof(IsFailureToCorrect)} is {iftc}");
AddReasonEntry($"{title} {defendant.Name}, {nameof(IsUndisclosedLegalImpediment)} is {iuli}");
return(false);
}
var isPossess = SubjectProperty.IsInPossessionOf(defendant);
var isTitle = SubjectProperty.IsEntitledTo(defendant);
IsLarcenyByTrick = isPossess && !isTitle;
IsFalsePretense = isPossess && isTitle;
if (IsLarcenyByTrick)
{
AddReasonEntry($"{title} {defendant.Name}, {nameof(IsLarcenyByTrick)} is true");
}
if (IsFalsePretense)
{
AddReasonEntry($"{title} {defendant.Name}, {nameof(IsFalsePretense)} is true");
}
return(true);
}
public override bool IsValid(params ILegalPerson[] persons)
{
var lessor = this.Lessor(persons);
var lessee = this.Lessee(persons);
if (lessor == null || lessee == null)
{
return(false);
}
var orTitle = lessor.GetLegalPersonTypeName();
var eeTitle = lessee.GetLegalPersonTypeName();
//landlord has no right to evict
if (!IsLeaseExpired && !IsBreachLeaseCondition(lessee) && !IsVacated(lessee))
{
AddReasonEntry($"{orTitle} {lessor.Name} and {eeTitle} {lessee.Name}, {nameof(IsLeaseExpired)}, " +
$"{nameof(IsBreachLeaseCondition)} and {nameof(IsVacated)} are all false");
return(false);
}
//lessor isn't the landlord
if (!SubjectProperty.IsEntitledTo(lessor))
{
AddReasonEntry($"{orTitle} {lessor.Name}, {nameof(SubjectProperty)} {nameof(SubjectProperty.IsEntitledTo)} is false");
return(false);
}
var isHome = IsResidenceHome(SubjectProperty);
var isPeaceful = !isHome?IsPeaceableSelfHelpReentry(lessor) : IsJudicialProcessReentry(lessor);
if (!isPeaceful)
{
var kindOfReentry = !isHome?nameof(IsPeaceableSelfHelpReentry) : nameof(IsJudicialProcessReentry);
AddReasonEntry($"{orTitle} {lessor.Name}, {kindOfReentry} is false");
return(false);
}
return(base.IsValid(persons));
}
protected virtual bool InPossessionOfDefendant(ILegalPerson[] persons)
{
var defendant = this.Defendant(persons);
if (defendant == null)
{
return(false);
}
var title = defendant.GetLegalPersonTypeName();
var possess = persons.FirstOrDefault(p => SubjectProperty.IsInPossessionOf(p));
if (!defendant.Equals(possess) && !ReferenceEquals(defendant, possess))
{
AddReasonEntry($"{title} {defendant.Name}, does not " +
$"possess {SubjectProperty?.GetType().Name} " +
$"named {SubjectProperty?.Name} - it is possessed " +
$"by {possess?.Name}");
return(false);
}
return(true);
}
set => SetValue(SubjectProperty, value);
public override bool IsValid(params ILegalPerson[] persons)
{
if (SubjectProperty?.IsEntitledTo == null)
{
AddReasonEntry($"{nameof(SubjectProperty)} {nameof(SubjectProperty.IsEntitledTo)} is unassigned");
return(false);
}
var subj = GetSubjectPerson(persons);
if (subj == null)
{
AddReasonEntry($"{nameof(GetSubjectPerson)} returned nothing");
return(false);
}
var title = subj.GetLegalPersonTypeName();
if (SubjectProperty.IsEntitledTo != null && !SubjectProperty.IsEntitledTo(subj))
{
AddReasonEntry($"property named '{SubjectProperty.Name}' is " +
$"not {nameof(SubjectProperty.IsEntitledTo)} {title} {subj.Name} ");
return(false);
}
if (!IsLocatedWhereChildrenLikelyAre(SubjectProperty))
{
AddReasonEntry($"property '{SubjectProperty.Name}', {nameof(IsLocatedWhereChildrenLikelyAre)} is false");
return(false);
}
if (!IsDangerToChildren(SubjectProperty))
{
AddReasonEntry($"property '{SubjectProperty.Name}', {nameof(IsDangerToChildren)} is false");
return(false);
}
if (!IsDangerOutweighUse(SubjectProperty))
{
AddReasonEntry($"property '{SubjectProperty.Name}', {nameof(IsDangerOutweighUse)} is false");
return(false);
}
if (!IsArtificialCondition(SubjectProperty))
{
AddReasonEntry($"property '{SubjectProperty.Name}', {nameof(IsArtificialCondition)} is false");
return(false);
}
if (IsChildObliviousToDanger != null)
{
var children = persons.Where(p => p is IChild).Cast <IChild>().ToList();
foreach (var child in children)
{
if (!IsChildObliviousToDanger(child))
{
AddReasonEntry($"{child.GetLegalPersonTypeName()} {child.Name}, {nameof(IsChildObliviousToDanger)} is false");
return(false);
}
}
}
if (!IsOwnerFailMitigateDanger(subj))
{
AddReasonEntry($"{title} {subj.Name}, {nameof(IsOwnerFailMitigateDanger)} is false");
return(false);
}
return(true);
}
