Golang TypeByExtension示例

说明

golang typebyextension示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: mime

示例#1
文件: file_resource.go 项目: pombredanne/webmachine.go

func (p *FileResource) ContentTypesProvided(req Request, cxt Context) ([]MediaTypeHandler, Request, Context, int, os.Error) {
	frc := cxt.(FileResourceContext)
	var arr []MediaTypeHandler
	if frc.IsDir() {
		arr = []MediaTypeHandler{NewJsonDirectoryListing(frc.FullPath(), req.URL().Path), NewHtmlDirectoryListing(frc.FullPath(), req.URL().Path)}
	} else if frc.HasMultipleResources() {
		dir, _ := path.Split(frc.FullPath())
		filenames := frc.MultipleResourceNames()
		arr = make([]MediaTypeHandler, len(filenames))
		for i, filename := range filenames {
			extension := filepath.Ext(filename)
			mediaType := mime.TypeByExtension(extension)
			if len(mediaType) == 0 {
				// default to text/plain
				mediaType = MIME_TYPE_TEXT_PLAIN
			}
			fullFilename := path.Join(dir, filename)
			tempFrc := NewFileResourceContextWithPath(fullFilename)
			arr[i] = NewPassThroughMediaTypeHandler(mediaType, tempFrc, tempFrc.Len(), tempFrc.LastModified())
		}
	} else {
		extension := filepath.Ext(frc.FullPath())
		mediaType := mime.TypeByExtension(extension)
		if len(mediaType) == 0 {
			// default to text/plain
			mediaType = MIME_TYPE_TEXT_PLAIN
		}
		arr = []MediaTypeHandler{NewPassThroughMediaTypeHandler(mediaType, frc, frc.Len(), frc.LastModified())}
	}
	return arr, req, cxt, 0, nil
}

示例#2
文件: repository.go 项目: gophergala2016/sisho

func (s *Sisho) walkRepo() error {
	// * walk repo and generate constitution of repo.
	err := filepath.Walk(s.tmpDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if info.IsDir() {
			return nil
		}

		isGitDir, isGitDirErr := regexp.MatchString(s.tmpDir+"/.git/", path)
		if isGitDirErr != nil {
			return err
		}
		if isGitDir {
			return nil
		}

		tmp := strings.Split(path, "/")
		name := tmp[len(tmp)-1]
		ext := filepath.Ext(path)
		r := regexp.MustCompile(s.tmpDir + "/")

		if util.IsBinary(ext) {
			a := ContentAsset{
				Content: Content{
					path:         path,
					relativePath: r.ReplaceAllString(path, ""),
					name:         name,
					contentType:  mime.TypeByExtension(ext),
				},
				ext: ext,
			}
			s.assets = append(s.assets, a)
			return nil
		}

		c := Code{
			Content: Content{
				path:         path,
				relativePath: r.ReplaceAllString(path, ""),
				name:         name,
				contentType:  mime.TypeByExtension(ext),
			},
			Title:     "",
			TextLines: []string{},
		}
		s.contents = append(s.contents, c)
		return nil
	})

	if err == nil {
		return err
	}
	return nil
}

示例#3
文件: response.go 项目: jango2015/entropy

//设置ContentType
func (r Response) SetContentType(ext string) {
	var contentType string
	//判断传入的扩展名是否有.
	if !strings.HasPrefix(ext, ".") {
		ext = "." + ext
	}
	//如果能从系统mime中获取相应的type,则使用系统提供的mimetype;否则的话,将application/ext直接设置为content type
	if mime.TypeByExtension(ext) != "" {
		contentType = mime.TypeByExtension(ext)
	} else {
		contentType = "application/" + strings.TrimPrefix(ext, ".") + ";charset=utf-8"
	}
	r.SetHeader("Content-Type", contentType, true)
}

示例#4
文件: measure_indent.go 项目: zlongshen/diffmerge

func fileExtImpliesText(ext string) (yes, unknown bool) {
	defer func() {
		glog.V(2).Infof("'%s' -> yes=%v   unknown=%v", ext, yes, unknown)
	}()

	if ext == "" {
		unknown = true
		return
	}
	mt := mime.TypeByExtension(ext)
	if strings.HasPrefix(mt, "text/") ||
		strings.HasSuffix(mt, "+xml") ||
		strings.HasSuffix(mt, ".json") ||
		strings.HasSuffix(mt, "+json") {
		// Most likely text.
		yes = true
		glog.V(1).Infof("Most likely a text extension: %s", ext)
		return
	}
	if strings.HasPrefix(mt, "audio/") ||
		strings.HasPrefix(mt, "image/") ||
		strings.HasPrefix(mt, "video/") {
		// Almost certainly not text.
		glog.V(1).Infof("Most likely a binary extension: %s", ext)
		return
	}
	unknown = true
	return
}

示例#5
文件: proc.go 项目: janhelke/sys-file-indexer

// Slower operations to fill props struct
func (p *props) load(h hash.Hash, name string) *props {
	p.mime = mime.TypeByExtension(p.ext)
	r, err := os.Open(name)
	if err != nil {
		log.Print(name, ": Props: ", err)
		return p
	}
	defer r.Close()
	p.ftype = mapType(p.mime)
	// TODO: this is quite unreadable
	copy(p.chash[:], filehash(name, h, r))
	copy(p.dident[:], strhash(p.dir, h))
	// If the extension is empty, we need to detect
	// the MIME type via file contents
	if p.mime == "" {
		p.mime = sniffMIME(name, r)
	}
	// Non-images are completely processed at this point
	if !strings.HasPrefix(p.mime, "image/") {
		return p
	}
	// Image-specific processing
	if _, err := r.Seek(0, 0); err != nil {
		log.Print(name, ": Seek: ", err)
		return p
	}
	imgconf, _, err := image.DecodeConfig(r)
	if err != nil {
		log.Print(name, ": Image decoder: ", err)
		return p
	}
	p.isize = image.Point{imgconf.Width, imgconf.Height}
	return p
}

示例#6
文件: writeto.go 项目: uchti/gomail

func (w *messageWriter) addFiles(files []*file, isAttachment bool) {
	for _, f := range files {
		if _, ok := f.Header["Content-Type"]; !ok {
			mediaType := mime.TypeByExtension(filepath.Ext(f.Name))
			if mediaType == "" {
				mediaType = "application/octet-stream"
			}
			f.setHeader("Content-Type", mediaType+`; name="`+f.Name+`"`)
		}

		if _, ok := f.Header["Content-Transfer-Encoding"]; !ok {
			f.setHeader("Content-Transfer-Encoding", string(Base64))
		}

		if _, ok := f.Header["Content-Disposition"]; !ok {
			var disp string
			if isAttachment {
				disp = "attachment"
			} else {
				disp = "inline"
			}
			f.setHeader("Content-Disposition", disp+`; filename="`+f.Name+`"`)
		}

		if !isAttachment {
			if _, ok := f.Header["Content-ID"]; !ok {
				f.setHeader("Content-ID", "<"+f.Name+">")
			}
		}
		w.writeHeaders(f.Header)
		w.writeBody(f.CopyFunc, Base64)
	}
}

示例#7
文件: gui.go 项目: hdortez/syncthing

func embeddedStatic() func(http.ResponseWriter, *http.Request, *log.Logger) {
	var modt = time.Now().UTC().Format(http.TimeFormat)

	return func(res http.ResponseWriter, req *http.Request, log *log.Logger) {
		file := req.URL.Path

		if file[0] == '/' {
			file = file[1:]
		}

		bs, ok := auto.Assets[file]
		if !ok {
			return
		}

		mtype := mime.TypeByExtension(filepath.Ext(req.URL.Path))
		if len(mtype) != 0 {
			res.Header().Set("Content-Type", mtype)
		}
		res.Header().Set("Content-Length", fmt.Sprintf("%d", len(bs)))
		res.Header().Set("Last-Modified", modt)

		res.Write(bs)
	}
}

示例#8
文件: fs.go 项目: cnhup/httpmq

func (h *fsHandler) newFSFile(f *os.File, fileInfo os.FileInfo, compressed bool) (*fsFile, error) {
	n := fileInfo.Size()
	contentLength := int(n)
	if n != int64(contentLength) {
		f.Close()
		return nil, fmt.Errorf("too big file: %d bytes", n)
	}

	// detect content-type
	ext := fileExtension(fileInfo.Name(), compressed)
	contentType := mime.TypeByExtension(ext)
	if len(contentType) == 0 {
		data, err := readFileHeader(f, compressed)
		if err != nil {
			return nil, fmt.Errorf("cannot read header of the file %q: %s", f.Name(), err)
		}
		contentType = http.DetectContentType(data)
	}

	lastModified := fileInfo.ModTime()
	ff := &fsFile{
		h:               h,
		f:               f,
		contentType:     contentType,
		contentLength:   contentLength,
		compressed:      compressed,
		lastModified:    lastModified,
		lastModifiedStr: AppendHTTPDate(nil, lastModified),

		t: time.Now(),
	}
	return ff, nil
}

示例#9
文件: operations.go 项目: Blackfin/rclone

// Returns a guess at the mime type from the extension
func MimeType(o Object) string {
	mimeType := mime.TypeByExtension(path.Ext(o.Remote()))
	if mimeType == "" {
		mimeType = "application/octet-stream"
	}
	return mimeType
}

示例#10
文件: context.go 项目: peidachang/gos

func (ctx *Context) ContentType(ext string) {
	ctype := mime.TypeByExtension(ext)

	if ctype != "" {
		ctx.ResponseWriter.Header().Set("Content-Type", ctype)
	}
}

示例#11
文件: gui.go 项目: kat-co/juju

// serveCombo serves the GUI JavaScript and CSS files, dynamically combined.
func (h *guiHandler) serveCombo(w http.ResponseWriter, req *http.Request) {
	ctype := ""
	// The combo query is like /combo/?path/to/file1&path/to/file2 ...
	parts := strings.Split(req.URL.RawQuery, "&")
	paths := make([]string, 0, len(parts))
	for _, p := range parts {
		fpath, err := getGUIComboPath(h.rootDir, p)
		if err != nil {
			sendError(w, errors.Annotate(err, "cannot combine files"))
			return
		}
		if fpath == "" {
			continue
		}
		paths = append(paths, fpath)
		// Assume the Juju GUI does not mix different content types when
		// combining contents.
		if ctype == "" {
			ctype = mime.TypeByExtension(filepath.Ext(fpath))
		}
	}
	w.Header().Set("Content-Type", ctype)
	for _, fpath := range paths {
		sendGUIComboFile(w, fpath)
	}
}

示例#12
文件: site.go 项目: htruong/oryza

// Deploys a site to S3.
func (s *Site) Deploy(user, pass, url string) error {
	auth := aws.Auth{AccessKey: user, SecretKey: pass}
	b := s3.New(auth, aws.USEast).Bucket(url)

	// walks _site directory and uploads file to S3
	walker := func(fn string, fi os.FileInfo, err error) error {
		if fi.IsDir() {
			return nil
		}

		rel, _ := filepath.Rel(s.Dest, fn)
		typ := mime.TypeByExtension(filepath.Ext(rel))
		content, err := ioutil.ReadFile(fn)
		log.Printf(MsgUploadFile, rel)
		if err != nil {
			return err
		}

		// try to upload the file ... sometimes this fails due to amazon
		// issues. If so, we'll re-try
		if err := b.Put(rel, content, typ, s3.PublicRead); err != nil {
			time.Sleep(100 * time.Millisecond) // sleep so that we don't immediately retry
			return b.Put(rel, content, typ, s3.PublicRead)
		}

		// file upload was a success, return nil
		return nil
	}

	return filepath.Walk(s.Dest, walker)
}

示例#13
文件: s3.go 项目: Luzifer/s3sync

func (s *s3Provider) WriteFile(path string, content io.ReadSeeker, public bool) error {
	bucket, path, err := s.getBucketPath(path)
	if err != nil {
		return err
	}

	ext := filepath.Ext(path)
	mimeType := mime.TypeByExtension(ext)
	if mimeType == "" {
		mimeType = "application/octet-stream"
	}

	params := &s3.PutObjectInput{
		Bucket:      aws.String(bucket),
		Key:         aws.String(path),
		Body:        content,
		ContentType: aws.String(mimeType),
	}
	if public {
		params.ACL = aws.String("public-read")
	}
	_, err = s.conn.PutObject(params)

	return err
}

示例#14
文件: server.go 项目: kiloe/blobstore

// Copy form file to Blob
func upload(f *multipart.FileHeader) (b *blob.Blob, err error) {
	// Open
	upload, err := f.Open()
	if err != nil {
		return
	}
	defer upload.Close()
	// Create blob
	b = blob.New()
	// Set filename from request
	b.Name = f.Filename
	// Set content-type from request
	if ct := f.Header.Get("Content-Type"); ct != "" {
		b.ContentType = ct
	}
	// Guess content-type from extension if missing
	if b.ContentType == "" || b.ContentType == ApplicationOctetStream {
		if ext := filepath.Ext(b.Name); ext != "" {
			b.ContentType = mime.TypeByExtension(ext)
		}
	}
	if b.ContentType == "" {
		b.ContentType = ApplicationOctetStream
	}
	// Write
	err = b.WriteFrom(upload)
	if err != nil {
		return
	}
	return
}

示例#15
文件: form.go 项目: mshockwave/nthuaplus-backend

//File saving routines
func saveFile(header *multipart.FileHeader, r io.Reader) (string, error) {
	if client, err := storage.GetNewStorageClient(); err == nil {
		h := public.NewHashString()
		objName := storage.PathJoin(storage.APPLICATIONS_FOLDER_NAME, h)
		//Determine the extension
		var ext string = ""
		if header != nil {
			if segs := strings.Split(header.Filename, "."); len(segs) > 1 {
				ext = "." + segs[len(segs)-1]
				objName = (objName + ext)
			}
		}

		obj := client.GetDefaultBucket().Object(objName)
		objWriter := obj.NewWriter(client.Ctx)

		_, err = io.Copy(objWriter, r)
		objWriter.Close()
		if err == nil {

			if attr, e := obj.Attrs(client.Ctx); attr != nil && e == nil {
				if mimeStr := mime.TypeByExtension(ext); len(mimeStr) > 0 {
					attr.ContentType = mimeStr
					obj.Update(client.Ctx, *attr)
				}
			}

			return objName, nil
		} else {
			return "", err
		}
	} else {
		return "", err
	}
}

示例#16
文件: uploader.go 项目: cyarie/suchgopcandidatewow.com

func walkpath(path string, f os.FileInfo, err error) error {
	fi, err := os.Open(path)
	if err != nil {
		panic(err)
	}

	defer func() {
		if err := fi.Close(); err != nil {
			panic(err)
		}
	}()

	ext := filepath.Ext(path)
	// This tests if something is a directory; basically, look for a file extension. If that doesn't exist, assume
	// it's a directory and don't upload it to S3
	if len(ext) > 0 {
		key := path[2:len(path)]

		mtype := mime.TypeByExtension(ext)
		fmt.Println(key)

		err = s3Upload(&key, &bucket, fi, &mtype)
		if err != nil {
			panic(err)
		}
	} else {
		fmt.Println("Directory, skipping")
	}

	return err
}

示例#17
文件: fs2s3.go 项目: reedobrien/wpgo

func makeVisitor(uploads chan FileUpload, bucket *s3.Bucket, waiter *sync.WaitGroup, args args) func(string, os.FileInfo, error) error {
	return func(fpath string, f os.FileInfo, err error) error {
		node := isfile(f)
		if node {
			contType := mime.TypeByExtension(path.Ext(fpath))
			if contType == "" {
				contType = args.mimetype
			}
			fu := FileUpload{
				ContentType: contType,
				Path:        fpath,
				Bucket:      bucket,
			}
			if runtime.NumGoroutine() > concurrency {
				uploadFile(fu, args, nil)
			} else {
				waiter.Add(1)
				go uploadFile(fu, args, func() {
					waiter.Done()
				})
			}
		}
		return nil
	}
}

示例#18
文件: filecache.go 项目: youkebing/filecache

func (cache *FileCache) HttpWriteFile(w http.ResponseWriter, r *http.Request) {
	path, err := url.QueryUnescape(r.URL.String())
	if err != nil {
		http.ServeFile(w, r, r.URL.Path)
	} else if len(path) > 1 {
		path = path[1:len(path)]
	} else {
		http.ServeFile(w, r, ".")
		return
	}

	if cache.InCache(path) {
		itm := cache.items[path]
		ctype := http.DetectContentType(itm.Access())
		mtype := mime.TypeByExtension(filepath.Ext(path))
		if mtype != "" && mtype != ctype {
			ctype = mtype
		}
		w.Header().Set("content-length", fmt.Sprintf("%d", itm.Size))
		w.Header().Set("content-disposition",
			fmt.Sprintf("filename=%s", filepath.Base(path)))
		w.Header().Set("content-type", ctype)
		w.Write(itm.Access())
		return
	}
	go cache.Cache(path)
	http.ServeFile(w, r, path)
}

示例#19
文件: main.go 项目: go-experimental/mongo-me

// FileServerHandler function
func FileServerHandler(c *echo.Context) error {
	fileType := mime.TypeByExtension(filepath.Ext(filepath.Base(c.Request().URL.String())))
	log.Println(c.Request().URL.String()[1:])
	c.Response().Header().Set("Content-Type", fileType)
	io.Copy(c.Response(), bytes.NewReader(staticFiles.Get(c.Request().URL.String()[1:])))
	return nil
}

示例#20
文件: views_publish.go 项目: CoolCloud/docker-bastion

func (v *Views) ServeHTTP(w http.ResponseWriter, r *http.Request, ss sessions.Session) {
	if v.Rewrite(w, r, ss) {
		// redirected
		return
	}
	var ok bool
	name := r.URL.Path[1:]
	if _, ok = v.Names[name]; !ok {
		name = v.Index
	}

	ext := path.Ext(name)
	ct := mime.TypeByExtension(ext)
	w.Header().Set("Content-Type", ct)

	data, _ := Asset(name)
	hdr := r.Header.Get("Accept-Encoding")
	if strings.Contains(hdr, "gzip") {
		w.Header().Set("Content-Encoding", "gzip")
		w.Write(data)
	} else {
		gz, err := gzip.NewReader(bytes.NewBuffer(data))
		if err != nil {
			w.Write([]byte(err.Error()))
			return
		}
		io.Copy(w, gz)
		gz.Close()
	}
}

示例#21
文件: submit.go 项目: netroby/seaweedfs

func newFilePart(fullPathFilename string) (ret FilePart, err error) {
	fh, openErr := os.Open(fullPathFilename)
	if openErr != nil {
		glog.V(0).Info("Failed to open file: ", fullPathFilename)
		return ret, openErr
	}
	ret.Reader = fh

	if fi, fiErr := fh.Stat(); fiErr != nil {
		glog.V(0).Info("Failed to stat file:", fullPathFilename)
		return ret, fiErr
	} else {
		ret.ModTime = fi.ModTime().UTC().Unix()
		ret.FileSize = fi.Size()
	}
	ext := strings.ToLower(path.Ext(fullPathFilename))
	ret.IsGzipped = ext == ".gz"
	if ret.IsGzipped {
		ret.FileName = fullPathFilename[0 : len(fullPathFilename)-3]
	}
	ret.FileName = fullPathFilename
	if ext != "" {
		ret.MimeType = mime.TypeByExtension(ext)
	}

	return ret, nil
}

示例#22
文件: action.go 项目: Schezuk/strapdown-zeta

func (this *RequestContext) Static(version string) error { // host static files
	var mimetype string
	lastdot := strings.LastIndex(this.path, ".")
	if lastdot > -1 {
		mimetype = mime.TypeByExtension(this.path[lastdot:])
	}
	w := *this.res

	var content []byte
	var err error

	if len(version) > 0 {
		content, err = getFileOfVersion(this.path, version)
	} else {
		content, err = ioutil.ReadFile(this.path)
	}
	if mimetype == "" {
		if len(content) == 0 {
			mimetype = "text/plain"
		} else {
			mimetype = http.DetectContentType(content)
		}
	}

	if err != nil {
		return err
	}
	w.Header().Set("Content-Type", mimetype)
	w.Write(content)

	return nil
}

示例#23
文件: repos_releases.go 项目: quixoten/vault

// UploadReleaseAsset creates an asset by uploading a file into a release repository.
// To upload assets that cannot be represented by an os.File, call NewUploadRequest directly.
//
// GitHub API docs : http://developer.github.com/v3/repos/releases/#upload-a-release-asset
func (s *RepositoriesService) UploadReleaseAsset(owner, repo string, id int, opt *UploadOptions, file *os.File) (*ReleaseAsset, *Response, error) {
	u := fmt.Sprintf("repos/%s/%s/releases/%d/assets", owner, repo, id)
	u, err := addOptions(u, opt)
	if err != nil {
		return nil, nil, err
	}

	stat, err := file.Stat()
	if err != nil {
		return nil, nil, err
	}
	if stat.IsDir() {
		return nil, nil, errors.New("the asset to upload can't be a directory")
	}

	mediaType := mime.TypeByExtension(filepath.Ext(file.Name()))
	req, err := s.client.NewUploadRequest(u, file, stat.Size(), mediaType)
	if err != nil {
		return nil, nil, err
	}

	asset := new(ReleaseAsset)
	resp, err := s.client.Do(req, asset)
	if err != nil {
		return nil, resp, err
	}
	return asset, resp, err
}

示例#24
文件: file.go 项目: toksea/iris

// TypeByExtension returns the MIME type associated with the file extension ext.
// The extension ext should begin with a leading dot, as in ".html".
// When ext has no associated type, TypeByExtension returns "".
//
// Extensions are looked up first case-sensitively, then case-insensitively.
//
// The built-in table is small but on unix it is augmented by the local
// system's mime.types file(s) if available under one or more of these
// names:
//
//   /etc/mime.types
//   /etc/apache2/mime.types
//   /etc/apache/mime.types
//
// On Windows, MIME types are extracted from the registry.
//
// Text types have the charset parameter set to "utf-8" by default.
func TypeByExtension(fullfilename string) (t string) {
	ext := filepath.Ext(fullfilename)
	//these should be found by the windows(registry) and unix(apache) but on windows some machines have problems on this part.
	if t = mime.TypeByExtension(ext); t == "" {
		// no use of map here because we will have to lock/unlock it, by hand is better, no problem:
		if ext == ".json" {
			t = "application/json"
		} else if ext == ".zip" {
			t = "application/zip"
		} else if ext == ".3gp" {
			t = "video/3gpp"
		} else if ext == ".7z" {
			t = "application/x-7z-compressed"
		} else if ext == ".ace" {
			t = "application/x-ace-compressed"
		} else if ext == ".aac" {
			t = "audio/x-aac"
		} else if ext == ".ico" { // for any case
			t = "image/x-icon"
		} else {
			t = ContentBINARY
		}
	}
	return
}

示例#25
文件: assest.go 项目: hidu/goutils

func (statics *AssestStruct) FileHandlerFunc(name string) http.HandlerFunc {
	if strings.Contains(name, "private") {
		return http.NotFound
	}
	static, err := statics.GetAssestFile(name)
	return func(w http.ResponseWriter, r *http.Request) {
		if err != nil {
			http.NotFound(w, r)
			return
		}
		modtime := time.Unix(static.Mtime, 0)
		modifiedSince := r.Header.Get("If-Modified-Since")
		if modifiedSince != "" {
			t, err := time.Parse(http.TimeFormat, modifiedSince)
			if err == nil && modtime.Before(t.Add(1*time.Second)) {
				w.Header().Del("Content-Type")
				w.Header().Del("Content-Length")
				w.Header().Set("Last-Modified", modtime.UTC().Format(http.TimeFormat))
				w.WriteHeader(http.StatusNotModified)
				return
			}
		}

		mimeType := mime.TypeByExtension(filepath.Ext(static.Name))
		if mimeType != "" {
			w.Header().Set("Content-Type", mimeType)
		}
		w.Header().Set("Last-Modified", modtime.UTC().Format(http.TimeFormat))
		w.Write([]byte(static.Content))
	}
}

示例#26
文件: rssbot.go 项目: 3ehzad/go-bots

// Guess image mime types from gif/jpeg/png/webp
func guessImageMimeTypes(r io.Reader) string {
	format, err := guessImageFormat(r)
	if format == "" || err != nil {
		return ""
	}
	return mime.TypeByExtension("." + format)
}

示例#27
文件: file_info.go 项目: r0b0ticus/platform

func GetInfoForBytes(filename string, data []byte) (*FileInfo, *AppError) {
	size := len(data)

	var mimeType string
	extension := filepath.Ext(filename)
	isImage := IsFileExtImage(extension)
	if isImage {
		mimeType = GetImageMimeType(extension)
	} else {
		mimeType = mime.TypeByExtension(extension)
	}

	hasPreviewImage := isImage
	if mimeType == "image/gif" {
		// just show the gif itself instead of a preview image for animated gifs
		if gifImage, err := gif.DecodeAll(bytes.NewReader(data)); err != nil {
			return nil, NewLocAppError("GetInfoForBytes", "model.file_info.get.gif.app_error", nil, "filename="+filename)
		} else {
			hasPreviewImage = len(gifImage.Image) == 1
		}
	}

	return &FileInfo{
		Filename:        filename,
		Size:            size,
		Extension:       extension[1:],
		MimeType:        mimeType,
		HasPreviewImage: hasPreviewImage,
	}, nil
}

示例#28
文件: static.go 项目: mokelab/pkgname

func (s *staticDB) Put(file *os.File, size int) error {
	s.lock.Lock()
	defer s.lock.Unlock()

	if _, ok := s.assets[file.Name()]; ok {
		return fmt.Errorf("file already known, %q", file.Name())
	}

	buf := bytes.NewBuffer(nil)

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

	data := buf.Bytes()

	mimetype := mime.TypeByExtension(filepath.Ext(file.Name()))
	if mimetype == "" {
		log.Printf("[INFO] Couldn't detect mimetype from exntension, sniffing content: %q", file.Name())
		mimetype = http.DetectContentType(data)
	}
	log.Printf("[INFO] Mimetype of %q: %q", file.Name(), mimetype)

	h := md5.New()
	_, _ = h.Write(data)

	s.assets[file.Name()] = &asset{
		md5hex:   hex.EncodeToString(h.Sum(nil)),
		content:  data,
		mimetype: mimetype,
	}

	return nil
}

示例#29
文件: gui.go 项目: wmwwmv/syncthing

func (s embeddedStatic) mimeTypeForFile(file string) string {
	// We use a built in table of the common types since the system
	// TypeByExtension might be unreliable. But if we don't know, we delegate
	// to the system.
	ext := filepath.Ext(file)
	switch ext {
	case ".htm", ".html":
		return "text/html"
	case ".css":
		return "text/css"
	case ".js":
		return "application/javascript"
	case ".json":
		return "application/json"
	case ".png":
		return "image/png"
	case ".ttf":
		return "application/x-font-ttf"
	case ".woff":
		return "application/x-font-woff"
	case ".svg":
		return "image/svg+xml"
	default:
		return mime.TypeByExtension(ext)
	}
}

示例#30
文件: test.go 项目: phpor/beegoexample

// @router /test/file/download [get]
func (c *TestController) Download() {
	filename := c.GetString("name")
	if filename == "" {
		http.Error(c.Ctx.ResponseWriter, "Not Found", 404)
		return
	}
	filename = fileDir + filename
	_, err := os.Stat(filename)
	if os.IsNotExist(err) {
		http.Error(c.Ctx.ResponseWriter, "Not Found", 404)
		return
	}

	ctype := mime.TypeByExtension(filepath.Ext(filename))
	if ctype == "" {
		ctype = "application/oct-stream"
	}
	en := context.ParseEncoding(c.Ctx.Request)
	if en != "" {
		c.Ctx.ResponseWriter.Header().Set("Content-Encoding", en)
	}
	c.Ctx.ResponseWriter.Header().Set("Content-Type", ctype)

	f, err := os.Open(filename)
	context.WriteFile(en, c.Ctx.ResponseWriter, f)
}

展开阅读全文