//-----------------------------------------------------------------------
        public void UpdatePreview()
        {
            DataTransformer.ElementPaths   = ElementPath.Split('\n').Select(e => e.Trim()).ToList();
            DataTransformer.Condition      = Condition;
            DataTransformer.OutputTemplate = TextEditor.Text;

            TransformError = null;

            try
            {
                var el = XElement.Parse(ExampleDocument);
                IsDocumentMatch = DataTransformer.TransformDocument(el);

                TransformedDocument = el.ToString().Replace("  ", "    ");
            }
            catch (Exception ex)
            {
                TransformError = ex.Message;

                TransformedDocument = "";
            }

            RaisePropertyChangedEvent(nameof(IsDocumentMatch));
            RaisePropertyChangedEvent(nameof(TransformError));
        }
Example #2
0
        public override bool DeferElement(DateTime newTickleDate)
        {
            var moves = new List <MovePair>();

            moves.Add(new MovePair(ElementPath, ElementPath.ReplaceTickleDate(newTickleDate)));

            if (HasInfoFile)
            {
                moves.Add(new MovePair(InfoFilePath, InfoFilePath.ReplaceTickleDate(newTickleDate)));
            }

            var res = true;

            foreach (var mp in moves)
            {
                try
                {
                    File.Move(mp.Source, mp.Destination);
                }
                catch (Exception ex)
                {
                    Logger.Error(ex, $"Exception occured when trying to perform tickle file moving ({mp.Source} -> {mp.Destination}).");
                    res = false;
                }
            }

            return(res);
        }
        bool TryFindAttribute(XDocument doc, out XAttribute attribute)
        {
            XElement element;

            if (!ElementPath.TryFind(doc, out element))
            {
                attribute = null;
                return(false);
            }

            attribute = element.Attribute(Key);

            if (attribute == null)
            {
                return(false);
            }
            return(true);
        }
Example #4
0
 public override Int32 GetHashCode()
 {
     return(ElementPath.GetHashCode());
 }
        //-----------------------------------------------------------------------
        public bool TransformDocument(XElement root)
        {
            var processed = false;

            foreach (var ElementPath in ElementPaths)
            {
                var pathParts    = ElementPath.Split('.');
                var resourceType = pathParts[0];
                if (resourceType == "*")
                {
                    var firstNode = pathParts[1];

                    var potentialStarts = root.Descendants(firstNode).ToList();

                    var elementPath = ElementPath.Replace(resourceType + "." + firstNode + ".", "");
                    foreach (var potentialRoot in potentialStarts)
                    {
                        if (pathParts.Length == 2)
                        {
                            var el          = potentialRoot;
                            var parent      = el.Parent;
                            var transformed = TransformElement(root, el);

                            foreach (var newEl in transformed)
                            {
                                el.AddBeforeSelf(newEl);
                            }
                            el.Remove();

                            processed = true;
                        }
                        else
                        {
                            var matchingEls = GetElements(potentialRoot, elementPath);
                            if (matchingEls.Count > 0)
                            {
                                foreach (var el in matchingEls)
                                {
                                    var parent      = el.Parent;
                                    var transformed = TransformElement(root, el);

                                    foreach (var newEl in transformed)
                                    {
                                        el.AddBeforeSelf(newEl);
                                    }
                                    el.Remove();
                                }

                                processed = true;
                            }
                        }
                    }
                }
                else
                {
                    if (root.Name != resourceType || resourceType == "*")
                    {
                        continue;
                    }

                    var elementPath = ElementPath.Replace(resourceType + ".", "");

                    var matchingEls = GetElements(root, elementPath);
                    if (matchingEls.Count > 0)
                    {
                        foreach (var el in matchingEls)
                        {
                            var parent      = el.Parent;
                            var transformed = TransformElement(root, el);

                            foreach (var newEl in transformed)
                            {
                                el.AddBeforeSelf(newEl);
                            }
                            el.Remove();
                        }

                        processed = true;
                    }
                }
            }

            return(processed);
        }