/// <summary>Hash the file.</summary> /// <param name="contentItem">The content item.</param> /// <returns>The result file after the hash.</returns> internal ContentItem Hash(ContentItem contentItem) { var originRelativePath = contentItem.RelativeContentPath; var hashedFileName = contentItem.GetContentHash(this.context) + Path.GetExtension(originRelativePath); var destinationFilePath = this.GetDestinationFilePath(this.DestinationDirectory, hashedFileName, contentItem.RelativeContentPath); var hashedDestinationFolder = this.context.Configuration.DestinationDirectory ?? this.DestinationDirectory; var relativeHashedPath = destinationFilePath; if (!string.IsNullOrWhiteSpace(hashedDestinationFolder) && Path.IsPathRooted(relativeHashedPath)) { relativeHashedPath = relativeHashedPath.MakeRelativeToDirectory(hashedDestinationFolder); } contentItem = ContentItem.FromContentItem(contentItem, null, relativeHashedPath); // Do not overwrite if exists, since filename is md5 hash, filename changes if content changes. contentItem.WriteToRelativeHashedPath(hashedDestinationFolder); // Append to the log this.AppendToWorkLog(contentItem); // Return it as a result file. return(contentItem); }
/// <summary>The append to work log.</summary> /// <param name="hashedContentItem">The hashed content item.</param> /// <param name="originalFiles">The original files.</param> /// <returns>The hashed items.</returns> internal IEnumerable <ContentItem> AppendToWorkLog(ContentItem hashedContentItem, IEnumerable <string> originalFiles) { var hashedFiles = new List <ContentItem>(); foreach (var destinationFile in originalFiles) { var alternateHashedContentItem = ContentItem.FromContentItem(hashedContentItem, destinationFile); this.AppendToWorkLog(alternateHashedContentItem); hashedFiles.Add(alternateHashedContentItem); } return(hashedFiles); }
internal IEnumerable <ContentItem> Hash(ContentItem contentItem, IEnumerable <string> originalFiles) { var hashedFiles = new List <ContentItem>(); if (originalFiles.Any()) { var firstOriginalFile = originalFiles.FirstOrDefault(); var hashedContentItem = this.Hash(ContentItem.FromContentItem(contentItem, firstOriginalFile)); hashedFiles.Add(hashedContentItem); hashedFiles.AddRange(this.AppendToWorkLog(hashedContentItem, originalFiles.Skip(1))); } return(hashedFiles); }
/// <summary>The execute method for the activity under question.</summary> /// <param name="resultContentItemType">The result Content Type.</param> /// <returns>The <see cref="ContentItem"/> or null if it failed.</returns> internal ContentItem Execute(ContentItemType resultContentItemType = ContentItemType.Path) { if (string.IsNullOrWhiteSpace(this.OutputFile)) { throw new ArgumentException("AssemblerActivity - The output file path cannot be null or whitespace."); } var assembleType = Path.GetExtension(this.OutputFile); if (!string.IsNullOrWhiteSpace(assembleType)) { assembleType = assembleType.Trim('.'); } ContentItem contentItem = null; this.context.SectionedAction(SectionIdParts.AssemblerActivity, assembleType) .MakeCachable(new { this.Inputs, this.PreprocessingConfig, this.AddSemicolons, output = resultContentItemType == ContentItemType.Path ? this.OutputFile : null }) .RestoreFromCacheAction(cacheSection => { var cachedContentItem = cacheSection.GetCachedContentItem(CacheFileCategories.AssemblerResult); if (cachedContentItem == null) { return(false); } contentItem = ContentItem.FromContentItem( cachedContentItem, Path.GetFileName(this.OutputFile)); return(true); }) .Execute(cacheSection => { try { // Add source inputs this.Inputs.ForEach(this.context.Cache.CurrentCacheSection.AddSourceDependency); // Create if the directory does not exist. var outputDirectory = Path.GetDirectoryName(this.OutputFile); if (resultContentItemType == ContentItemType.Path && !string.IsNullOrWhiteSpace(outputDirectory)) { Directory.CreateDirectory(outputDirectory); } // set the semicolon flag to true so the first file doesn't get a semicolon added before it. // IF we are interesting in adding semicolons between bundled files (eg: JavaScript), then this flag // will get set after outputting each file, depending on whether or not that file ends in a semicolon. // the NEXT file will look at the flag and add one if the previous one didn't end in a semicolon. this.endedInSemicolon = true; contentItem = this.Bundle(resultContentItemType, outputDirectory, this.OutputFile, this.context.Configuration.SourceDirectory); cacheSection.AddResult(contentItem, CacheFileCategories.AssemblerResult); } catch (Exception exception) { throw new WorkflowException("AssemblerActivity - Error happened while executing the assembler activity", exception); } return(true); }); return(contentItem); }