Пример #1
0
// Write the File to io.Writer as xlsx
func (f *File) Write(writer io.Writer) (err error) {
	var parts map[string]string
	var zipWriter *zip.Writer

	parts, err = f.MarshallParts()
	if err != nil {
		return
	}

	zipWriter = zip.NewWriter(writer)

	for partName, part := range parts {
		var writer io.Writer
		writer, err = zipWriter.Create(partName)
		if err != nil {
			return
		}
		_, err = writer.Write([]byte(part))
		if err != nil {
			return
		}
	}

	err = zipWriter.Close()

	return
}
Пример #2
0
func AddMimetype(zippy *zip.Writer) {
	mimetype, err := zippy.Create("mimetype")
	if err != nil {
		log.Fatal(err)
	}
	WriteToFile(mimetype, "application/epub+zip")
}
Пример #3
0
func addtozip(z *zip.Writer, name string, f *os.File) {

	if fi, _ := f.Stat(); fi.IsDir() {
		log.Println("Adding folder", name)
		names, _ := f.Readdirnames(-1)
		for _, subname := range names {
			file, err := os.Open(filepath.Join(f.Name(), subname))
			if err != nil {
				log.Println(err)
				continue
			}
			addtozip(z, filepath.Join(name, subname), file)
			file.Close()
		}
	} else {
		log.Println("Adding file", name)
		fw, err := z.Create(name)
		if err != nil {
			panic(err)
		}
		_, err = io.Copy(fw, f)
		if err != nil {
			panic(err)
		}
	}
}
Пример #4
0
// Save the File to an xlsx file at the provided path.
func (f *File) Save(path string) (err error) {
	var parts map[string]string
	var target *os.File
	var zipWriter *zip.Writer

	parts, err = f.MarshallParts()
	if err != nil {
		return
	}

	target, err = os.Create(path)
	if err != nil {
		return
	}

	zipWriter = zip.NewWriter(target)

	for partName, part := range parts {
		var writer io.Writer
		writer, err = zipWriter.Create(partName)
		if err != nil {
			return
		}
		_, err = writer.Write([]byte(part))
		if err != nil {
			return
		}
	}
	err = zipWriter.Close()
	if err != nil {
		return
	}

	return target.Close()
}
Пример #5
0
// addIndexToZip generates an index.html file for the given Overlay and adds
// it to the provided zip file.
func addIndexToZip(c appengine.Context, z *zip.Writer, oKey *datastore.Key, o *Overlay) error {
	w, err := z.Create(fmt.Sprintf("%s/index.html", oKey.Encode()))
	if err != nil {
		return err
	}
	return zipTemplate.Execute(w, o)
}
Пример #6
0
// Copy any files from the includes directory
func copyIncludes(zw *zip.Writer, includes string) error {
	includes = path.Clean(includes)
	if !strings.HasSuffix(includes, "/") {
		includes += "/"
	}
	return filepath.Walk(includes, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if info.IsDir() {
			return nil
		}
		path = filepath.ToSlash(path)
		if w, err := zw.Create(strings.TrimPrefix(path, includes)); err != nil {
			return err
		} else {
			b, err := ioutil.ReadFile(path)
			if err != nil {
				return err
			} else {
				_, err := w.Write(b)
				if err != nil {
					return err
				}
			}
		}
		return nil
	})
}
Пример #7
0
func AddContainer(zippy *zip.Writer) {
	container, err := zippy.Create(path.Join("META-INF", "container.xml"))
	if err != nil {
		log.Fatal(err)
	}
	WriteToFile(container, "<?xml version=\"1.0\"?><container version=\"1.0\" xmlns=\"urn:oasis:names:tc:opendocument:xmlns:container\"><rootfiles><rootfile full-path=\"OEBPS/content.opf\" media-type=\"application/oebps-package+xml\"/></rootfiles></container>")
}
Пример #8
0
// Deal with files
func zipFile(srcFile string, recPath string, tw *zip.Writer, fi os.FileInfo) {
	if fi.IsDir() {
		//    	fmt.Println("??")
		// Create tar header
		/*
		   fh, err := zip.FileInfoHeader(fi)
		   if err != nil {
		       panic(err)
		   }
		   fh.Name = recPath // + "/"
		   err = tw.WriteHeader(hdr)
		   tw.Create(recPath)
		*/
	} else {
		// File reader
		fr, err := os.Open(srcFile)
		if err != nil {
			panic(err)
		}
		defer fr.Close()

		// Write hander
		w, err2 := tw.Create(recPath)
		if err2 != nil {
			panic(err)
		}
		// Write file data
		_, err = io.Copy(w, fr)
		if err != nil {
			panic(err)
		}
	}
}
Пример #9
0
func array2XlsxWriteSharedStrings(zw *zip.Writer, data [][]string) (err error) {
	siList := []xlsxSharedStringSi{{""}}
	for _, row := range data {
		for _, v1 := range row {
			if v1 == "" { //ignore blank cell can save space
				continue
			}
			siList = append(siList, xlsxSharedStringSi{v1})
		}
	}
	sst := xlsxSharedStringSst{
		Xmlns:  xmlNs,
		Count:  len(siList),
		SiList: siList,
	}
	thisW, err := zw.Create(sharedStringsFileName)
	_, err = thisW.Write([]byte(xml.Header))
	if err != nil {
		return
	}
	encoder := xml.NewEncoder(thisW)
	err = encoder.Encode(sst)
	if err != nil {
		return
	}
	return
}
Пример #10
0
func AddTitle(book_title string, book_author string, zippy *zip.Writer) {
	title, err := zippy.Create(path.Join("OEBPS", "title.xhtml"))
	if err != nil {
		log.Fatal(err)
	}

	WriteToFile(title, fmt.Sprintf("<html>\n\t<head>\n\t\t<title>%s</title>\n\t</head>\n\t<body>\n\t\t<center><h1>%s</h1>\n\t\t<h2>by %s</h2></center>\n\t</body>\n</html>", book_title, book_title, book_author))
}
Пример #11
0
func addZipFileMust(w *zip.Writer, path string) {
	d, err := ioutil.ReadFile(path)
	fataliferr(err)
	f, err := w.Create(filepath.Base(path))
	fataliferr(err)
	_, err = f.Write(d)
	fataliferr(err)
	// no need to close f. It's implicitly closed by the next Create() or Close() call
}
Пример #12
0
func copyFile(outzip *zip.Writer, name string, in *zip.File) {
	w, err := outzip.Create(name)
	must(err)
	r, err := in.Open()
	must(err)
	defer r.Close()
	_, err = io.Copy(w, r)
	must(err)
}
Пример #13
0
func walk(base, startPath string, zipWriter *zip.Writer) error {
	return filepath.Walk(startPath, func(path string, stat os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if stat.IsDir() {
			return nil
		}

		relativePath, err := filepath.Rel(startPath, path)
		if err != nil {
			return err
		}

		filePath := path
		if stat.Mode()&os.ModeSymlink != 0 {
			filePath, err = filepath.EvalSymlinks(path)
			if err != nil {
				return err
			}
			stat, err = os.Stat(filePath)
			if err != nil {
				return err
			}
			if stat.IsDir() {
				if err != nil {
					return err
				}
				return walk(Path.Join(base, ".", relativePath), filePath, zipWriter)
			}
		}

		name := Path.Join(base, filepath.ToSlash(relativePath))

		dbg("+", filePath, "=>", name)

		file, err := os.Open(filePath)
		if err != nil {
			return err
		}
		defer file.Close()

		writer, err := zipWriter.Create(name)
		if err != nil {
			return err
		}

		_, err = io.Copy(writer, file)
		if err != nil {
			return err
		}

		return nil
	})
}
Пример #14
0
func (w *Writer) writeFile(z *zip.Writer, s string, b []byte) error {
	f, err := z.Create(s)
	if err != nil {
		return err
	}

	_, err = f.Write(b)

	return err
}
Пример #15
0
func pack(z *zip.Writer, result *CheckResult) (err error) {
	var (
		f         io.Writer
		fnPattern = "%s.txt"
	)
	if f, err = z.Create(fmt.Sprintf(fnPattern, result.Date)); err != nil {
		return
	}
	f.Write(result.Data)
	return
}
Пример #16
0
func AddChapters(chapters []Chapter, zippy *zip.Writer) {
	chapter_fmt := "<html>\n\t<head>\n\t\t<title>%s</title>\n\t</head>\n\t<body>\n\t\t<center><h1>%s</h1></center>\n\t\t%s\n\t</body>\n</html>"

	for chapter := range chapters {
		chapter_filename := fmt.Sprintf("chapter%d.xhtml", chapter+1)
		chapter_file, err := zippy.Create(path.Join("OEBPS", chapter_filename))
		if err != nil {
			log.Fatal(err)
		}

		WriteToFile(chapter_file, fmt.Sprintf(chapter_fmt, chapters[chapter].Title, chapters[chapter].Title, chapters[chapter].Text))
	}
}
Пример #17
0
func appendToArchive(archive *zip.Writer, download URLDownload) error {
	if download.err != nil {
		return download.err
	}
	fileName := fileNameFromURL(download.url)
	w, err := archive.Create(fileName)
	if err != nil {
		return err
	}
	_, err = io.Copy(w, download.body)
	defer download.body.Close()
	return nil
}
Пример #18
0
func writeNodeJSShim(serviceName string,
	executableOutput string,
	lambdaAWSInfos []*LambdaAWSInfo,
	zipWriter *zip.Writer,
	logger *logrus.Logger) error {

	// Add the string literal adapter, which requires us to add exported
	// functions to the end of index.js.  These NodeJS exports will be
	// linked to the AWS Lambda NodeJS function name, and are basically
	// automatically generated pass through proxies to the golang HTTP handler.
	nodeJSWriter, err := zipWriter.Create("index.js")
	if err != nil {
		return errors.New("Failed to create ZIP entry: index.js")
	}
	nodeJSSource := _escFSMustString(false, "/resources/index.js")
	nodeJSSource += "\n// DO NOT EDIT - CONTENT UNTIL EOF IS AUTOMATICALLY GENERATED\n"

	handlerNames := make(map[string]bool, 0)
	for _, eachLambda := range lambdaAWSInfos {
		if _, exists := handlerNames[eachLambda.jsHandlerName()]; !exists {
			nodeJSSource += createNewNodeJSProxyEntry(eachLambda, logger)
			handlerNames[eachLambda.jsHandlerName()] = true
		}

		// USER DEFINED RESOURCES
		for _, eachCustomResource := range eachLambda.customResources {
			if _, exists := handlerNames[eachCustomResource.jsHandlerName()]; !exists {
				nodeJSSource += createUserCustomResourceEntry(eachCustomResource, logger)
				handlerNames[eachCustomResource.jsHandlerName()] = true
			}
		}
	}
	// SPARTA CUSTOM RESOURCES
	for _, eachCustomResourceName := range golangCustomResourceTypes {
		nodeJSSource += createNewSpartaCustomResourceEntry(eachCustomResourceName, logger)
	}

	// Finally, replace
	// 	SPARTA_BINARY_NAME = 'Sparta.lambda.amd64';
	// with the service binary name
	nodeJSSource += fmt.Sprintf("SPARTA_BINARY_NAME='%s';\n", executableOutput)
	// And the service name
	nodeJSSource += fmt.Sprintf("SPARTA_SERVICE_NAME='%s';\n", serviceName)
	logger.WithFields(logrus.Fields{
		"index.js": nodeJSSource,
	}).Debug("Dynamically generated NodeJS adapter")

	stringReader := strings.NewReader(nodeJSSource)
	_, copyErr := io.Copy(nodeJSWriter, stringReader)
	return copyErr
}
Пример #19
0
func AddTOC(title string, book_str string, chapters []Chapter, zippy *zip.Writer) {
	toc, err := zippy.Create(path.Join("OEBPS", "toc.ncx"))
	if err != nil {
		log.Fatal(err)
	}

	WriteToFile(toc, fmt.Sprintf("<?xml version=\"1.0\" encoding=\"UTF-8\"?><ncx xmlns=\"http://www.daisy.org/z3986/2005/ncx/\" version=\"2005-1\"><head><meta name=\"dtb:uid\" content=\"%s\"/><meta name=\"dtb:depth\" content=\"1\"/><meta name=\"dtb:totalPageCount\" content=\"0\"/><meta name=\"dtb:maxPageNumber\" content=\"0\"/></head><docTitle><text>%s</text></docTitle><navMap><navPoint id=\"title\" playOrder=\"1\"><navLabel><text>Title Page</text></navLabel><content src=\"title.xhtml\"/></navPoint>", book_str, title))

	for chapter := range chapters {
		WriteToFile(toc, fmt.Sprintf("<navPoint id=\"chapter%d\" playOrder=\"%d\"><navLabel><text>%s</text></navLabel><content src=\"chapter%d.xhtml\"/></navPoint>", chapter, chapter+2, chapters[chapter].Title, chapter))
	}

	WriteToFile(toc, "</navMap></ncx>")
}
Пример #20
0
// CreateNW creates a node-webkit .nw file
func (p Package) CreateNW(zw *zip.Writer, templates Templates, myapp io.Reader, includes string) error {
	// Add in a couple of package defaults
	p.Main = "index.html"
	p.EnvVar = nw.EnvVar

	if w, err := zw.Create("package.json"); err != nil {
		return err
	} else {
		if _, err := p.writeJsonTo(w); err != nil {
			return err
		}
	}

	filenameTemplates := map[string]string{
		"index.html": templates.IndexHtml,
		"client.js":  templates.ClientJs,
		"script.js":  templates.ScriptJs}
	for filename, str := range filenameTemplates {
		if w, err := zw.Create(filename); err != nil {
			return err
		} else {
			if t, err := template.New(filename).Parse(str); err != nil {
				return err
			} else {
				if err := t.Execute(w, p); err != nil {
					return err
				}
			}
		}
	}

	if includes != "" {
		if err := copyIncludes(zw, includes); err != nil {
			return err
		}
	}

	binHeader := zip.FileHeader{Name: p.Bin}
	binHeader.SetMode(0755) // Make it executable
	if w, err := zw.CreateHeader(&binHeader); err != nil {
		return err
	} else {
		if _, err := io.Copy(w, myapp); err != nil {
			return err
		}
	}

	return nil
}
Пример #21
0
func writeLines_To_ZipFile(lines []string, writer *zip.Writer, fileName string) {

	//Create a file in the zip file
	f, err := writer.Create(fileName)
	if err != nil {
		log.Fatal(err)
	}

	for _, line := range lines {
		_, err = f.Write([]byte(line + "\n"))
		if err != nil {
			log.Fatal(err)
		}
	}
}
Пример #22
0
func AddHeader(title string, author string, url string, chapters []Chapter, zippy *zip.Writer) {
	content, err := zippy.Create(path.Join("OEBPS", "content.opf"))
	if err != nil {
		log.Fatal(err)
	}

	WriteToFile(content, "<?xml version=\"1.0\"?><package version=\"2.0\" xmlns=\"http://www.idpf.org/2007/opf\" unique-identifier=\"BookId\"><metadata xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:opf=\"http://www.idpf.org/2007/opf\"><dc:title>")
	WriteToFile(content, title)
	WriteToFile(content, "</dc:title><dc:creator opf:role=\"aut\">")
	WriteToFile(content, author)
	WriteToFile(content, "</dc:creator><dc:language>en-US</dc:language><dc:identifier id=\"BookId\">urn:uuid:")
	WriteToFile(content, url)
	WriteToFile(content, "</dc:identifier></metadata>")

	AddContentHeader(content, chapters)
}
Пример #23
0
func archiveHook(context map[string]interface{},
	serviceName string,
	zipWriter *zip.Writer,
	awsSession *session.Session,
	noop bool,
	logger *logrus.Logger) error {

	logger.Info("Adding userResource")
	resourceFileName := "userResource.json"
	binaryWriter, binaryWriterErr := zipWriter.Create(resourceFileName)
	if nil != binaryWriterErr {
		return binaryWriterErr
	}
	userdataReader := strings.NewReader(userdataResourceContents)
	_, copyErr := io.Copy(binaryWriter, userdataReader)
	return copyErr
}
Пример #24
0
func (a *Archiver) addFile(filename string, zw *zip.Writer) error {
	file, err := os.Open(filename)
	if err != nil {
		return fmt.Errorf("failed opening %s: %s", filename, err)
	}
	defer file.Close()

	wr, err := zw.Create(filepath.Base(filename))
	if err != nil {
		return fmt.Errorf("failed creating entry for %s in zip file: %s", filename, err)
	}

	if _, err := io.Copy(wr, file); err != nil {
		return fmt.Errorf("failed writing %s to zip: %s", filename, err)
	}

	return nil
}
Пример #25
0
func array2XlsxWriteSheet1(zw *zip.Writer, data [][]string) (err error) {
	rowList := make([]xlsxRow, len(data))
	totalIndex := 1
	MaxCellIndex := 0
	for rowIndex, row := range data {
		rowList[rowIndex].C = make([]xlsxC, len(row))
		if len(row) > MaxCellIndex {
			MaxCellIndex = len(row) - 1
		}
		for cellIndex, v1 := range row {
			index := totalIndex
			if v1 == "" { //ignore blank cell can save space
				index = 0
			} else {
				totalIndex++
			}
			rowList[rowIndex].C[cellIndex] = xlsxC{
				R: CoordinateXy2Excel(cellIndex, rowIndex),
				T: "s",
				V: index,
			}
		}
	}
	sheetData := xlsxSheetData{
		Row: rowList,
	}
	thisW, err := zw.Create(sheel1FileName)
	xmlBytes, err := xml.Marshal(sheetData)
	if err != nil {
		return
	}
	err = sheelTpl.Execute(thisW, struct {
		MaxPosition string
		SheetData   string
	}{
		MaxPosition: CoordinateXy2Excel(MaxCellIndex, len(data)-1),
		SheetData:   string(xmlBytes),
	})
	if err != nil {
		return
	}
	return
}
Пример #26
0
// Write the File to io.Writer as xlsx
func (f *File) Write(writer io.Writer, fn func(total int, current int) string) (err error) {
	var parts map[string]string
	var zipWriter *zip.Writer

	parts, err = f.MarshallParts()
	if err != nil {
		return
	}

	zipWriter = zip.NewWriter(writer)

	count := 0
	for partName, part := range parts {
		var writer io.Writer
		writer, err = zipWriter.Create(partName)
		if err != nil {
			return
		}
		_, err = writer.Write([]byte(part))
		if err != nil {
			return
		}

		for {
			ctrl := fn(len(parts), count)
			if ctrl == "pause" {
				time.Sleep(1 * time.Second)
			} else if ctrl == "export" || ctrl == "resume" {
				break
			} else if ctrl == "cancel" {
				zipWriter.Close()
				return
			}
		}

		count++
	}

	fn(len(parts), len(parts))
	err = zipWriter.Close()

	return
}
Пример #27
0
func addFile(filename string, zw *zip.Writer) error {
	file, err := os.Open(filename)
	if err != nil {
		return fmt.Errorf("failed opening %s: %s", filename, err)
	}
	defer file.Close()

	wr, err := zw.Create(filename)
	if err != nil {
		return fmt.Errorf("failed creating entry for %s in zip file: %s", filename, err)
	}

	// Not checking how many bytes copied,
	// since we don't know the file size without doing more work
	if _, err := io.Copy(wr, file); err != nil {
		return fmt.Errorf("failed writing %s to zip: %s", filename, err)
	}

	return nil
}
Пример #28
0
// read, resize, crop and zip a 'screenshot' named 'name' into 'zipArchive'
func convert(zipFile *zip.Writer, infile io.Reader, filename string) error {
	img, err := png.Decode(infile)
	if err != nil {
		return err
	}

	resized := resize.Resize(0, TargetHeight, img, resize.Bicubic)
	croppedImg, _ := cutter.Crop(resized, cutter.Config{
		Width:  TargetWidth,
		Height: TargetHeight,
		Mode:   cutter.Centered,
	})

	zippedFile, err := zipFile.Create(filename)
	if err != nil {
		return err
	}

	return jpeg.Encode(zippedFile, croppedImg, JpegQuality)
}
Пример #29
0
// Función encargada de recorrer un directorio y agregar los archivos al ZIP
func walkDirectory(directory *os.File, zipWriter *zip.Writer) error {
	// Leemos contenido del directorio
	content, err := directory.Readdir(-1)
	if err != nil {
		return err
	}

	// Recorremos contenido del directorio
	for _, val := range content {
		if !val.IsDir() {
			// Es un archivo: anrimos el archivo y lo agregamos al Writer
			file, err := openPath(directory.Name() + "/" + val.Name())
			if err != nil {
				return err
			}

			// Agregamos un archivo al ZIP
			fileWriter, err := zipWriter.Create(file.Name())
			if err != nil {
				file.Close()
				return err
			}
			// Escrivimos sobre el nuevo archivo ZIP
			_, err = copyContent(file, fileWriter)
		} else {
			// Es un directorio: abrimos el directorio y recorremos su contenido
			dir, err := openPath(directory.Name() + "/" + val.Name())
			if err != nil {
				return err
			}
			err = walkDirectory(dir, zipWriter)
			if err != nil {
				return err
			}
		}
	}

	// Cerramos directorio
	directory.Close()
	return nil
}
Пример #30
0
// addTilesToZip fetches all the Tile records for a given Overlay, fetches
// their associated image blobs, and adds them to the provided zip file.
func addTilesToZip(c appengine.Context, z *zip.Writer, oKey *datastore.Key) error {
	base := oKey.Encode()
	q := datastore.NewQuery("Tile").Ancestor(oKey)
	for i := q.Run(c); ; {
		var t Tile
		if _, err := i.Next(&t); err == datastore.Done {
			break
		} else if err != nil {
			return err
		}
		name := fmt.Sprintf("%s/%d/%d/%d.png", base, t.Zoom, t.X, t.Y)
		w, err := z.Create(name)
		if err != nil {
			return err
		}
		if _, err = w.Write(t.Image); err != nil {
			return err
		}
	}
	return nil
}