public void Transform(Engine engine, Package package)
        {
            TemplatingLogger log = TemplatingLogger.GetLogger(GetType());
            if (package.GetByName(Package.OutputName) == null)
            {
                log.Error("Could not find \"Output\" item in Package. This template building block should be the last TBB in your template.");
                return;
            }
            Item output = package.GetByName(Package.OutputName);

            string outputText = output.GetAsString();

            bool outputchanged = false;
            foreach (Match m in TcmUriRegEx.Matches(outputText))
            {
                log.Debug("Found " + m.Value);
                TcmUri uri = new TcmUri(m.Value);
                if(uri.GetVersionlessUri().ToString().Equals(m.Value)) continue;
                log.Debug("Found version information on uri " + m.Value + ". Removing.");
                outputText = outputText.Replace(m.Value, uri.GetVersionlessUri().ToString());
                outputchanged = true;
            }
            if (outputchanged)
            {
                output.SetAsString(outputText);
                package.Remove(output);
                package.PushItem(Package.OutputName, output);
            }
        }

 public Article(SessionAwareCoreServiceClient client, TcmUri location)
     : base(client)
 {
     ComponentData component = (ComponentData)Client.GetDefaultData(ItemType.Component, location, ReadOptions);
     component.Schema = new LinkToSchemaData { IdRef = ContentManager.ResolveUrl(Constants.ArticleSchemaUrl) };
     Content = component;
 }

 /// <summary>
 /// Constrctor
 /// </summary>
 /// <param name="engine"></param>
 /// <param name="componentID"></param>
 /// <param name="templateID"></param>
 /// <param name="index"></param>
 public ComponentPresentationModel(Engine engine, TcmUri componentID, TcmUri templateID, int index)
 {
     _engine = engine;
     _componentID = componentID;
     _templateID = templateID;
     Index = index;
 }

 protected ContentItem(TcmUri itemId, SessionAwareCoreServiceClient client)
 {
     ReadOptions = new ReadOptions();
     Client = client;
     Content = (ComponentData) client.Read(itemId, ReadOptions);
     ContentManager = new ContentManager(Client);
 }

        public string ResolveLink(string componentUri)
        {
            TcmUri uri = new TcmUri(componentUri);

            if (!uri.Equals(emptyTcmUri))
            {
                Cache cache = HttpContext.Current.Cache;
                string cacheKey = String.Format(CACHEKEY_FORMAT, componentUri);
                if (cache[cacheKey] != null)
                {
                    return (String)cache[cacheKey];
                }
                else
                {
                    Link link = componentLink.GetLink(uri.ToString());
                    if (!link.IsResolved)
                    {
                        return null;
                    }
                    cache.Insert(cacheKey, link.Url, null, DateTime.Now.AddSeconds(30), TimeSpan.Zero); //TODO should this be configurable?
                    return link.Url;
                }
            }

            return null;
        }

        /// <summary>
        /// Retrieves the Compound Template invocation XML for a given page or component template Uri
        /// </summary>
        /// <param name="compoundTemplateWebService"><see cref="T:Tridion.ContentManager.Templating.CompoundTemplates.DomainModel.Proxy.CompoundTemplateWebService" /></param>
        /// <param name="templateUri">Tridion template URI.</param>
        /// <returns>Compound Template invocation XML as <see cref="T:String.String" /></returns>
        /// <exception cref="System.NotSupportedException">Unsupported template type</exception>
        public static String GetAssemblyKey(this CompoundTemplateWebService compoundTemplateWebService, String templateUri)
        {
            if (compoundTemplateWebService != null)
            {
                XmlElement templateXml = compoundTemplateWebService.ReadItem(templateUri, EnumOpenMode.OpenModeView, 1919);

                String templateType = templateXml.SelectSingleNode("/tcm:Data/tcm:Type", namespaceManager).InnerText;

                if (!String.Equals(templateType, "CompoundTemplate", StringComparison.OrdinalIgnoreCase))
                    throw new NotSupportedException("Unsupported template type: " + templateType);

                String owningPublication = templateXml.SelectSingleNode("/tcm:Info/tcm:BluePrintInfo/tcm:OwningPublication/@xlink:href", namespaceManager).InnerText;
                String version = templateXml.SelectSingleNode("/tcm:Info/tcm:VersionInfo/tcm:Version", namespaceManager).InnerText;
                String revision = templateXml.SelectSingleNode("/tcm:Info/tcm:VersionInfo/tcm:Revision", namespaceManager).InnerText;
                String content = templateXml.SelectSingleNode("/tcm:Data/tcm:Content/tcm:PublisherScript", namespaceManager).InnerText;

                content = content.Replace("\n", "\r\n");

                TcmUri tcmPublication = new TcmUri(owningPublication);
                TcmUri tcmTemplate = new TcmUri(templateUri);

                TcmUri tcmParent = new TcmUri(tcmTemplate.ItemId, tcmTemplate.ItemType, tcmPublication.ItemId);

                int hashCode = 0;

                if (!String.IsNullOrEmpty(content))
                    hashCode = content.GetHashCode();

                return String.Format("{0}/{1}.{2}/{3:X}", tcmParent, version, revision, hashCode);
            }

            return String.Empty;
        }

        protected void Page_Load(object sender, EventArgs e)
        {
            // get the current logged in user
            string user = HttpContext.Current.User.Identity.Name;
            if (!String.IsNullOrEmpty(user))
            {
                // set LogonUser
                TridionTreeView.LogonUser = user;
            }

            // process querystring parameters
            string start = Request.QueryString["start"];
            string types = Request.QueryString["types"];
            string pubid = Request.QueryString["pubid"];

            if (!String.IsNullOrEmpty(start))
            {
                // override StartFromUri
                TridionTreeView.StartFromUri = start;
            }
            else if (!String.IsNullOrEmpty(pubid))
            {
                // override StartFromUri with current publication id
                TcmUri uri = new TcmUri(pubid);
                TridionTreeView.StartFromUri = uri.ToString();
            }

            if (!String.IsNullOrEmpty(types))
            {
                // override SelectTypes
                TridionTreeView.SelectTypes = Convert.ToInt32(types);
            }
        }

 protected ComponentLink GetComponentLink(TcmUri uri)
 {
     if (!_componentLinks.ContainsKey(uri.PublicationId))
     {
         _componentLinks.Add(uri.PublicationId, new ComponentLink(uri.PublicationId));
     }
     return _componentLinks[uri.PublicationId];
 }

 /// <summary>
 /// Add a new <see cref="T:Tridion.ContentManager.TcmUri"/> value to the current <see cref="T:Tridion.ContentManager.Templating.Package" />
 /// </summary>
 /// <param name="package"><see cref="T:Tridion.ContentManager.Templating.Package" /></param>
 /// <param name="name">Name.</param>
 /// <param name="value">Value.</param>
 public static void AddComponent(this Package package, String name, TcmUri value)
 {
     if (package != null)
     {
         Item packageItem = package.CreateTridionItem(ContentType.Component, value != null ? value : TcmUri.UriNull);
         package.PushItem(name, packageItem);
     }
 }

 public static TcmUri GetLocalUri(TcmUri uriPublication, TcmUri uriItem)
 {
    TcmUri uriReturn = new TcmUri(uriItem.ItemId, uriItem.ItemType, uriPublication.ItemId);
    TemplatingLogger log = TemplatingLogger.GetLogger(typeof(TemplateUtilities));
    log.Info("(getLocalUri)Old URI was:" + uriItem.ToString());
    log.Info("(getLocalUri)New URI is:" + uriReturn.ToString());
    return uriReturn;
 }

        public string GetContent(string uri, string templateUri = "")
        {
            var tcmUri = new TcmUri(uri);
            string urlParameters = string.IsNullOrEmpty(templateUri) ?
                string.Format("{0}/GetContent/{1}/{2}", controller, tcmUri.PublicationId, tcmUri.ItemId) :
                string.Format("{0}/GetContent/{1}/{2}/{3}", controller, tcmUri.PublicationId, tcmUri.ItemId, new TcmUri(templateUri).ItemId);

            return Execute<string>(urlParameters);
        }

        public string ResolveLink(string sourcePageUri, string componentUri, string excludeComponentTemplateUri)
        {
            
            var compUri = new TcmUri(componentUri);
            var pageUri = new TcmUri(sourcePageUri);
            var templateUri = new TcmUri(excludeComponentTemplateUri);

            string urlParameters = string.Format("{0}/ResolveLink/{1}/{2}/{3}/{4}", controller, PublicationId, pageUri.ItemId, compUri.ItemId, templateUri.ItemId);
            return Execute<string>(urlParameters);
        }

        public string GetContent(string uri, string templateUri = "")
        {
            LoggerService.Debug(">>GetContent({0})", LoggingCategory.Performance, uri);

            TcmUri tcmUri = new TcmUri(uri);

            TcmUri templateTcmUri = new TcmUri(templateUri);

            T.ComponentPresentationFactory cpFactory = GetComponentPresentationFactory(tcmUri.PublicationId);

            T.ComponentPresentation cp = null;

            if (!String.IsNullOrEmpty(templateUri))
            {
                cp = cpFactory.GetComponentPresentation(tcmUri.ItemId, templateTcmUri.ItemId);
                if (cp != null)
                    return cp.Content;
            }

            if (!string.IsNullOrEmpty(selectByComponentTemplateId))
            {
                cp = cpFactory.GetComponentPresentation(tcmUri.ItemId, Convert.ToInt32(selectByComponentTemplateId));
                if (cp != null)
                {
                    LoggerService.Debug("<<GetContent({0}) - by ct id", LoggingCategory.Performance, uri);
                    return cp.Content;
                }
            }
            if (!string.IsNullOrEmpty(selectByOutputFormat))
            {
                cp = cpFactory.GetComponentPresentationWithOutputFormat(tcmUri.ItemId, selectByOutputFormat);
                if (cp != null)
                {
                    LoggerService.Debug("<<GetContent({0}) - by output format", LoggingCategory.Performance, uri);
                    return cp.Content;
                }
            }

            LoggerService.Debug("GetContent: about to get component presentations with Highst Priority for {0}", LoggingCategory.Performance, tcmUri.ToString());
            cp = cpFactory.GetComponentPresentationWithHighestPriority(tcmUri.ItemId);
            LoggerService.Debug("GetContent: get component presentations with Highst Priority for {0}", LoggingCategory.Performance, tcmUri.ToString());
            if (cp != null)
                return cp.Content;
            //foreach (Tridion.ContentDelivery.DynamicContent.ComponentPresentation _cp in cps)
            //{
            //    if (_cp != null)
            //    {
            //        LoggerService.Debug("<<GetContent({0}) - find all", LoggingCategory.Performance, uri);
            //        return _cp.Content;
            //    }
            //}

            LoggerService.Debug("<<GetContent({0}) - not found", LoggingCategory.Performance, uri);
            return string.Empty;
        }

        public string ResolveLink(string componentUri)
        {
            TcmUri uri = new TcmUri(componentUri);

            if (!uri.Equals(emptyTcmUri))
            {
                Link link = componentLink.GetLink(uri.ToString());
                return link.IsResolved ? link.Url : null;
            }
    
            return null;
        }

 public bool IsSiteEditEnabled(ITridionItemData item)
 {
     int publicationId = 0;
     try
     {
         publicationId = new TcmUri(item.TcmUri).PublicationId;
     }
     catch (Exception)
     {
         publicationId = 0;
     }
     return IsSiteEditEnabled(publicationId);
 }

        private void CreateBinaryLink(XmlDocument xmlContent, XmlNode node, TcmUri item, Component c)
        {
            _package.PushItem(_package.CreateMultimediaItem(item));
            Binary binary = _engine.PublishingContext.RenderedItem.AddBinary(c, "");
            node.Attributes.RemoveAll();
            String publishedPath = GetUrlForBinary(binary.Url);
            XmlAttribute attr = xmlContent.CreateAttribute("href");
            attr.Value = publishedPath;
            node.Attributes.SetNamedItem(attr);

            attr = xmlContent.CreateAttribute("title");
            attr.Value = c.Title;
            node.Attributes.SetNamedItem(attr);
        }

        /// <summary>
        /// Get all urls of published pages
        /// </summary>
        /// <param name="includeExtensions"></param>
        /// <param name="pathStarts"></param>
        /// <param name="publicationID"></param>
        /// <returns></returns>
        public string[] GetAllPublishedPageUrls(string[] includeExtensions, string[] pathStarts)
        {
            Query pageQuery = new Query();
            ItemTypeCriteria isPage = new ItemTypeCriteria(64);  // TODO There must be an enum of these somewhere
            PublicationCriteria currentPublication = new PublicationCriteria(PublicationId); //Todo: add logic to determine site on url

            Criteria pageInPublication = CriteriaFactory.And(isPage, currentPublication);

            if (includeExtensions.Length > 0)
            {
                PageURLCriteria[] extensionsCriteria = new PageURLCriteria[includeExtensions.Length];
                int criteriaCount = 0;
                foreach (string pageExtension in includeExtensions)
                {
                    extensionsCriteria.SetValue(new PageURLCriteria("%" + pageExtension, Criteria.Like), criteriaCount);
                    criteriaCount++;
                }

                Criteria allExtensions = CriteriaFactory.Or(extensionsCriteria);
                pageInPublication = CriteriaFactory.And(pageInPublication, allExtensions);
            }

            if (pathStarts.Length > 0)
            {
                PageURLCriteria[] pathCriteria = new PageURLCriteria[pathStarts.Length];
                int criteriaCount = 0;
                foreach (string requiredPath in pathStarts)
                {
                    pathCriteria.SetValue(new PageURLCriteria(requiredPath + "%", Criteria.Like), criteriaCount);
                    criteriaCount++;
                }

                Criteria allPaths = CriteriaFactory.Or(pathCriteria);
                pageInPublication = CriteriaFactory.And(pageInPublication, allPaths);
            }

            Query findPages = new Query(pageInPublication);
            string[] pageUris = findPages.ExecuteQuery();

            // Need to get PageMeta data to find all the urls
            List<string> pageUrls = new List<string>();
            foreach (string uri in pageUris)
            {
                TcmUri tcmUri = new TcmUri(uri);
                PageMetaFactory metaFactory = GetPageMetaFactory(tcmUri.PublicationId);
                IPageMeta currentMeta = metaFactory.GetMeta(uri);
                pageUrls.Add(currentMeta.UrlPath);
            }
            return pageUrls.ToArray();
        }

        /// <summary>
        /// Returns the Component contents which could be found. Components that couldn't be found don't appear in the list. 
        /// </summary>
        /// <param name="componentUris"></param>
        /// <returns></returns>
        public List<string> GetContentMultiple(string[] componentUris)
        {
            TcmUri uri = new TcmUri(componentUris.First());
            ComponentPresentationFactory cpFactory = new ComponentPresentationFactory(uri.PublicationId);
            var components =
                componentUris
                .Select(componentUri => (Tridion.ContentDelivery.DynamicContent.ComponentPresentation)cpFactory.FindAllComponentPresentations(componentUri)[0])
                .Where(cp => cp != null)
                .Select(cp => cp.Content)
                .ToList();

            return components;

        }

        /// <summary>
        /// Get 'current' PublishTransaction. It tries to identify a PublishTransaction from the publish queue that is on the 
        /// given TcmUri, Publication, User, etc.
        /// </summary>
        /// <param name="engine">Engine object</param>
        /// <param name="tcmUri">String representing the tcmuri of the item to check</param>
        /// <returns>PublishTransaction if found; or null, otherwise</returns>
        public static PublishTransaction GetPublishTransaction(Engine engine, String tcmUri)
        {
            String binaryPath = engine.PublishingContext.PublishInstruction.RenderInstruction.BinaryStoragePath;
            Regex tcmRegex = new Regex(@"tcm_\d+-\d+-66560");
            Match match = tcmRegex.Match(binaryPath);

            if (match.Success)
            {
                String transactionId = match.Value.Replace('_', ':');
                TcmUri transactionUri = new TcmUri(transactionId);
                return new PublishTransaction(transactionUri, engine.GetSession());
            }
            return FindPublishTransaction(engine, tcmUri);
        }

        public IDictionary<string, IComponentMeta> FindComponentMetas(string[] schemaUris, DateTime sinceLastPublished)
        {
            int pubId = new TcmUri(schemaUris.First()).PublicationId;
            string[] componentMetas;
            using (var client = new TridionBrokerServiceClient())
            {
                componentMetas = client.FindLatestComponentMetasBySchemas(schemaUris, sinceLastPublished);
            }

            return
                componentMetas
                .Select(metaXml => XElement.Parse(metaXml))
                .ToDictionary(k => String.Format("tcm:{0}-{1}", pubId, k.Element("Id").Value), v => CreateComponentMeta(v));
        }