private void CheckMissingMandatoryElements(IPluglet currentPluglet, IDocumentFragment currentDocumentFragment) { foreach (IPluglet childPluglet in currentPluglet.Children) { if (childPluglet.IsMandatory == false) { continue; } bool childExist = false; foreach (IDocumentFragment childDocumentFragment in currentDocumentFragment.Children) { if (childDocumentFragment.Pluglet.Tag == childPluglet.Tag) { childExist = true; break; } } EdiErrorType errorType = EdiErrorType.Error; if (childPluglet.IsIgnore) { errorType = EdiErrorType.Warning; } if (childExist == false) { Errors.AddSegmentError(childPluglet.Tag, X12ErrorCode.MandatorySegmentMissingCode , string.Format("{0} : {1}", X12ErrorCode.GetStandardSegmentErrorDescription(X12ErrorCode.MandatorySegmentMissingCode), childPluglet.Tag) , CurrentElementNumber, CurrentLinePayloadStart + TotalPayloadLength, CurrentLinePayloadEnd + TotalPayloadLength, errorType); } } }
/// <summary> /// Add new DocumentFragment based on it's xPath. If intermediate nodes are not available then this function create those nodes too. /// </summary> /// <param name="currentDocument"></param> /// <param name="newFragment"></param> public static void AddDocumentFragment(this DocumentFragment document, IDocumentFragment newFragment) { if (document == null) { throw new ArgumentNullException("document"); } if (newFragment == null) { throw new ArgumentNullException("newFragment"); } ILogger logger = LoggerFactory.Logger; logger.Debug("DocumentFragmentExtensions.AddDocumentFragment", "Adding document fragment {0}", newFragment.Name); DocumentFragment parentFragment = document.AddIntermediateDocumentFragment(newFragment.Pluglet.Path); if (parentFragment.Children == null) { parentFragment.Children = new List <IDocumentFragment>(); } parentFragment.Children.Add(newFragment); ((DocumentFragment)newFragment).Parent = parentFragment; logger.Debug("DocumentFragmentExtensions.AddDocumentFragment", "Added document fragment {0}", newFragment.Name); }
public void Requeue() { lock (syncRoot) { IDocumentFragment <Documents.Queue> result = bucket.MutateIn <Documents.Queue>(Id) .Remove(q => q.FetchedAt) .Execute(); reQueued = result.Success; } }
/// <summary> /// Get the existence result for a fragement of type <typeparamref name="TContent"/> from a document of type <typeparamref name="TDocument"/>, /// using a given lambda expression path. /// </summary> /// <typeparam name="TDocument">Type of the parent document.</typeparam> /// <typeparam name="TContent">Type of the subdocument.</typeparam> /// <param name="result"><see cref="IDocumentFragment{TDocument}"/> where the the subdocument lookup was returned.</param> /// <param name="path">Lambda expression path that navigates to the subdocument from the parent document. /// This must be a path that was provided originally to the <see cref="ILookupInBuilder{TDocument}"/>.</param> /// <returns>True if the subdocument exists.</returns> /// <exception cref="ArgumentNullException"><paramref name="result"/> or <paramref name="path"/> is null.</exception> public static bool Exists <TDocument, TContent>(this IDocumentFragment <TDocument> result, Expression <Func <TDocument, TContent> > path) { if (result == null) { throw new ArgumentNullException("result"); } if (path == null) { throw new ArgumentNullException("path"); } return(result.Exists(ParsePath(result as ITypeSerializerProvider, path))); }
public static T AttachTo <T>(this T e, IDocumentFragment c) where T : INodeConvertible <IHTMLElement> { // X:\jsc.svn\examples\javascript\Avalon\Test\TestShadowTextBox\TestShadowTextBox\ApplicationCanvas.cs // X:\jsc.svn\core\ScriptCoreLib.Avalon\ScriptCoreLib.Avalon\JavaScript\BCLImplementation\System\Windows\Controls\TextBox.cs if (e != null) { c.appendChild(e.AsNode()); } return(e); }
public IDocumentFragment SelectSegment(SegmentPath segmentPath, string value) { IDocumentFragment segmentDocumentFragment = null; // If SegmentPath is conditional group then replace value with conditional value if (string.IsNullOrWhiteSpace(segmentPath.Value) == false) { value = segmentPath.Value; } if (CurrentSegments.TryGetValue(segmentPath.Path, out segmentDocumentFragment) == false) { List <IDocumentFragment> unusedSegmentsList; if (UnusedSegments.TryGetValue(segmentPath.Path, out unusedSegmentsList) == false) { PopulateUnusedSegments(segmentPath); } List <IDocumentFragment> documentFragments; if (UnusedSegments.TryGetValue(segmentPath.Path, out documentFragments)) { if (documentFragments.Count > 0) { if (string.IsNullOrWhiteSpace(value) == false && documentFragments.Count != 1) { foreach (IDocumentFragment documentFragment in documentFragments) { string segmentValue = documentFragment.GetDataSegmentValue(segmentPath.DataSegmentName); if (string.Equals(segmentValue, value, StringComparison.OrdinalIgnoreCase)) { segmentDocumentFragment = documentFragment; } } } else { segmentDocumentFragment = documentFragments[0]; } if (segmentDocumentFragment != null) { documentFragments.Remove(segmentDocumentFragment); CurrentSegments.Add(segmentPath.Path, segmentDocumentFragment); } } } } return(segmentDocumentFragment); }
/// <summary> /// Create plug based on the fatpipeDocument (instance tree). /// Generated plug will only have pluglets referred in instance tree. /// Generated plug will have repeated pluglets in case of loops. /// </summary> /// <param name="documentFragment"></param> /// <returns></returns> public static Pluglet GeneratePluglet(this IDocumentFragment documentFragment) { Pluglet pluglet = documentFragment.Pluglet.Clone(false); // Check if instance tree has any childrens, if not then copy all childrens from existingPluglet if (documentFragment.Children != null) { foreach (IDocumentFragment child in documentFragment.Children) { pluglet.Children.Add(child.GeneratePluglet()); } } return(pluglet); }
public override string GetJobParameter(string id, string name) { if (id == null) { throw new ArgumentNullException(nameof(id)); } if (name == null) { throw new ArgumentNullException(nameof(name)); } IDocumentFragment <Documents.Job> result = bucket.LookupIn <Documents.Job>(id) .Get($"parameters.{name}") .Execute(); return(result.Success ? result.Content($"parameters.{name}").ToString() : null); }
public static string GetDataSegmentValue(this IDocumentFragment documentFragment, string dataSegmentName) { string segmentValue = null; if (documentFragment != null && documentFragment.Children != null) { foreach (DocumentFragment child in documentFragment.Children) { if (string.Equals(child.Pluglet.Tag, dataSegmentName, StringComparison.OrdinalIgnoreCase)) { segmentValue = child.Value; break; } } } return(segmentValue); }
private static IElement GetInnerMostElement(this IDocumentFragment fragment) { if (fragment.ChildElementCount != 1) { throw new InvalidOperationException("The provided HTML code did not result in any element."); } var element = default(IElement); var child = fragment.FirstElementChild; do { element = child; child = element.FirstElementChild; }while (child != null); return(element); }
/// <summary> /// Count all segments in a given document /// </summary> /// <param name="document"></param> /// <returns></returns> public static int CountAllChilds(this IDocumentFragment document) { if (document.Pluglet.PlugletType == PlugletType.Segment) { return(1); } if (document.Children == null) { return(0); } int count = 0; foreach (IDocumentFragment child in document.Children) { count += child.CountAllChilds(); } return(count); }
public IFetchedJob Dequeue(string[] queues, CancellationToken cancellationToken) { lock (syncLock) { while (true) { cancellationToken.ThrowIfCancellationRequested(); int invisibilityTimeoutEpoch = DateTime.UtcNow.Add(invisibilityTimeout.Negate()).ToEpoch(); logger.Trace("Looking for any jobs from the queue"); using (new CouchbaseDistributedLock(DISTRIBUTED_LOCK_KEY, defaultLockTimeout, storage)) { using (IBucket bucket = storage.Client.OpenBucket(storage.Options.DefaultBucket)) { BucketContext context = new BucketContext(bucket); Documents.Queue data = context.Query <Documents.Queue>() .Where(q => q.DocumentType == DocumentTypes.Queue && queues.Contains(q.Name) && (N1QlFunctions.IsMissing(q.FetchedAt) || q.FetchedAt < invisibilityTimeoutEpoch)) .OrderBy(q => q.CreatedOn) .FirstOrDefault(); if (data != null) { IDocumentFragment <Documents.Queue> result = bucket.MutateIn <Documents.Queue>(data.Id) .Upsert(q => q.FetchedAt, DateTime.UtcNow.ToEpoch(), true) .Execute(); if (result.Success) { logger.Trace($"Found job {data.JobId} from the queue {data.Name}"); return(new FetchedJob(storage, data)); } } } } logger.Trace($"Unable to find any jobs in the queue. Will check the queue for jobs in {storage.Options.QueuePollInterval.TotalSeconds} seconds"); cancellationToken.WaitHandle.WaitOne(storage.Options.QueuePollInterval); } } }
/// <summary> /// Move to given xPath fragment (leaf as well as non-leaf) /// </summary> /// <param name="rootFragment"></param> /// <param name="xPath"></param> /// <returns></returns> public static IDocumentFragment MoveTo(this IDocumentFragment rootFragment, string xPath) { if (rootFragment == null) { return(null); } IDocumentFragment documentFragment = null; string[] pathElements = xPath.Split(new string[] { rootFragment.Pluglet.PathSeperator }, StringSplitOptions.None); // Check if root element and 1st element in path match if (string.Equals(pathElements[0], rootFragment.Name, StringComparison.OrdinalIgnoreCase) == false) { throw new PlugDataModelException( string.Format("Error while traversing path {0}. First element in path {1} does not match with root element {2} of document", xPath, pathElements[0], rootFragment.Name)); } IDocumentFragment prevFragment = rootFragment; for (int i = 1; i < pathElements.Length; i++) { documentFragment = prevFragment.Children.FirstOrDefault( f => string.Equals(f.Name, pathElements[i], StringComparison.OrdinalIgnoreCase)); if (documentFragment == null) { break; } prevFragment = documentFragment; } return(documentFragment); }
private void ReadSegmentsWithIdDataTypeChildrens(Dictionary <string, List <IDocumentFragment> > contingencyOccurances, IDocumentFragment documentFragment) { if (documentFragment == null || documentFragment.Pluglet == null || documentFragment.Pluglet.PlugletType == PlugletType.Data || documentFragment.Pluglet.PlugletType == PlugletType.Unknown) { return; } bool currentSegmentAdded = false; if (documentFragment.Children != null && documentFragment.Children.Count > 0) { foreach (IDocumentFragment child in documentFragment.Children) { if (child.Pluglet != null) { if (child.Pluglet.PlugletType == PlugletType.Data) { if (child.Pluglet.DataType is X12_IdDataType && child.Pluglet.IsMandatory == true && currentSegmentAdded == false) { List <IDocumentFragment> contingencies; if (contingencyOccurances.TryGetValue(documentFragment.Pluglet.Path, out contingencies) == false) { contingencies = new List <IDocumentFragment>(); contingencyOccurances.Add(documentFragment.Pluglet.Path, contingencies); } contingencies.Add(documentFragment); currentSegmentAdded = true; } } else { ReadSegmentsWithIdDataTypeChildrens(contingencyOccurances, child); } } } } }
/// <summary> /// Read xml file and construct IFatpipeDocument. /// Xml file reader will traverse Xml files and for each element /// match it with current pluglet. If match fails then it tries to /// find matching pluglet (similar to X12). /// </summary> /// <returns></returns> public IFatpipeDocument ReadFile(Stream xmlFileStream, IDocumentPlug documentPlug) { if (xmlFileStream == null) { throw new ArgumentNullException("xmlFileStream", "Xml file stream cannot be null"); } if (documentPlug == null) { throw new ArgumentNullException("documentPlug", "Document plug cannot be null"); } string location = "XmlFileReader.ReadFile"; Logger.Debug(location, "Start"); BeautifiedOriginalPayload = string.Empty; CurrentElementNumber = 0; TotalPayloadLength = 0; CurrentLinePayloadStart = 0; CurrentLinePayloadEnd = 0; CurrentLevel = 0; Stopwatch sw = new Stopwatch(); sw.Start(); errors = new InterchangeErrors(); // Since xml file doesn't have concept of ST/SE, ans we want to use InterchangeErrors for reporting purpose // create dummy transaction set details Errors.AddTransactionSetDetails(1, "", "", true); IPluglet currentPluglet = documentPlug.RootPluglet; currentPluglet.ResetCurrentOccurances(); currentPluglet.InitializeStartSegmentList(); FatpipeDocumentInst = new FatpipeDocument(); FatpipeDocumentInst.DocumentPlug = documentPlug; FatpipeDocumentInst.RootFragment = currentPluglet.ConstructDocumentFragment(null, null); IDocumentFragment currentDocumentFragment = FatpipeDocumentInst.RootFragment; IDocumentFragment newDocumentFragment = null; bool isLeafNode = false; try { XmlTextReader xmlReader = new XmlTextReader(xmlFileStream); // If some element doesn't match document plutlet then stop // TODO: Should we try to match other elements? If yes, which pluglet to start with? // Also we need to ignore this entire element bool stopProcessing = false; while (xmlReader.Read()) { switch (xmlReader.NodeType) { case XmlNodeType.Element: isLeafNode = false; AddStartElementToPayload(xmlReader.Name, xmlReader.IsEmptyElement); if (xmlReader.IsEmptyElement) { break; } if (stopProcessing == false) { currentDocumentFragment = ConstructNewDocumentFragment(xmlReader.Name, currentPluglet, currentDocumentFragment); } // If some element doesn't match document plutlet then stop // TODO: Should we try to match other elements? If yes, which pluglet to start with? // Also we need to ignore this entire element if (currentDocumentFragment == null) { stopProcessing = true; } else { currentPluglet = currentDocumentFragment.Pluglet; } CurrentLevel++; CurrentElementNumber++; break; case XmlNodeType.Text: isLeafNode = true; AddValueToPayload(xmlReader.Value); if (stopProcessing == false) { currentDocumentFragment.Value = xmlReader.Value; } // Assumption: Leaf nodes are on same line and non-leaf nodes are 1-per line (separate line for start and end element) // If this assumption is wrong then we can construct the xml in string format to match fulfill above assumption // and then Ux can use this string version of xml to highlight the errors. CurrentElementNumber--; // Decrement since leaf level elements are one line, so we need to increment element on endElement only. break; case XmlNodeType.EndElement: CurrentLevel--; AddEndElementToPayload(xmlReader.Name, isLeafNode); if (stopProcessing == false) { // Check if all mandatory segments were present CheckMissingMandatoryElements(currentPluglet, currentDocumentFragment); currentDocumentFragment = currentDocumentFragment.Parent; currentPluglet = currentPluglet.Parent; } CurrentElementNumber++; isLeafNode = false; break; default: break; } } } catch (XmlException xmlException) { // TODO: Pass start and end postition Errors.AddGenericError(currentPluglet == null ? "N/A" : currentPluglet.Name, X12ErrorCode.UnexpectedSegmentCode, string.Format("Error parsing XML document: {0}", xmlException.Message), CurrentElementNumber / 2, CurrentLinePayloadStart + TotalPayloadLength, CurrentLinePayloadEnd + TotalPayloadLength); } catch (Exception exception) { // TODO: Pass start and end postition (for all Errors.Add* calls) in this file. Errors.AddGenericError(currentPluglet == null ? "N/A" : currentPluglet.Name, X12ErrorCode.UnexpectedSegmentCode, "Internal error occurred, please contact Maarg", CurrentElementNumber / 2, CurrentLinePayloadStart + TotalPayloadLength, CurrentLinePayloadEnd + TotalPayloadLength); Logger.Error(location, EventId.XmlReaderUnhandledException, "Error occured during xml file processing: {0}", exception.ToString()); } FatpipeDocumentInst.BeautifiedOriginalPayloadBody = BeautifiedOriginalPayload; sw.Stop(); Logger.Debug(location, "Stop - Elapsed time {0} ms", sw.ElapsedMilliseconds); return(FatpipeDocumentInst); }
private IDocumentFragment ConstructNewDocumentFragment(string elementName, IPluglet currentPluglet, IDocumentFragment currentDocumentFragment) { IDocumentFragment newDocumentPluglet = null; IPluglet nextPluglet = null; // Special case for root pluglet if (CurrentElementNumber == 0) { nextPluglet = currentPluglet; string rootNodeName = elementName; int pos = elementName.IndexOf(":"); if (pos != -1) { rootNodeName = elementName.Substring(pos + 1); } if (string.Equals(nextPluglet.Tag, rootNodeName, StringComparison.InvariantCultureIgnoreCase) == false) { Errors.AddSegmentError(elementName, -1, string.Format("Invalid root node name. Expected: {0}, Actual {1}", nextPluglet.Tag, rootNodeName), CurrentElementNumber, CurrentLinePayloadStart + TotalPayloadLength, CurrentLinePayloadEnd + TotalPayloadLength, EdiErrorType.Error); } } else { foreach (IPluglet childPluglet in currentPluglet.Children) { if (string.Equals(childPluglet.Tag, elementName, StringComparison.InvariantCultureIgnoreCase)) { nextPluglet = childPluglet; break; } } } if (nextPluglet == null) { Errors.AddSegmentError(elementName, X12ErrorCode.UnrecognizedSegmentIDCode, X12ErrorCode.GetStandardSegmentErrorDescription(X12ErrorCode.UnrecognizedSegmentIDCode), CurrentElementNumber, CurrentLinePayloadStart + TotalPayloadLength, CurrentLinePayloadEnd + TotalPayloadLength, EdiErrorType.Error); // TODO: Should we add 'Unrecognized segment' pluglet here? } else { newDocumentPluglet = new DocumentFragment() { Parent = currentDocumentFragment, Pluglet = nextPluglet, Value = elementName, }; if (currentDocumentFragment.Children == null) { ((DocumentFragment)currentDocumentFragment).Children = new List <IDocumentFragment>(); } currentDocumentFragment.Children.Add(newDocumentPluglet); } return(newDocumentPluglet); }
/// <summary> /// Construct EDI representation of this fragment /// </summary> /// <param name="ediDelimiters"></param> /// <param name="internalSegment"></param> /// <returns></returns> public string ToEDI(Delimiters ediDelimiters, bool internalSegment) { if (Children == null) { return(string.Empty); } StringBuilder segment = new StringBuilder(); string componentDelimiter = ((char)ediDelimiters.ComponentSeperator).ToString(); string fieldDelimiter = ((char)ediDelimiters.FieldSeperator).ToString(); string delimiter = internalSegment == true ? componentDelimiter : fieldDelimiter; // construct segment only for parent with at least 1 leaf node if (Children.Any(c => c.Pluglet.PlugletType == PlugletType.Data)) { if (internalSegment == false) { segment.AppendFormat("{0}", Pluglet.Tag); } foreach (IDocumentFragment child in Children) { if (child.Pluglet.PlugletType == PlugletType.Data) { if (segment.Length != 0 || internalSegment == false) { segment.AppendFormat("{0}{1}", delimiter, child.Value); } else { segment.AppendFormat("{0}", child.Value); } } else { segment.AppendFormat("{0}{1}", fieldDelimiter, child.ToEDI(ediDelimiters, true)); } } } else { string childSegment; StringBuilder segmentB = new StringBuilder(3); segmentB.Append((char)ediDelimiters.SegmentDelimiter); if (ediDelimiters.SegmentDelimiterSuffix1 != -1) { segmentB.Append((char)ediDelimiters.SegmentDelimiterSuffix1); } if (ediDelimiters.SegmentDelimiterSuffix2 != -1) { segmentB.Append((char)ediDelimiters.SegmentDelimiterSuffix2); } string segmentDelimiter = segmentB.ToString(); foreach (IDocumentFragment child in Children) { childSegment = child.ToEDI(ediDelimiters, false); segment.AppendFormat("{0}{1}" , string.IsNullOrEmpty(segment.ToString()) ? string.Empty : segmentDelimiter , childSegment); } IDocumentFragment firstChild = Children[0]; // Special case for ading SE/GE/IEA segments switch (firstChild.Pluglet.Tag) { case "ST": string txnSetNumber = ""; int segmentCount = 0; if (firstChild.Children != null && firstChild.Children.Count > 1) { txnSetNumber = firstChild.Children[1].Value; } // Set segmentCount to child count of X12_00401_850 segmentCount = this.CountAllChilds() + 1; // +1 for SE segment //segment.AppendFormat("{0}SE{1}{2}{3}{4}", segmentDelimiter, fieldDelimiter, segmentCount, fieldDelimiter, txnSetNumber); //segment.AppendFormat("{0}GE{1}1{2}1", segmentDelimiter, fieldDelimiter, fieldDelimiter); //segment.AppendFormat("{0}IEA{1}1{2}{3}", segmentDelimiter, fieldDelimiter, fieldDelimiter, "NNNN"); break; } } return(segment.ToString()); }
public JsDocumentFragment(IDocumentFragment baseObject, ISvgScriptEngine engine) : base(baseObject, engine) { }
private void ValidateContingencies() { // Assumption: If id data segment is not present then this function will not report error // as we must have already reported that data segment as missing segment earlier Dictionary <string, List <IDocumentFragment> > contingencyOccurances = new Dictionary <string, List <IDocumentFragment> >(); ReadSegmentsWithIdDataTypeChildrens(contingencyOccurances, FatpipeDocumentInst.RootFragment); foreach (string path in contingencyOccurances.Keys) { // Select pluglet for current path // Selecting pluglet from the 1st documentFragment as pluglet will be // same for all documentFragments with same path IDocumentFragment documentFragment = contingencyOccurances[path][0]; IPluglet pluglet = documentFragment.Pluglet; // Pluglet will point to segment, process all child with data type as X12_IdDataType // Filter out non-mandatory data type pluglets foreach (Pluglet child in pluglet.Children) { if (child.PlugletType == PlugletType.Data && child.DataType is X12_IdDataType && child.IsMandatory == true) { List <string> presentValues = GetAllPresentValues(contingencyOccurances[path], child); X12_IdDataType dataType = child.DataType as X12_IdDataType; foreach (string allowedValue in dataType.AllowedValues.Keys) { Contingency contingencies = dataType.GetContingencies(allowedValue); // TODO: Use Ignore flag at id value level // If Id value does not have any contingency then segment with that value must exist if (contingencies == null || contingencies.ContingencyValues.Count == 0) { if (presentValues.Contains(allowedValue) == false && dataType.IsOptionalValue(allowedValue) == false) { Errors.AddSegmentError(pluglet.Tag, X12ErrorCode.DeMandatoryIdValueMissingCode , string.Format("{0} : {1}", X12ErrorCode.GetDataElementErrorDescription(X12ErrorCode.DeMandatoryIdValueMissingCode), allowedValue) , documentFragment.SequenceNumber, documentFragment.StartOffset, documentFragment.EndOffset, EdiErrorType.Error); } } // If Id value has contingencies of type Enumeration then segment with that value or any contingency value must exist else if (contingencies.Type == ContingencyType.Enumeration) { bool valuePresent = presentValues.Contains(allowedValue); if (valuePresent == false) { foreach (string alternateValue in contingencies.ContingencyValues) { valuePresent = presentValues.Contains(alternateValue); if (valuePresent) { break; } } } if (valuePresent == false) { Errors.AddSegmentError(pluglet.Tag, X12ErrorCode.DeMandatoryIdValueOrAlternativeValueMissingCode , string.Format("{0} : {1}", X12ErrorCode.GetDataElementErrorDescription(X12ErrorCode.DeMandatoryIdValueOrAlternativeValueMissingCode), allowedValue) , documentFragment.SequenceNumber, documentFragment.StartOffset, documentFragment.EndOffset, EdiErrorType.Error); } } // If contingency type is cross segment then either both values must exist or both values missing else if (contingencies.Type == ContingencyType.CrossSegment) { // TODO: handle all values in contingencies.ContingencyValues string xPath = contingencies.ContingencyValues[0]; bool currentValuePresent = presentValues.Contains(allowedValue); bool crossSegmentValuePresent = IsCrossSegmentValuePresent(contingencyOccurances, xPath, pluglet.PathSeperator); if (currentValuePresent != crossSegmentValuePresent) { Errors.AddSegmentError(pluglet.Tag, X12ErrorCode.DeCrossSegmentIdValueOccurancesDoesNotMatch , string.Format("{0} : {1} {2}", X12ErrorCode.GetDataElementErrorDescription(X12ErrorCode.DeCrossSegmentIdValueOccurancesDoesNotMatch), allowedValue, xPath) , documentFragment.SequenceNumber, documentFragment.StartOffset, documentFragment.EndOffset, EdiErrorType.Error); } } } } } } }
static void GetDisplay <T>(IDocumentFragment <T> fragment, string path) { string format = "Path='{0}' Value='{1}'"; Console.WriteLine(format, path, fragment.Content(path)); }
protected override IProviderResponse <TEntityFragment> MapResponse <TEntityFragment>(IDocumentFragment <TSvcFragmentEntity> cbSvcResult, string fragmentKey) { if (cbSvcResult != null) { int fragmentIndex; dynamic data = (Int32.TryParse(fragmentKey, out fragmentIndex)) ? cbSvcResult.Content <TEntityFragment>(fragmentIndex) : cbSvcResult.Content <TEntityFragment>(fragmentKey); if (data == null && typeof(TEntityFragment) == typeof(bool)) { data = cbSvcResult.Exists(fragmentKey); } return(new ProviderResponse <TEntityFragment>() { Data = data, Success = cbSvcResult.Success, Message = cbSvcResult.Message, ResponseStatus = cbSvcResult.Status.ToString("f"), Exception = cbSvcResult.Exception, Version = cbSvcResult.Cas }); } return(new ProviderResponse <TEntityFragment>() { Success = false, Message = string.Empty, ResponseStatus = CustomResponseErrors.CBSvcMappingError.ToString("f") }); }
/// <summary> /// Construct DocumentFragment from IPluglet for non-leaf elements /// </summary> /// <param name="pluglet"></param> /// <param name="parent"></param> /// <returns></returns> public static DocumentFragment ConstructDocumentFragment(this IPluglet pluglet, IDocumentFragment parent, string value) { if (pluglet == null) { throw new ArgumentNullException("pluglet"); } ++pluglet.CurrentOccurrences; DocumentFragment documentFragment = new DocumentFragment() { Pluglet = pluglet, Parent = parent, Value = value, }; return(documentFragment); }
private static List <BizRuleValidationResult> ValidateBizRules(BizRuleSet bizRuleSet, List <DocumentPlugValidationInfo> documentPlugValidationInfoList) { if (bizRuleSet == null) { throw new ArgumentNullException("bizRuleSet", "bizRuleSet cannot be null"); } if (documentPlugValidationInfoList == null || documentPlugValidationInfoList.Count <= 1) { throw new ArgumentNullException("documentPlugValidationInfoList", "documentPlugValidationInfoList cannot be null and should have > 1 entries"); } List <BizRuleValidationResult> bizRuleValidationResults = new List <BizRuleValidationResult>(); List <RuleSegments> ruleSegmentsList = new List <RuleSegments>(); foreach (int messageDomainId in bizRuleSet.MessageDomainIds) { RuleSegments ruleSegments = null; foreach (DocumentPlugValidationInfo documentPlugValidationInfo in documentPlugValidationInfoList) { if (documentPlugValidationInfo.DocumentPlug != null && documentPlugValidationInfo.DocumentPlug.DocumentType == messageDomainId) { ruleSegments = new RuleSegments(documentPlugValidationInfo.FatpipeDocument, documentPlugValidationInfo.SpecCertName); break; } } ruleSegmentsList.Add(ruleSegments); } // Conditional groups - first get all BizRuleValidationResult for all groups // then for each group check if at least one is successful, in case // of success, mark others as success? Dictionary <string, List <BizRuleValidationResult> > conditionalRulesResult = new Dictionary <string, List <BizRuleValidationResult> >(); string segmentValue; foreach (string firstSegmentPath in bizRuleSet.BizRules.Keys) { // TODO: Handle segmentPath being null/empty List <BizRule> bizRules = bizRuleSet.BizRules[firstSegmentPath]; bool loopHasValues = true; int loopOccurance = 0; while (loopHasValues) { foreach (BizRule bizRule in bizRules) { string valueToMatch = null; BizRuleValidationResult bizRuleValidationResult = new BizRuleValidationResult(); bizRuleValidationResult.RuleName = bizRule.Name; bizRuleValidationResult.Type = ResultType.Success; bizRuleValidationResult.RuleInfo = new List <BizRuleInfo>(); int i = 0; bool isRuleSuccessful = true; foreach (SegmentPath segmentPath in bizRule.SegmentPaths) { if (string.IsNullOrWhiteSpace(segmentPath.OriginalPath)) { i++; continue; } BizRuleInfo bizRuleInfo = new BizRuleInfo() { SegmentPath = segmentPath.OriginalPath, }; if (ruleSegmentsList[i] != null) { bizRuleInfo.FileName = ruleSegmentsList[i].CertName; IDocumentFragment documentFragment = ruleSegmentsList[i].SelectSegment(segmentPath, valueToMatch); if (documentFragment != null) { segmentValue = documentFragment.GetDataSegmentValue(segmentPath.DataSegmentName); if (string.IsNullOrWhiteSpace(valueToMatch) || string.IsNullOrWhiteSpace(segmentPath.Value) == false) { valueToMatch = segmentValue; } else if (string.Equals(valueToMatch, segmentValue, StringComparison.OrdinalIgnoreCase) == false) { isRuleSuccessful = false; } bizRuleInfo.Value = segmentValue; } else if (loopOccurance != 0 && i == 0) { loopHasValues = false; break; } } else { bizRuleInfo.FileName = "Not provided"; } if (string.IsNullOrWhiteSpace(bizRuleInfo.Value)) { bizRuleInfo.Value = "<Not Valued>"; isRuleSuccessful = false; } bizRuleValidationResult.RuleInfo.Add(bizRuleInfo); i++; } if (loopHasValues) { // TODO: Conditional mandatory will impact setting type to error. if (isRuleSuccessful == false) { bizRuleValidationResult.Type = bizRule.Type == BizRuleType.Optional ? ResultType.Warning : ResultType.Error; } if (string.IsNullOrWhiteSpace(bizRule.ConditionalGroupName) == false) { List <BizRuleValidationResult> bizRuleResults; if (conditionalRulesResult.TryGetValue(bizRule.ConditionalGroupName, out bizRuleResults) == false) { bizRuleResults = new List <BizRuleValidationResult>(); conditionalRulesResult.Add(bizRule.ConditionalGroupName, bizRuleResults); } bizRuleResults.Add(bizRuleValidationResult); } bizRuleValidationResults.Add(bizRuleValidationResult); } } foreach (RuleSegments ruleSegments in ruleSegmentsList) { ruleSegments.MoveCurrentToUsed(); } loopOccurance++; } } if (conditionalRulesResult.Count > 0) { foreach (List <BizRuleValidationResult> bizRuleResults in conditionalRulesResult.Values) { if (bizRuleResults.Any(bizRuleResult => bizRuleResult.Type == ResultType.Success)) { foreach (BizRuleValidationResult bizRuleResult in bizRuleResults) { bizRuleResult.Type = ResultType.Success; } } } } return(bizRuleValidationResults); }
private void Acquire(TimeSpan timeout) { logger.Trace($"Trying to acquire lock for {resource} within {timeout.TotalSeconds} seconds"); System.Diagnostics.Stopwatch acquireStart = new System.Diagnostics.Stopwatch(); acquireStart.Start(); string id = $"{resource}:{DocumentTypes.Lock}".GenerateHash(); while (string.IsNullOrEmpty(resourceId)) { // default ttl for lock document TimeSpan ttl = DateTime.UtcNow.Add(timeout).AddMinutes(1).TimeOfDay; // read the document IDocumentResult <Lock> document = bucket.GetDocument <Lock>(id); // false means the document does not exists got ahead and create if (document.Success == false) { Lock @lock = new Lock { Id = id, Name = resource, ExpireOn = DateTime.UtcNow.Add(timeout).ToEpoch() }; IOperationResult <Lock> result = bucket.Insert(@lock.Id, @lock, ttl); if (result.Success) { resourceId = id; break; } } else if (document.Content != null) { if (document.Content.ExpireOn < DateTime.UtcNow.ToEpoch()) { IDocumentFragment <Lock> result = bucket.MutateIn <Lock>(id) .WithCas(document.Document.Cas) .WithExpiry(ttl) .Upsert(l => l.ExpireOn, DateTime.UtcNow.Add(timeout).ToEpoch(), false) .Execute(); if (result.Success) { resourceId = id; break; } } } // check the timeout if (acquireStart.ElapsedMilliseconds > timeout.TotalMilliseconds) { throw new CouchbaseDistributedLockException($"Could not place a lock on the resource '{resource}': Lock timeout."); } // sleep for 2000 millisecond logger.Trace($"Unable to acquire lock for {resource}. Will check try after 2 seconds"); System.Threading.Thread.Sleep(2000); } logger.Trace($"Acquired lock for {resource} in {acquireStart.Elapsed.TotalSeconds} seconds"); }
public static IFatpipeDocument Transform(IFatpipeDocument sourceDocument, ITransformPlug transformPlug) { if (sourceDocument == null) { throw new ArgumentNullException("sourceDocument"); } Stopwatch sw = new Stopwatch(); sw.Start(); FatpipeDocument targetDocument = new FatpipeDocument(); targetDocument.RootFragment = transformPlug.TargetDocument.RootPluglet.ConstructDocumentFragment(null, null);; //TODO: Handle loops foreach (ITransformGroup transformGroup in transformPlug.Facets) { Logger.Debug("DocumentTransformer.Transform", "Processing {0} tranformGroup", transformGroup.Name); foreach (ITransformLink transformLink in transformGroup.Links) { Logger.Debug("DocumentTransformer.Transform", "Processing Link#-{0}: {1} [{2}] => {3} [{4}]" , transformLink.Name , transformLink.Source.ReferenceType, transformLink.Source.Name , transformLink.Target.ReferenceType, transformLink.Target.Name); //TODO: Handle all kind of transformation if (transformLink.Source.ReferenceType == ReferenceType.Document && transformLink.Target.ReferenceType == ReferenceType.Document) { // Traverse source path IDocumentFragment sourceFragment = sourceDocument.RootFragment.MoveTo(transformLink.Source.Name); if (sourceFragment != null) { IPluglet targetPluglet = targetDocument.RootFragment.Pluglet.MoveTo(transformLink.Target.Name); if (targetPluglet != null) { Logger.Debug("DocumentTransformer.Transform", "Source = {0}, Target = {1}", sourceFragment.Name, targetPluglet.Tag); Dictionary <string, string> attributes = new Dictionary <string, string>(); foreach (IPluglet attr in targetPluglet.Attributes) { string attributeName = attr.Name; attributeName.Remove(0, 1); attributeName.Remove(attributeName.Length, 1); attributes.Add(attributeName, attributeName); } bool isAttribute = false; string name = transformLink.Target.Name.Substring( transformLink.Target.Name.LastIndexOf(targetPluglet.PathSeperator) + targetPluglet.PathSeperator.Length); // Check if this transformation point to attribute or leaf node if (targetPluglet.Attributes != null && attributes.ContainsKey(name)) { isAttribute = true; } if (isAttribute == false) { IDocumentFragment newFragment = targetPluglet.ConstructDocumentFragment(null, sourceFragment.Value); ((DocumentFragment)targetDocument.RootFragment).AddDocumentFragment(newFragment); } else { ((DocumentFragment)targetDocument.RootFragment).AddDocumentFragment(transformLink.Target.Name, sourceFragment.Value); } } else { string error = string.Format("Link#-{0}: {1} path not found in target tree", transformLink.Name, transformLink.Target.Name); if (targetDocument.Errors == null) { targetDocument.Errors = new List <string>(); } targetDocument.Errors.Add(error); Logger.Error("DocumentTransformer.Transform", EventId.DocTransformerNoMapping, error); } } } else { Logger.Debug("DocumentTransformer.Transform", "Ignoring Link#-{0}", transformLink.Name); } } //TODO: Handle transformGroup.Formulas } sw.Stop(); Logger.Debug("DocumentTransformer.Transform", "Stop. Elapsed time {0} ms", sw.ElapsedMilliseconds); return(targetDocument); }