예제 #1
0
파일: Zip.cs 프로젝트: HimmaTong/exult
        public override bool Execute()
        {
            WarnIfUneven(Tuple.Create("Prefixes", Prefixes), Tuple.Create("Suffixes", Suffixes), Tuple.Create("Outputs", Outputs));
            foreach (var tuple in Zip(Prefixes, Suffixes, Outputs))
            {
                ITaskItem prefix = tuple.Item1;
                ITaskItem suffix = tuple.Item2;
                ITaskItem output = tuple.Item3;

                DateTime prefixUpdated = prefix.GetTimestamp();
                DateTime suffixUpdated = suffix.GetTimestamp();

                Log.LogMessage(MessageImportance.High, "Appending");
                Log.LogMessage(MessageImportance.Normal, "Prefix: {0}", Path.GetFileName(prefix.ItemSpec));
                Log.LogMessage(MessageImportance.Normal, "Suffix: {0}", Path.GetFileName(suffix.ItemSpec));
                Log.LogMessage(MessageImportance.Normal, "Output: {0}", Path.GetFileName(output.ItemSpec));
                Log.LogMessage(MessageImportance.Normal, "Directory: {0}", Path.GetDirectoryName(prefix.ItemSpec));

                JoinModels.Join(
                    log: Log,
                    models: new[] { tuple.Item1, tuple.Item2 },
                    output: tuple.Item3);

                if (prefixUpdated > suffixUpdated)
                {
                    File.SetLastWriteTime(output.ItemSpec, prefixUpdated);
                }
                else
                {
                    File.SetLastWriteTime(output.ItemSpec, suffixUpdated);
                }
            }

            return(true);
        }
예제 #2
0
        public override bool Execute()
        {
            Log.LogMessage(MessageImportance.High, "Modeling Text Document(s)");
            WarnIfUneven(Tuple.Create("Downloads", Downloads), Tuple.Create("Documents", Documents), Tuple.Create("Uris", Uris), Tuple.Create("Models", Models));
            foreach (var tuple in Zip(Downloads, Documents, Uris, Models))
            {
                ITaskItem downloadInput = tuple.Item1;
                ITaskItem documentInput = tuple.Item2;
                ITaskItem uri           = tuple.Item3;
                ITaskItem modelOutput   = tuple.Item4;

                Log.LogMessage(MessageImportance.Normal, modelOutput.ItemSpec);
                modelOutput.RequireParentDirectory(Log);

                modelOutput.LoadCustomMetadataFrom(documentInput);

                Uri    u  = new Uri(uri.ItemSpec.Replace('\\', '/'));
                string us = u.ToString();

                modelOutput.SetMetadata("Uri", us);
                modelOutput.SetMetadata(FolderUriAlias ?? "FolderUri", us.Substring(0, us.Length - u.Segments.Last().Length));

                XslTransforms.Google.Documents.Text.ToModel(htmlPath: downloadInput.ItemSpec, modelPath: modelOutput.ItemSpec, metadata: modelOutput.GetAllMetadata());

                DateTime modified = downloadInput.GetTimestamp();
                File.SetLastWriteTime(modelOutput.ItemSpec, modified);
            }
            return(true);
        }
예제 #3
0
        public override bool Execute()
        {
            WarnIfUneven(Tuple.Create("LocalItems", LocalItems), Tuple.Create("S3ObjectTimestamps", S3ObjectTimestamps), Tuple.Create("Receipts", Receipts), Tuple.Create("S3Puts", S3Puts));
            foreach (var tuple in Zip(LocalItems, S3ObjectTimestamps, Receipts, S3Puts))
            {
                ITaskItem publish        = tuple.Item1;
                ITaskItem published      = tuple.Item2;
                ITaskItem receipt        = tuple.Item3;
                ITaskItem put            = tuple.Item4;
                DateTime  publishUpdated = publish.GetTimestamp();

                bool newPublish = !File.Exists(published.ItemSpec);

                if (newPublish ||                              //If this is a new publish
                    publishUpdated > published.GetTimestamp()) //Or there is an update
                {
                    put.RequireParentDirectory(Log);

                    File.Copy(publish.ItemSpec, put.ItemSpec, true);
                    put.Touch(publishUpdated);
                }

                //Add a publish receipt for building the RSS feed
                if (newPublish)
                {
                    receipt.Save(Log, publishUpdated);
                }
            }
            return(true);
        }
예제 #4
0
파일: Bind.cs 프로젝트: HimmaTong/exult
        public override bool Execute()
        {
            DateTime viewModelTimestamp = ViewModel.GetTimestamp();

            Log.LogMessage(MessageImportance.High, "Bind:");
            Log.LogMessage(MessageImportance.Normal, "ViewModel: {0}", ViewModel.ItemSpec);

            WarnIfUneven(Tuple.Create("Models", Models), Tuple.Create("Views", Views));
            foreach (var tuple in Zip(Models, Views))
            {
                ITaskItem model = tuple.Item1;
                ITaskItem view  = tuple.Item2;

                Log.LogMessage(MessageImportance.Normal, "Model: {0}", model.ItemSpec);
                Log.LogMessage(MessageImportance.Normal, "View: {0}", view.ItemSpec);

                DateTime modelTimestamp = model.GetTimestamp();

                view.RequireParentDirectory(Log);

                if (!XslTransforms.Bind(Log, modelPath: model.ItemSpec, viewModelPath: ViewModel.ItemSpec, viewPath: view.ItemSpec))
                {
                    return(false);
                }

                HtmlDocument doc = new HtmlDocument();
                doc.Load(view.ItemSpec);
                HtmlNode html = doc.DocumentNode.SelectSingleNode("//html");
                if (html != null)
                {
                    HtmlAttribute xvm = html.Attributes.FirstOrDefault(item => item.Name == "xmlns:xvm");
                    if (xvm != null)
                    {
                        xvm.Remove();
                        doc.Save(view.ItemSpec);
                    }
                }

                if (viewModelTimestamp > modelTimestamp)
                {
                    view.Touch(viewModelTimestamp);
                }
                else
                {
                    view.Touch(modelTimestamp);
                }
            }
            return(true);
        }
예제 #5
0
        private void DoDownload(Request documentsRequest, ITaskItem document, ITaskItem download)
        {
            string sourceFile      = document.ItemSpec;
            string targetFile      = download.ItemSpec;
            string targetDirectory = Path.GetDirectoryName(targetFile);

            Log.LogMessage(MessageImportance.High, "Downloading \"{0}\"", document.RequireTitle());
            Log.LogMessage(MessageImportance.Normal, "To \"{0}\"", targetDirectory);
            download.RequireParentDirectory(Log);

            if (!File.Exists(sourceFile))
            {
                throw new FileNotFoundException("Cannot find", sourceFile);
            }

            ResourceType resourceType = document.RequireResourceType();

            switch (resourceType)
            {
            case ResourceType.file:
                DoFileDownload(documentsRequest, document, targetFile);
                break;

            case ResourceType.document:
                DoDocumentDownload(documentsRequest, document, targetFile);
                break;

            default:
                throw new NotImplementedException(string.Format("Resource Type '{0}' is unsupported", resourceType));
            }

            DateTime updated = document.GetTimestamp();

            File.SetLastWriteTime(download.ItemSpec, updated);
            document.CopyMetadataTo(download);
        }
예제 #6
0
        public override bool Execute()
        {
            GDataCredentials credentials = GetDataCredentials();
            RequestSettings  settings    = new RequestSettings("code.google.com/p/exult/", credentials);

            settings.AutoPaging = true;
            settings.PageSize   = 100;

            List <ITaskItem> folderContent = new List <ITaskItem>();

            WarnIfUneven(Tuple.Create("Folders", Folders), Tuple.Create("FolderListings", FolderListings));
            foreach (var tuple in Zip(Folders, FolderListings))
            {
                if (_Cancelled)
                {
                    return(false);
                }

                ITaskItem folder        = tuple.Item1;
                ITaskItem folderListing = tuple.Item2;

                folder.LoadCustomMetadata();
                folder.RequireDocumentType(Document.DocumentType.Folder);

                //yada/hrm.folder -> yada/hrm/
                string folderPath = Path.Combine(Path.GetDirectoryName(folder.ItemSpec), Path.GetFileNameWithoutExtension(folder.ItemSpec));
                RequireDirectory(folderPath);
                PathMapping folderMapping = new PathMapping(folderPath);

                Request request = new Request(settings);

                string resourceId = folder.RequireResourceId();

                Log.LogMessage(MessageImportance.High, "Getting Folder Content \"{0}\"", folder.RequireTitlePath());
                Feed <Document> feed = request.GetFolderContent(resourceId);

                // this takes care of paging the results in
                List <Document> documents = feed.Entries.Where(item => item.Type != Document.DocumentType.Folder).ToList();
                Log.LogMessage(MessageImportance.Normal, "Found {0} Item(s)", documents.Count);

                DateTime folderTimestamp = folder.GetTimestamp();
                DateTime latestTimestamp = folderTimestamp;

                foreach (Document document in documents)
                {
                    if (_Cancelled)
                    {
                        return(false);
                    }

                    if (document.Updated > latestTimestamp)
                    {
                        latestTimestamp = document.Updated;
                    }
                    if (Pattern == null || PatternExpression.IsMatch(document.Title))
                    {
                        Log.LogMessage(MessageImportance.Normal, "Matched \"{0}\"", document.Title);
                        folderContent.Add(BuildContent(folder, document, folderMapping));
                    }
                    else
                    {
                        Log.LogMessage(MessageImportance.Low, "Skipped \"{0}\"", document.Title);
                    }
                }
                folder.CopyMetadataTo(folderListing);
                folderListing.Save(Log, latestTimestamp);
            }
            FolderContent = folderContent.ToArray();
            return(true);
        }
예제 #7
0
        public override void ExecuteItemSequence(string groupByValue, IEnumerable <Tuple <ITaskItem, ITaskItem, ITaskItem> > items)
        {
            var feed = new AtomFeed
            {
                Id        = new AtomId(new Uri(FeedId)),
                Title     = new AtomTextConstruct(FeedTitle ?? ""),
                UpdatedOn = DateTime.Now,
            };

            if (!string.IsNullOrWhiteSpace(FeedRights))
            {
                feed.Rights = new AtomTextConstruct(FeedRights);
            }

            if (!string.IsNullOrWhiteSpace(FeedIcon))
            {
                feed.Icon = new AtomIcon(new Uri(FeedIcon));
            }

            if (!string.IsNullOrWhiteSpace(FeedLogo))
            {
                feed.Logo = new AtomLogo(new Uri(FeedLogo));
            }

            if (!string.IsNullOrWhiteSpace(FeedSubtitle))
            {
                feed.Subtitle = new AtomTextConstruct(FeedSubtitle);
            }


            if (!string.IsNullOrWhiteSpace(FeedAuthors))
            {
                foreach (string author in FeedAuthors.Split(';').Select(item => item.Trim()))
                {
                    feed.Authors.Add(new AtomPersonConstruct(author));
                }
            }

            if (!string.IsNullOrWhiteSpace(FeedContributors))
            {
                foreach (string contributor in FeedContributors.Split(';').Select(item => item.Trim()))
                {
                    feed.Contributors.Add(new AtomPersonConstruct(contributor));
                }
            }

            if (!string.IsNullOrWhiteSpace(FeedCategories))
            {
                foreach (string category in FeedCategories.Split(';').Select(item => item.Trim()))
                {
                    feed.Categories.Add(new AtomCategory(category));
                }
            }

            if (FeedLinkRelationSelf != null)
            {
                var selfLink = new AtomLink
                {
                    Relation = "self",
                    Uri      = new Uri(FeedLinkRelationSelf)
                };
                feed.Links.Add(selfLink);
            }

            foreach (Tuple <ITaskItem, ITaskItem, ITaskItem> tuple in items.OrderByDescending(item => item.Item2.GetTimestamp()))
            {
                ITaskItem modelInput   = tuple.Item1;
                ITaskItem receiptInput = tuple.Item2;
                ITaskItem contentInput = tuple.Item3;

                modelInput.LoadCustomMetadata();

                DateTime receiptModified = receiptInput.GetTimestamp();
                var      entry           = new AtomEntry
                {
                    Id        = new AtomId(new Uri(modelInput.GetMetadata(EntryIdSelector ?? "Uri"))),
                    Title     = new AtomTextConstruct(modelInput.GetMetadata(EntryTitleSelector ?? "Title")),
                    UpdatedOn = receiptModified,
                    Summary   = new AtomTextConstruct(modelInput.GetMetadata(EntrySummarySelector ?? "Summary")),
                };

                if (string.IsNullOrWhiteSpace(entry.Title.Content))
                {
                    entry.Title.Content = tuple.Item1.ItemSpec;
                }
                if (string.IsNullOrWhiteSpace(entry.Summary.Content))
                {
                    entry.Summary.Content = entry.Title.Content;
                }

                if (contentInput.Exists())
                {
                    if (string.IsNullOrWhiteSpace(EntryContentEncoding))
                    {
                        entry.Content = new AtomContent(contentInput.ReadAllText());
                    }
                    else
                    {
                        entry.Content = new AtomContent(contentInput.ReadAllText(), EntryContentEncoding);
                    }

                    if (!string.IsNullOrWhiteSpace(EntryContentType))
                    {
                        entry.Content.ContentType = EntryContentType;
                    }
                }

                var alternateLink = new AtomLink
                {
                    Relation = "alternate",
                    Uri      = new Uri(modelInput.GetMetadata(EntryLinkAlternateSelector ?? "Uri"))
                };
                entry.Links.Add(alternateLink);
                feed.AddEntry(entry);
            }
            using (FileStream stream = File.OpenWrite(Output.ItemSpec))
            {
                SyndicationResourceSaveSettings s = new SyndicationResourceSaveSettings()
                {
                    CharacterEncoding = Encoding.UTF8
                };
                feed.Save(stream, s);
            }
        }
예제 #8
0
        private void DoDownload(Request documentsRequest, ITaskItem document, ITaskItem download)
        {
            string sourceFile = document.ItemSpec;
            string targetFile = download.ItemSpec;
            string targetDirectory = Path.GetDirectoryName(targetFile);
            Log.LogMessage(MessageImportance.High,"Downloading \"{0}\"", document.RequireTitle());
            Log.LogMessage(MessageImportance.Normal, "To \"{0}\"", targetDirectory);
            download.RequireParentDirectory(Log);

            if (!File.Exists(sourceFile))
            {
                throw new FileNotFoundException("Cannot find", sourceFile);
            }

            ResourceType resourceType = document.RequireResourceType();
            switch (resourceType)
            {
                case ResourceType.file:
                    DoFileDownload(documentsRequest, document, targetFile);
                    break;
                case ResourceType.document:
                    DoDocumentDownload(documentsRequest, document, targetFile);
                    break;
                default:
                    throw new NotImplementedException(string.Format("Resource Type '{0}' is unsupported", resourceType));
            }

            DateTime updated = document.GetTimestamp();
            File.SetLastWriteTime(download.ItemSpec, updated);
            document.CopyMetadataTo(download);
        }