Esempio n. 1
0
        public async Task GenerationWorks()
        {
            var sourceFiles = ImagesFolder.EnumerateFiles().Where(d => ValidExtensions.Contains(d.Extension)).ToArray();

            var testFile = new FileInfo(@"Test.epub");

            using (var stream = testFile.Open(FileMode.Create))
                using (var writer = new EPUBWriter(stream))
                {
                    foreach (var i in sourceFiles)
                    {
                        using (var pageStream = i.OpenRead())
                        {
                            if (i.Name == CoverImageName)
                            {
                                await writer.SetCoverAsync(pageStream, true);
                            }
                            else
                            {
                                await writer.AddPageAsync(pageStream, i.Name);
                            }
                        }
                    }

                    SetMetadata(writer.Metadata);
                }
        }
Esempio n. 2
0
        private async Task AddImageToEpub(EPUBWriter writer, FileInfo imageFile, bool asCover)
        {
            if (!imageFile.Exists)
            {
                Console.WriteLine($"{imageFile.FullName} not found");
            }

            try
            {
                using (var imageStream = imageFile.OpenRead())
                {
                    if (asCover)
                    {
                        await writer.SetCoverAsync(imageStream, false, !IgnoreCoverAspectRatio);
                    }
                    else
                    {
                        await writer.AddPageAsync(imageStream);
                    }
                }
            }
            catch (Exception e)
            {
                throw new Exception($"Unable to add {imageFile.FullName} to epub.\n{e.Message}");
            }
        }
Esempio n. 3
0
        private async Task <int> OnExecuteAsync()
        {
            if (string.IsNullOrEmpty(OutputPath))
            {
                Console.WriteLine("Specify an output file");
                return(-1);
            }

            var outputFile = new FileInfo(OutputPath);
            var tempFile   = new FileInfo(OutputPath + "_part");

            if (tempFile.Exists)
            {
                tempFile.Delete();
                tempFile.Refresh();
            }

            Console.WriteLine($"Generating {outputFile.Name}");

            var targetFiles = GenerateTargetFilesList();

            if (!targetFiles.pages.Any())
            {
                Console.WriteLine("No images for pages found");
                return(-1);
            }

            try
            {
                using (var outStream = tempFile.Open(FileMode.Create))
                    using (var writer = new EPUBWriter(outStream))
                    {
                        var metadata = writer.Metadata;
                        metadata.Title              = !string.IsNullOrEmpty(Title) ? Title : Path.GetFileNameWithoutExtension(outputFile.Name);
                        metadata.Author             = !string.IsNullOrEmpty(Author) ? Author : nameof(CPubMake);
                        metadata.Publisher          = !string.IsNullOrEmpty(Publisher) ? Publisher : nameof(CPubMake);
                        metadata.Description        = Description;
                        metadata.RightToLeftReading = RightToLeftReading;
                        if (!string.IsNullOrEmpty(Tags))
                        {
                            foreach (var i in Tags.Split(',').Select(d => d.Trim()))
                            {
                                metadata.Tags.Add(i);
                            }
                        }

                        if (Metadata != null)
                        {
                            foreach (var i in Metadata)
                            {
                                var components = i.Split('=');
                                if (components.Length == 2)
                                {
                                    metadata.Custom[components[0]] = components[1];
                                }
                            }
                        }

                        if (targetFiles.cover != null)
                        {
                            Console.Write("\r" + new string(' ', Console.WindowWidth) + "\r");
                            Console.Write("Adding cover");
                            await AddImageToEpub(writer, targetFiles.cover, true);
                        }

                        var ctr = 1;
                        foreach (var i in targetFiles.pages)
                        {
                            Console.Write("\r" + new string(' ', Console.WindowWidth) + "\r");
                            Console.Write($"Adding image {ctr}/{targetFiles.pages.Count}");
                            await AddImageToEpub(writer, i, false);

                            ctr++;
                        }

                        Console.WriteLine(string.Empty);
                        await writer.FinalizeAsync();

                        await outStream.FlushAsync();
                    }
            }
            catch (Exception e)
            {
                Console.WriteLine(string.Empty);
                Console.WriteLine($"Error generating {outputFile.FullName}\n{e.Message}");
                return(-1);
            }

            tempFile.Refresh();
            tempFile.MoveTo(outputFile.FullName, true);
            return(0);
        }