public Partnership(IFamilyMember partner1, IFamilyMember partner2, bool isDivorced = false) : base(partner1)
{
Partner2 = partner2;
partner1.Partnerships.Add(this);
partner2.Partnerships.Add(this);
IsDivorced = isDivorced;
}
//Algorithm to be implemented in derived classes
public virtual void Execute(IFamilyTree tree, IFamilyMember source = null)
{
if (tree == null || tree.Root == null)
{
throw new ArgumentNullException("Tree cannot be null.");
}
this.tree = tree;
if (source != null)
{
if (!tree.MemberExists(source))
{
throw new NotInFamilyTreeException(source);
}
//prevent source from being inlaw. Inlaws do not have parents, which
//breaks traversal.
if (source.HasFact(FactType.InLaw))
{
throw new InvalidSourceException(source);
}
source.AddFact(FactType.XPosition, 0);
source.AddFact(FactType.XPosition, 0);
this.source = source;
}
Execute();
}
private void AddMember(IFamilyMember member)
{
if (MemberExists(member))
{
throw new DuplicateMemberException(member);
}
members.Add(member.Id, member);
}
public virtual int CalculateDiscount(IFamilyMember familyMember)
{
if (familyMember.FirstName.StartsWith("A", StringComparison.CurrentCultureIgnoreCase))
{
return(10);
}
return(0);
}
public ChildSubResolver_Unit()
{
successorMock = new Mock <INieceNephewSubResolver>();
resolver = new ChildSubResolver(successorMock.Object);
sourceMock = new Mock <IFamilyMember>();
sourceMock.Setup(x => x.GetFactValue <int>(FactType.XPosition)).Returns(0);
sourceMock.Setup(x => x.GetFactValue <int>(FactType.YPosition)).Returns(0);
source = sourceMock.Object;
}
public SpouseSubResolver_Unit()
{
successorMock = new Mock <ISiblingSubResolver>();
resolver = new SpouseSubResolver(successorMock.Object);
sourceMock = new Mock <IFamilyMember>();
sourceMock.Setup(x => x.GetFactValue <int>(FactType.XPosition)).Returns(0);
sourceMock.Setup(x => x.GetFactValue <int>(FactType.YPosition)).Returns(0);
source = sourceMock.Object;
}
private static void DisplayMemberWithFacts(IFamilyMember fm)
{
string facts = "";
foreach (var f in fm.GetFacts())
{
facts += string.Format("{0}: {1}; ", f.Type, f.Value);
}
Console.WriteLine(fm.Name + " - " + facts);
}
public override string Handle(IFamilyMember source, IFamilyMember target)
{
if (target.GetFactValue <int>(FactType.YPosition) == -1 && target.HasFact(FactType.Ancestor))
{
return(RelationshipType.Parent.ToString());
}
else
{
return(successor.Handle(source, target));
}
}
public IFamilyMember OtherPartner(IFamilyMember member)
{
if (member == Partner1)
{
return(Partner2);
}
else
{
return(Partner1);
}
}
public ParentSubResolver_Unit()
{
successorMock = new Mock <IAuntUncleSubResolver>();
resolver = new ParentSubResolver(successorMock.Object);
var sourceMock = new Mock <IFamilyMember>();
sourceMock.Setup(x => x.GetFactValue <int>(FactType.XPosition)).Returns(0);
sourceMock.Setup(x => x.GetFactValue <int>(FactType.YPosition)).Returns(0);
source = sourceMock.Object;
}
public override string Handle(IFamilyMember source, IFamilyMember target)
{
if (target.GetFactValue <int>(FactType.YPosition) == 1 && !target.HasFact(FactType.Ancestor))
{
return(target.Gender == Gender.Female ? RelationshipType.Niece.ToString() : RelationshipType.Nephew.ToString());
}
else
{
return(successor.Handle(source, target));
}
}
public override string Handle(IFamilyMember source, IFamilyMember target)
{
if (target.GetFactValue <int>(FactType.YPosition) < -1 && !target.HasFact(FactType.Ancestor))
{
return(string.Format("{0}{1}",
GetGreatness(target.GetFactValue <int>(FactType.YPosition)),
target.Gender == Gender.Female ? RelationshipType.Aunt.ToString() : RelationshipType.Uncle.ToString()));
}
else
{
return(successor.Handle(source, target));
}
}
public override string Handle(IFamilyMember source, IFamilyMember target)
{
var isEx = source.IsDivorcedFrom(target);
if (target.GetFactValue <int>(FactType.YPosition) == 0 && !source.IsMarriedTo(target) && !isEx)
{
return(RelationshipType.Sibling.ToString());
}
else
{
return(successor.Handle(source, target));
}
}
public override string Handle(IFamilyMember source, IFamilyMember target)
{
if (target.GetFactValue <int>(FactType.YPosition) > 1 && target.HasFact(FactType.Ancestor))
{
return(string.Format("{0}{1}",
GetGreatness(target.GetFactValue <int>(FactType.YPosition)),
RelationshipType.Grandchild));
}
else
{
return(successor.Handle(source, target));
}
}
public static void AddToFamily(this IFamilyMember item, IFamilyRegister register, bool isMale, string name)
{
IFamily family = null;
if (PreferExistingFamilyToNew)
{
IEnumerable <IFamily> candidateFamilies = register.Families.AsEnumerable().Where(fam => fam.Name == name);
if (PreferCreatingParentToChild)
{
if (isMale)
{
family = candidateFamilies.Where(fam => fam.Father == null).FirstOrDefault();
}
else
{
family = candidateFamilies.Where(fam => fam.Mother == null).FirstOrDefault();
}
}
family = family ?? candidateFamilies.FirstOrDefault();
}
if (family == null)
{
family = new Family {
Name = name
};
register.Families.Add(family);
}
if (isMale)
{
if (family.Father == null && PreferCreatingParentToChild)
{
family.Father = item;
}
else
{
family.Sons.Add(item);
}
}
else
{
if (family.Mother == null && PreferCreatingParentToChild)
{
family.Mother = item;
}
else
{
family.Daughters.Add(item);
}
}
}
public static void SetFullName(this IFamilyMember member, string newName)
{
var family = member.Parent as IFamily;
var separator = newName.IndexOf(", ");
var lastName = newName.Substring(0, separator);
var firstName = newName.Substring(separator + 2);
member.Name = firstName;
if (family != null && family.Name != lastName)
{
var isMale = member.FatherInverse != null || member.SonsInverse != null;
member.AddToFamily(family.FamiliesInverse, isMale, lastName);
}
}
public void Process(IFamilyTree tree, IFamilyMember source)
{
try
{
foreach (var alg in algorithms)
{
alg.Execute(tree, source);
}
}
catch (Exception)
{
tree.ClearMemberFacts();
throw;
}
}
public override string Handle(IFamilyMember source, IFamilyMember target)
{
var isEx = source.IsDivorcedFrom(target);
if (target.GetFactValue <int>(FactType.YPosition) == 0 && (source.IsMarriedTo(target) || isEx))
{
return(string.Format("{0}{1}",
isEx ? (RelationshipModifier.Ex.ToString() + "-") : string.Empty,
RelationshipType.Spouse.ToString()));
}
else
{
return(successor.Handle(source, target));
}
}
private IBenefitDeductionItem CreateBenefitItem(IFamilyMember familyMember)
{
return(new BenefitDeductionItem()
{
EmployeeId = _Employee.EmployeeId,
FamilyMemberId = familyMember.FamilyMemberId,
FirstName = familyMember.FirstName,
MiddleName = familyMember.MiddleName,
LastName = familyMember.LastName,
NumberOfPayPeriod = _Salary.NumberOfPayPeriod,
AnnualCostGross = 500.00m,
IsSpouse = familyMember.IsSpouse,
IsChild = familyMember.IsChild,
AnnualDiscountPerentage = CalculateDiscount(familyMember)
});
}
public void AddNonPartnershipChild(IFamilyMember parent, IFamilyMember child)
{
if (!MemberExists(parent))
{
throw new NotInFamilyTreeException(parent);
}
if (child.Parents != null)
{
throw new ExistingParentsReferenceException(child);
}
child.AddFact(FactType.HasSingleParent, true);
child.AddFact(FactType.Depth, (int)parent.Facts[FactType.Depth].Value + 1);
AddMember(child);
parent.NonPartnership.Children.Add(child);
child.Parents = parent.NonPartnership;
}
private static FamilyMemberDto Convert(IFamilyMember aFamilyMember)
{
if (aFamilyMember == null)
{
return(null);
}
var MapperConfig = new MapperConfiguration(cfg => {
cfg.CreateMap <IFamilyMember, FamilyMemberDto>();
});
IMapper iMapper = MapperConfig.CreateMapper();
var Results = iMapper.Map <IFamilyMember, FamilyMemberDto>(aFamilyMember);
return(Results);
}
private void Above(IChildBearingBase n, int x, int y)
{
// MarkedChildBearingBases.Add(n);
if (n is IParentship)
{
IFamilyMember nextParent = ((IParentship)n).Partner1;
//set relative position
nextParent.AddFact(FactType.XPosition, x);
nextParent.AddFact(FactType.YPosition, y);
nextParent.AddFact(FactType.Ancestor, true);
MarkedMembers.Add(nextParent);
//ensure that we recurse over non-inlaw partner
if (n is IPartnership)
{
var partnership = n as IPartnership;
var otherPartner = partnership.OtherPartner(nextParent);
//set relative position
otherPartner.AddFact(FactType.XPosition, x);
otherPartner.AddFact(FactType.YPosition, y);
otherPartner.AddFact(FactType.Ancestor, true);
MarkedMembers.Add(otherPartner);
if (nextParent.HasFact(FactType.InLaw))
{
nextParent = otherPartner;
}
}
//recurse through nextParent parentships/partnerships
foreach (IChildBearingBase p in nextParent)
{
if (!MarkedChildBearingBases.Contains(p))
{
Below(p, x, y + 1, y);
}
}
//move up
if (!MarkedChildBearingBases.Contains(nextParent.Parents))
{
Above(nextParent.Parents, x, y - 1);
}
}
}
public void SetRoot(IPartnership root, IFamilyMember inlaw)
{
this.Root = root;
if (root.Partner1 != null)
{
root.Partner1.AddFact(FactType.Depth, 0);
AddMember(root.Partner1);
}
if (root.Partner2 != null)
{
root.Partner2.AddFact(FactType.Depth, 0);
AddMember(root.Partner2);
}
inlaw.AddFact(FactType.InLaw, true);
AddPartnership(root);
}
public void AddChild(IPartnership partnership, IFamilyMember child)
{
if (partnership != null && !PartnershipExists(partnership))
{
throw new InvalidPartnershipException("Cannot add children to a partnership that does not exist.");
}
if (child.Parents != null)
{
throw new ExistingParentsReferenceException(child);
}
AddMember(child);
child.Parents = partnership;
partnership.Children.Add(child);
//Determine depth based on parents
int depth = (int)(partnership.Partner1.Facts[FactType.Depth]?.Value ?? partnership.Partner2.Facts[FactType.Depth]?.Value) + 1;
child.AddFact(FactType.Depth, depth);
}
public IPartnership AddPartnership(IFamilyMember partner1, IFamilyMember partner2, bool isDivorced = false)
{
var p1Exists = MemberExists(partner1);
var p2Exists = MemberExists(partner2);
if (!p1Exists || !p2Exists)
{
throw new NotInFamilyTreeException(!p1Exists ? partner1 : partner2);
}
var partnership = FamilyTreeFactory.CreatePartnership(partner1, partner2, isDivorced);
IFamilyMember blood = null,
inlaw = null;
inlaw = partner1.HasFact(FactType.InLaw) ? partner1 : partner2;
blood = partnership.OtherPartner(inlaw);
inlaw.AddFact(FactType.Depth, blood.Facts[FactType.Depth].Value);
AddPartnership(partnership);
return(partnership);
}
static void Family(IFamilyMember pobj)
{
pobj.Sorrow();
pobj.JoyOrLaughter();
}
public abstract string Handle(IFamilyMember source, IFamilyMember target);
public bool IsMarriedTo(IFamilyMember member)
{
return(Partnerships.Exists(x => x.OtherPartner(this) == member && x.IsDivorced == false));
}
public abstract string Execute(IFamilyMember source, IFamilyMember target);
public bool IsDivorcedFrom(IFamilyMember member)
{
return(Partnerships.Exists(x => x.OtherPartner(this) == member && x.IsDivorced == true));
}
