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()); }