public virtual void ValidateConfirmationToken(string email, ValidationToken token, out ValidationTokenStatus status)
{
using (var Entities = Repository)
{
Guid applicationInstance = Guid.Parse(ApplicationName);
var user = Entities.
ApplicationInstance_v1_0
.Single(i => i.instanceUID == applicationInstance)
.Membership_v1_0.Where(m => m.Users_v1_0.email == email)
.Select(m => m.Users_v1_0).SingleOrDefault();
if (user == null)
{
status = ValidationTokenStatus.UserNotFound;
}
else
{
try
{
status = token.Validate(email);
}
catch
{
status = ValidationTokenStatus.InvalidToken;
}
}
}
}
public void ArrivalsService_GetArrivalsFromApi_ShouldReturnToken()
{
Task <ValidationToken> result = _mockedArrivalService.Object.GetArrivalsFromApi(today, testUrlAdress);
ValidationToken validationToken = result.Result;
Assert.IsNotNull(validationToken.Token);
}
public static ValidationResponse ValidateMember(ValidationToken token)
{
string connection = ConfigurationManager.ConnectionStrings["database"].ToString();
SqlConnection sql = new SqlConnection(connection);
SignInManager manager = new SignInManager(sql);
Family f = manager.Validate(token.Barcode, token.Pin);
OrganizationManager organization = new OrganizationManager(sql);
return(new ValidationResponse(f != null, f, organization.GetLocations(1)));
}
private void ProcessSerialDivergence(IPfcNode node)
{
ValidationToken nodeVt = GetValidationData(node).ValidationToken;
foreach (IPfcNode successor in node.SuccessorNodes)
{
nodeVt.IncrementAlternatePathsOpen();
Enqueue(node, successor, nodeVt);
}
nodeVt.DecrementAlternatePathsOpen();
//added 1 per child, subtract 1 overall. Thus 1 split to 4 yields 4 alt.
}
private void Enqueue(IPfcNode from, IPfcNode node, ValidationToken vt)
{
NodeValidationData vd = GetValidationData(node);
if (vd.InputRole == InputRole.ParallelConvergence)
{
GetValidationData(from).ValidationToken.DecrementAlternatePathsOpen();
}
vd.ValidationToken = vt;
m_activePath.Enqueue(new QueueData(from, node));
if (m_diagnostics)
{
Console.WriteLine("\tEnqueueing {0} with {1} ({2}).", node.Name, vt, vt.AlternatePathsOpen);
}
}
private void ProcessParallelDivergence(IPfcNode node)
{
ValidationToken nodeVt = GetValidationData(node).ValidationToken;
foreach (IPfcNode successor in node.SuccessorNodes)
{
ValidationToken successorVtVt = new ValidationToken(successor);
nodeVt.AddChild(successorVtVt);
if (m_diagnostics)
{
Console.WriteLine("\tCreated {0} as child for {1}.", successorVtVt.Name, nodeVt.Name);
}
Enqueue(node, successor, successorVtVt);
}
nodeVt.DecrementAlternatePathsOpen(); // I've been replaced by my childrens' collective path.
}
public JsonResult ValidateMember(ValidationToken data)
{
try
{
string connection = ConfigurationManager.ConnectionStrings["database"].ToString();
SqlConnection sql = new SqlConnection(connection);
SignInManager manager = new SignInManager(sql);
Family f = manager.Validate(data.Barcode, data.Pin);
OrganizationManager organization = new OrganizationManager(sql);
Location[] locationList = organization.GetLocations();
Object o = new ValidationResponse(f != null, f, locationList);
return(Json(o, JsonRequestBehavior.AllowGet));
} catch (Exception e)
{
return(null);
}
}
private void UpdateClosureToken(IPfcTransitionNode closureTransition)
{
// Find the youngest common ancestor to all gazinta tokens.
IPfcNode yca = DivergenceNodeFor(closureTransition);
bool completeParallelConverge = AllParallelAndAtLeastOneOfEachSetOfSerialPathsContain(yca, closureTransition);
ValidationToken replacementToken =
completeParallelConverge ? // Are all of the root node's outbound
// paths closed by the closure node?
GetValidationData(yca).ValidationToken : // If so, its token is the closure token.
GetValidationData(closureTransition.PredecessorNodes[0]).ValidationToken; // If not, pick one of the gazinta tokens.
replacementToken.IncrementAlternatePathsOpen();
GetValidationData(closureTransition).ValidationToken = replacementToken;
if (m_diagnostics)
{
Console.WriteLine("\t\tAssigning {0} ({1}) to {2} on its closure.", replacementToken.Name,
replacementToken.AlternatePathsOpen, closureTransition.Name);
}
}
public virtual void ValidateSubscriptionToken(string email, ValidationToken token, out ValidationTokenStatus status)
{
using (var Entities = Repository)
{
var user = Entities.Users_v1_0.Where(u => u.email.Equals(email, StringComparison.InvariantCultureIgnoreCase)).SingleOrDefault();
if (user == null)
{
status = ValidationTokenStatus.UserNotFound;
}
else
{
try
{
status = token.Validate(email);
}
catch
{
status = ValidationTokenStatus.InvalidToken;
}
}
}
}
private void Check()
{
m_errorList = new List <PfcValidationError>();
List <ValidationToken> tokensWithLiveChildren = new List <ValidationToken>();
List <ValidationToken> tokensWithOpenAlternates = new List <ValidationToken>();
List <IPfcNode> unreachableNodes = new List <IPfcNode>();
List <IPfcNode> unexecutedNodes = new List <IPfcNode>();
List <IPfcStepNode> inconsistentSerialConvergences = new List <IPfcStepNode>();
#region Collect errors
foreach (IPfcNode node in m_pfc.Nodes)
{
NodeValidationData nodeVd = GetValidationData(node);
ValidationToken nodeVt = nodeVd.ValidationToken;
if (nodeVt == null)
{
unreachableNodes.Add(node);
unexecutedNodes.Add(node);
}
else
{
if (nodeVt.AlternatePathsOpen > 0 && !tokensWithOpenAlternates.Contains(nodeVt))
{
tokensWithOpenAlternates.Add(GetValidationData(node).ValidationToken);
}
if (!nodeVd.NodeHasRun)
{
unexecutedNodes.Add(node);
}
if (node.ElementType == PfcElementType.Step && node.PredecessorNodes.Count() > 1)
{
ValidationToken vt = GetValidationData(node.PredecessorNodes[0]).ValidationToken;
if (!node.PredecessorNodes.TrueForAll(n => GetValidationData(n).ValidationToken.Equals(vt)))
{
inconsistentSerialConvergences.Add((IPfcStepNode)node);
}
}
if (nodeVt.AnyChildLive)
{
tokensWithLiveChildren.Add(nodeVt);
}
}
}
#endregion
m_pfcIsValid = tokensWithLiveChildren.Count() == 0 &&
tokensWithOpenAlternates.Count() == 0 &&
unreachableNodes.Count() == 0 &&
unexecutedNodes.Count() == 0 &&
inconsistentSerialConvergences.Count() == 0;
StringBuilder sb = null;
sb = new StringBuilder();
unreachableNodes.Sort(m_nodeByName);
unexecutedNodes.Sort(m_nodeByName);
inconsistentSerialConvergences.Sort(m_stepNodeByName);
foreach (IPfcNode node in unreachableNodes)
{
if (!node.PredecessorNodes.TrueForAll(n => GetValidationData(n).ValidationToken == null))
{
string narrative = string.Format("Node {0}, along with others that follow it, is unreachable.",
node.Name);
m_errorList.Add(new PfcValidationError("Unreachable PFC Node", narrative, node));
sb.AppendLine(narrative);
}
}
foreach (IPfcNode node in unexecutedNodes)
{
if (!node.PredecessorNodes.TrueForAll(n => GetValidationData(n).ValidationToken == null))
{
string narrative = string.Format("Node {0} failed to run.", node.Name);
m_errorList.Add(new PfcValidationError("Unexecuted PFC Node", narrative, node));
sb.AppendLine(narrative);
}
}
inconsistentSerialConvergences.Sort((n1, n2) => Comparer.Default.Compare(n1.Name, n2.Name));
foreach (IPfcStepNode node in inconsistentSerialConvergences)
{
string narrative =
string.Format(
"Branch paths (serial convergences) into {0} do not all have the same validation token, meaning they came from different branches (serial divergences).",
node.Name);
m_errorList.Add(new PfcValidationError("Serial Di/Convergence Mismatch", narrative, node));
sb.AppendLine(narrative);
}
foreach (ValidationToken vt in tokensWithLiveChildren)
{
List <IPfcNode> liveNodes = new List <IPfcNode>();
foreach (ValidationToken vt2 in vt.ChildNodes.Where(n => n.AlternatePathsOpen > 0))
{
liveNodes.Add(vt2.Origin);
}
int nParallelsOpen = vt.ChildNodes.Count();
string narrative =
string.Format(
"Under {0}, there {1} {2} parallel branch{3} that did not complete - {4} began at {5}.",
vt.Origin.Name,
nParallelsOpen == 1 ? "is" : "are",
nParallelsOpen,
nParallelsOpen == 1 ? "" : "es",
nParallelsOpen == 1 ? "it" : "they",
StringOperations.ToCommasAndAndedList <IPfcNode>(liveNodes, n => n.Name)
);
m_errorList.Add(new PfcValidationError("Uncompleted Parallel Branches", narrative, vt.Origin));
sb.AppendLine();
}
if (m_diagnostics)
{
Console.WriteLine(sb.ToString());
}
}
private void Propagate()
{
if (m_pfc.GetStartSteps().Count() != 1)
{
m_pfcIsValid = false;
return;
}
#region Initialize the processing queue.
IPfcNode start = m_pfc.GetStartSteps()[0];
m_root = new ValidationToken(start);
GetValidationData(start).ValidationToken = m_root;
if (m_diagnostics)
{
Console.WriteLine("Enqueueing {0} with token {1}.", start.Name, GetValidationData(start).ValidationToken);
}
m_activePath.Enqueue(new QueueData(null, start));
#endregion
do
{
// Now process the queue.
while (m_activePath.Count() > 0)
{
IPfcNode node = Dequeue();
GetValidationData(node).DequeueCount++;
if (m_diagnostics)
{
Console.WriteLine("Dequeueing {0} with token {1}.", node.Name,
GetValidationData(node).ValidationToken);
}
bool continueProcessing = true;
switch (GetValidationData(node).InputRole)
{
case InputRole.ParallelConvergence:
continueProcessing = ProcessParallelConvergence(node);
break;
case InputRole.SerialConvergence:
continueProcessing = ProcessSerialConvergence(node);
break;
case InputRole.PassIn:
break;
case InputRole.StartNode:
break;
default:
break;
}
if (continueProcessing)
{
switch (GetValidationData(node).OutputRole)
{
case OutputRole.ParallelDivergence:
ProcessParallelDivergence(node);
break;
case OutputRole.SerialDivergence:
ProcessSerialDivergence(node);
break;
case OutputRole.PassOut:
ProcessPassthrough(node);
break;
case OutputRole.TerminalNode:
ProcessTerminalNode(node);
break;
default:
break;
}
}
GetValidationData(node).NodeHasRun = true;
}
} while (m_activePath.Any());
}
public virtual void ValidateSubscriptionToken(string email, ValidationToken token, out ValidationTokenStatus status)
{
using (var Entities = Repository)
{
var user = Entities.Users_v1_0.Where(u => u.email.Equals(email, StringComparison.InvariantCultureIgnoreCase)).SingleOrDefault();
if (user == null)
{
status = ValidationTokenStatus.UserNotFound;
}
else
{
try
{
status = token.Validate(email);
}
catch
{
status = ValidationTokenStatus.InvalidToken;
}
}
}
}
public virtual void ValidateConfirmationToken(string email, ValidationToken token, out ValidationTokenStatus status)
{
using (var Entities = Repository)
{
Guid applicationInstance = Guid.Parse(ApplicationName);
var user = Entities.
ApplicationInstance_v1_0
.Single(i => i.instanceUID == applicationInstance)
.Membership_v1_0.Where(m => m.Users_v1_0.email == email)
.Select(m => m.Users_v1_0).SingleOrDefault();
if (user == null)
{
status = ValidationTokenStatus.UserNotFound;
}
else
{
try
{
status = token.Validate(email);
}
catch
{
status = ValidationTokenStatus.InvalidToken;
}
}
}
}
