private async void WaitForMessage(NetworkStream stream)
{
while (true)
{
var message = await NetworkHelper.ReceiveMessage(stream).ConfigureAwait(false);
message.LastPlayBy = LastPlayerPlayed;
if (message.MessageType == NetworkHelper.MessageType.Pass)
{
if ((message.Player !.PlayerNumber + 1) % 4 == LastPlayerPlayed)
{
RuleHandler.FreeTurn();
}
foreach (var clientStream in ClientStreams)
{
NetworkHelper.SendMessage(clientStream, message);
}
}
else
{
var validPlay = RuleHandler.IsValidPlay(message.Hand !, Pile);
if (validPlay)
{
Pile = message.Hand;
foreach (var clientStream in ClientStreams)
{
NetworkHelper.SendMessage(clientStream, message);
}
LastPlayerPlayed = message.Player !.PlayerNumber;
}
}
}
}
public RuleMethod(object target, RuleHandler handler, string propertyName)
{
_target = target;
_handler = handler;
_args = new RuleArgs(propertyName);
_ruleName = _handler.Method.Name + "!" + _args.ToString();
}
/// <summary>
/// Adds a lambda property level rule to business rules.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="businessRules">Business rules instance.</param>
/// <param name="ruleHandler">Rule method.</param>
/// <param name="primaryProperty">Primary property.</param>
/// <param name="ruleArgs">Rule args object.</param>
/// <param name="priority">Priority.</param>
//[Obsolete("For migration of older apps to Csla 4.x only")]
public static void AddRule <T>(this BusinessRules businessRules, RuleHandler <T, RuleArgs> ruleHandler, Csla.Core.IPropertyInfo primaryProperty, RuleArgs ruleArgs, int priority) where T : BusinessBase <T>
{
var rule = new Csla.Rules.CommonRules.Lambda(primaryProperty, (o) =>
{
var target = (T)o.Target;
using (new ObjectAccessor().BypassPropertyChecks(target))
{
if (!ruleHandler(target, ruleArgs))
{
o.Results.Add(new RuleResult(o.Rule.RuleName, o.Rule.PrimaryProperty, ruleArgs.Description)
{
Severity = ruleArgs.Severity, StopProcessing = ruleArgs.StopProcessing
});
}
else if (ruleArgs.StopProcessing)
{
o.AddSuccessResult(true);
}
else
{
o.AddSuccessResult(false);
}
ruleArgs.StopProcessing = false;
}
});
#if NETFX_CORE
var methodName = Guid.NewGuid().ToString();
#else
var methodName = ruleHandler.Method.ToString();
#endif
rule.AddQueryParameter("r", Convert.ToBase64String(Encoding.Unicode.GetBytes(methodName)));
rule.Priority = priority;
businessRules.AddRule(rule);
}
/// <summary>
/// Creates a shared or instance validator
/// </summary>
public Validator(RuleHandler ruleHandler, RuleDescriptorBase e, RuleType ruleType)
{
_ruleHandler = ruleHandler;
this.RuleBase = e;
this.RuleType = ruleType;
switch (ruleType)
{
case RuleType.Instance:
this.RuleName = _INSTANCE + this.RuleName;
break;
case RuleType.Shared:
break;
case RuleType.Attribute:
this.RuleName = String.Format(_RULE_FORMATSTRING, ruleHandler.Method.Name, e.PropertyName, (Guid.NewGuid()));
break;
default:
throw new ArgumentException(Resources.Validator_Validator_RuleType_not_programmed_yet, "RuleType");
}
}
public RuleMethod(object target, RuleHandler handler, RuleArgs args)
{
_target = target;
_handler = handler;
_args = args;
_ruleName = _handler.Method.Name + "!" + _args.ToString();
}
/// <summary>
/// Creates a shared or instance validator
/// </summary>
/// <param name="ruleHandler">The rule handler.</param>
/// <param name="ruleDescriptor">The rule descriptor.</param>
/// <param name="ruleType"><see cref="RuleType" /> of the rule.</param>
/// <exception cref="ArgumentNullException">
/// Either ruleHandler or ruleDescriptor is null
/// </exception>
/// <exception cref="InvalidEnumArgumentException">ruleType is not a member of RuleType enum.</exception>
public Validator(RuleHandler ruleHandler, RuleDescriptorBase ruleDescriptor, RuleType ruleType)
{
if (ruleHandler == null)
{
throw new ArgumentNullException(nameof(ruleHandler));
}
if (ruleDescriptor == null)
{
throw new ArgumentNullException(nameof(ruleDescriptor));
}
if (!Enum.IsDefined(typeof(RuleType), ruleType))
{
throw new InvalidEnumArgumentException(nameof(ruleType), (Int32)ruleType, typeof(RuleType));
}
_ruleHandler = ruleHandler;
this.RuleBase = ruleDescriptor;
this.RuleType = ruleType;
switch (ruleType)
{
case RuleType.Instance:
this.RuleName = $"rule://Instance-{ruleHandler.GetMethodInfo().Name}/{ruleDescriptor.PropertyName}-{(Guid.NewGuid())}";
break;
case RuleType.Shared:
case RuleType.Attribute:
this.RuleName = $"rule://{ruleHandler.GetMethodInfo().Name}/{ruleDescriptor.PropertyName}-{Guid.NewGuid()}";
break;
}
}
public void AddRule <T, R>(RuleHandler <T, R> handler, R args, int priority) where R : RuleArgs
{
// get the list of rules for the property
List <IRuleMethod> list = GetRulesForProperty(args.PropertyName, true).GetList(false);
// we have the list, add out new rule
list.Add(new RuleMethod <T, R>(handler, args, priority));
}
//public void AddRule(AsyncRuleHandler handler, RuleSeverity severity, AsyncRuleArgs args)
//{
// // get the list of rules for the primary property
// List<IRuleMethod> list = GetRulesForProperty(args.Properties[0].Name, true).GetList(false);
// // we have the list, add our new rule
// list.Add(new AsyncRuleMethod(handler, args, severity));
//}
public void AddRule(RuleHandler handler, RuleArgs args, int priority)
{
// get the list of rules for the property
List <IRuleMethod> list = GetRulesForProperty(args.PropertyName, true).GetList(false);
// we have the list, add our new rule
list.Add(new RuleMethod(handler, args, priority));
}
/// <summary>
/// Adds a rule to the list of rules to be enforced.
/// </summary>
/// <remarks>
/// <para>
/// A rule is implemented by a method which conforms to the
/// method signature defined by the RuleHandler delegate.
/// </para><para>
/// The propertyName may be used by the method that implements the rule
/// in order to retrieve the value to be validated. If the rule
/// implementation is inside the target object then it probably has
/// direct access to all data. However, if the rule implementation
/// is outside the target object then it will need to use reflection
/// or CallByName to dynamically invoke this property to retrieve
/// the value to be validated.
/// </para>
/// </remarks>
/// <param name="handler">The method that implements the rule.</param>
/// <param name="propertyName">
/// The property name on the target object where the rule implementation can retrieve
/// the value to be validated.
/// </param>
public void AddRule(RuleHandler handler, string propertyName)
{
// get the list of rules for the property
List <RuleMethod> list = GetRulesForProperty(propertyName);
// we have the list, add our new rule
list.Add(new RuleMethod(_target, handler, propertyName));
}
/// <summary>Creates and initializes the rule.</summary>
/// <param name="pHandler">The address of the method implementing the rule.</param>
/// <param name="pArgs">A RuleArgs object.</param>
/// <param name="pPropertyNames">The fields, properties or columns to which the rule applies.</param>
public MultiPropertyRuleMethod(RuleHandler pHandler, RuleArgs pArgs, params string[] pPropertyNames)
: base(pHandler, pArgs)
{
if (pPropertyNames == null || pPropertyNames.Length < 2)
{
throw new ArgumentException("MultiPropertyRules require at least two properties.");
}
mPropertyNames = pPropertyNames;
}
/// <summary>
/// Creates and initializes the rule.
/// </summary>
/// <param name="handler">The address of the method implementing the rule.</param>
/// <param name="args">A RuleArgs object.</param>
public RuleMethod(RuleHandler handler, RuleArgs args)
{
_handler = handler;
_args = args;
_ruleName = string.Format(@"rule://{0}/{1}/{2}",
Uri.EscapeDataString(_handler.Method.DeclaringType.FullName),
_handler.Method.Name,
_args.ToString());
}
/// <summary>
/// Creates and initializes the rule.
/// </summary>
/// <param name="handler">The address of the method implementing the rule.</param>
/// <param name="args">A RuleArgs object.</param>
public RuleMethod(RuleHandler handler, RuleArgs args)
{
_handler = handler;
_args = args;
_ruleName = string.Format(@"rule://{0}/{1}/{2}",
Uri.EscapeDataString(_handler.Method.DeclaringType.GetAssemplyQualifiedName(true)),
_handler.Method.Name,
_args.ToString());
}
/// <summary>
/// Adds a lambda property level rule to business rules.
/// </summary>
/// <param name="businessRules">Business rules</param>
/// <param name="ruleHandler">Rule method</param>
/// <param name="primaryPropertyName">Primary Property name</param>
/// <param name="priority">Priority</param>
//[Obsolete("For migration of older apps to Csla 4.x only")]
public static void AddRule(this BusinessRules businessRules, RuleHandler ruleHandler, string primaryPropertyName, int priority)
{
if (string.IsNullOrEmpty(primaryPropertyName))
{
throw new ArgumentException("primaryPropertyName");
}
var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, primaryPropertyName);
AddRule(businessRules, ruleHandler, primaryProperty, new RuleArgs(primaryProperty), priority);
}
/// <summary>
/// Adds a lambda property level rule to business rules.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="businessRules">Business rules</param>
/// <param name="ruleHandler">Rule method</param>
/// <param name="primaryPropertyName">Name of the primary property.</param>
///// <param name="primaryPropertyName">Primary Property name</param>
//[Obsolete("For migration of older apps to Csla 4.x only")]
public static void AddRule <T>(this BusinessRules businessRules, RuleHandler <T, RuleArgs> ruleHandler, string primaryPropertyName) where T : BusinessBase <T>
{
if (string.IsNullOrEmpty(primaryPropertyName))
{
throw new ArgumentException("primaryPropertyName");
}
var primaryProperty = PropertyHelper.GetRegisteredProperty(businessRules, primaryPropertyName);
AddRule(businessRules, ruleHandler, primaryProperty, new RuleArgs(primaryProperty), 0);
}
/// <summary>Remove a specific rule from the rule list.</summary>
public void Remove(RuleHandler pHandler, string pPropertyName)
{
// get the list of rules for the property
List <RuleMethod> list = this[pPropertyName];
if (list == null)
{
return; // no such list
}
Remove(pHandler, list);
}
private static void Remove(RuleHandler pHandler, List <RuleMethod> pList)
{
// we have the list, remove the rule by handler
for (int index = 0; index < pList.Count; index++)
{
if (pList[index].RuleHandler == pHandler)
{
pList.RemoveAt(index);
break;
}
}
}
public void Has3OfSpades_UsingInvalidPlay_ReturnsFalse()
{
var sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Diamonds", 2)
};
bool result = sut.Has3OfSpades(cards);
Assert.IsFalse(result);
}
public void IsValidPlay_UsingInvalidValidSingleOnFirstPlay_Fail()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("4", 1, "Spades", 0)
};
bool result = sut.IsValidPlay(cards, null);
Assert.IsFalse(result);
}
public void Has3OfSpades_Using3OfSpades_ReturnsTrue()
{
var sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Spades", 0)
};
bool result = sut.Has3OfSpades(cards);
Assert.IsTrue(result);
}
public void FindCategory_UsingSingle_ReturnsSingle()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Spades", 0)
};
RuleHandler.Category result = sut.FindCategory(cards);
Assert.AreEqual(RuleHandler.Category.Single, result);
}
public void IsValidPlay_UsingValidSingleOnFirstPlay_Success()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Spades", 0)
};
bool result = sut.IsValidPlay(cards, null);
Assert.IsTrue(result);
Assert.AreEqual(RuleHandler.Category.Single, sut.CurrentCategory);
}
/// <summary>Creates and initializes the rule.</summary>
/// <param name="pHandler">The address of the method implementing the rule.</param>
/// <param name="pArgs">Rule arguments.</param>
/// <param name="pBusinessPropertys">The entity columns to which the rule applies.</param>
public MultiPropertyRuleMethod(RuleHandler pHandler, RuleArgs pArgs, params BusinessProperty[] pBusinessPropertys)
: base(pHandler, pArgs)
{
if (pBusinessPropertys == null || pBusinessPropertys.Length < 2)
{
throw new ArgumentException("MultiPropertyRules require at least two properties.");
}
mPropertyNames = new string[pBusinessPropertys.Length];
for (int i = 0; i < pBusinessPropertys.Length; i++)
{
mPropertyNames[i] = pBusinessPropertys[i].Name;
}
}
public void FindCategory_UsingInvalidDouble_ReturnsInvalid()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Spades", 0),
new Card("4", 1, "Clubs", 1)
};
RuleHandler.Category result = sut.FindCategory(cards);
Assert.AreEqual(RuleHandler.Category.Invalid, result);
}
public void FindCategory_UsingTriple_ReturnsTriple()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Spades", 0),
new Card("3", 0, "Clubs", 1),
new Card("3", 0, "Diamonds", 2)
};
RuleHandler.Category result = sut.FindCategory(cards);
Assert.AreEqual(RuleHandler.Category.Triple, result);
}
public void FindCategory_UsingStraightFlush_ReturnsStraightFlush()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Spades", 0),
new Card("4", 1, "Spades", 0),
new Card("5", 2, "Spades", 0)
};
RuleHandler.Category result = sut.FindCategory(cards);
Assert.AreEqual(RuleHandler.Category.StraightFlush, result);
}
public void FindCategory_Using4OfAKind_ReturnsBomb()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Spades", 0),
new Card("3", 0, "Clubs", 1),
new Card("3", 0, "Diamonds", 2),
new Card("3", 0, "Hearts", 3)
};
RuleHandler.Category result = sut.FindCategory(cards);
Assert.AreEqual(RuleHandler.Category.Bomb, result);
}
public void IsValidPlay_Using4OfAKindBomb_Success()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Spades", 0),
new Card("3", 0, "Clubs", 1),
new Card("3", 0, "Diamonds", 2),
new Card("3", 0, "Hearts", 3)
};
bool result = sut.IsValidPlay(cards, null);
Assert.IsTrue(result);
Assert.AreEqual(RuleHandler.Category.Bomb, sut.CurrentCategory);
}
public void IsValidPlay_UsingEqualSingleLowerSuit_Fail()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>();
sut.FreeTurn();
cards.Add(new Card("J", 8, "Clubs", 1));
sut.IsValidPlay(cards, null);
var cards1 = new List <Card>
{
new Card("J", 8, "Spades", 0)
};
bool result = sut.IsValidPlay(cards1, cards);
Assert.IsFalse(result);
}
public void IsValidPlay_UsingHigherSingle_Success()
{
RuleHandler sut = new RuleHandler();
List <Card> cards = new List <Card>
{
new Card("3", 0, "Spades", 0)
};
sut.IsValidPlay(cards, null);
var cards1 = new List <Card>
{
new Card("4", 1, "Spades", 0)
};
bool result = sut.IsValidPlay(cards1, cards);
Assert.IsTrue(result);
}
/// <summary>
/// Adds a rule to the list of rules to be enforced.
/// </summary>
/// <param name="handler">The handler.</param>
/// <param name="e">The e.</param>
/// <param name="ruleType">Type of the rule.</param>
/// <exception cref="ArgumentNullException">
/// Either handler or e is null
/// </exception>
/// <exception cref="InvalidEnumArgumentException">ruleType is not a member of RuleType enum.</exception>
public void AddRule(RuleHandler handler, RuleDescriptorBase e, RuleType ruleType)
{
if (handler == null)
{
throw new ArgumentNullException(nameof(handler));
}
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
if (!Enum.IsDefined(typeof(RuleType), ruleType))
{
throw new InvalidEnumArgumentException(nameof(ruleType), (Int32)ruleType, typeof(RuleType));
}
List <IValidationRuleMethod> list = GetRulesForProperty(e.PropertyName).List;
list.Add(new Validator(handler, e, ruleType));
}
public void AddRules(RuleHandler oHandler, string strPropertyName)
{
List<RuleMethod> oList = GetRulesForProperty(strPropertyName);
oList.Add(new RuleMethod(m_oTarget, oHandler, strPropertyName));
}
public RuleMethod(object oTarget, RuleHandler oHandler, string strPropertyName)
{
m_oTarget = oTarget;
m_oHandler = oHandler;
m_oArgs = new RuleArgs(strPropertyName);
m_strRuleName = oHandler.Method.Name + "!" + m_oArgs.ToString();
}
public void Start()
{
ruleHandler = GameObject.FindGameObjectWithTag("DiceRule").GetComponent<RuleHandler>();
}
