Golang appengine-blobstore.UploadURL类(方法)实例源码

func handlePost(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	if r.Method != "GET" || r.URL.Path != "/post" {
		serve404(w)
		return
	}
	c := appengine.NewContext(r)
	u := user.Current(c)
	if u == nil {
		url, err := user.LoginURL(c, r.URL.String())
		if err != nil {
			serveError(c, w, err)
			return
		}
		w.Header().Set("Location", url)
		w.WriteHeader(http.StatusFound)
		return
	}
	if !user.IsAdmin(c) {
		serve404(w)
		return
	}
	uploadURL, err := blobstore.UploadURL(c, "/upload", nil)
	if err != nil {
		serveError(c, w, err)
		return
	}
	err = postTemplate.Execute(w, uploadURL)
	if err != nil {
		serveError(c, w, err)
	}
}

func SearchHandler(w http.ResponseWriter, r *http.Request) {
	data := make(map[string]string)
	c := appengine.NewContext(r)
	u := user.Current(c)
	if u != nil {
		data["Email"] = u.String()
		upload_url, upload_err := blobstore.UploadURL(c, "/upload")
		if upload_err != nil {
			c.Logf("blob store is disabled? %v", upload_err)
			data["Upload_Action"] = "/upload"
		} else {
			data["Upload_Action"] = upload_url.String()
		}
	} else {
		url, err := user.LoginURL(c, r.URL.String())
		if err != nil {
			http.Error(w, err.String(), http.StatusInternalServerError)
			return
		}
		data["Login_url"] = url
	}
	data["Base_person"] =
		"{\"name\": \"James Morrison\", \"Date of Birth\": [1981, 10, 2]}"

	template_err := searchTemplate.Execute(w, data)
	if template_err != nil {
		log.Print("Error rendering template ", template_err)
	}
}

func Index(w http.ResponseWriter, r *http.Request) {
	server := plate.NewServer()

	photos, err := photos_help.GetAll(r)
	if err != nil {
		photos = nil
	}

	albums, err := albums_help.GetAll(r)
	if err != nil {
		albums = nil
	}

	c := appengine.NewContext(r)
	uploadURL, _ := blobstore.UploadURL(c, "/admin/photos", nil)

	mux := menuMux.New()
	mux.AdminMenu("Photos")

	t, _ := server.Template(w)
	t.Bag["MenuItems"] = mux.GetItems()
	t.Bag["Photos"] = photos
	t.Bag["Albums"] = albums
	t.Bag["UploadURL"] = uploadURL
	t.Layout = "templates/admin/layout.html"
	files := []string{"templates/admin/sidebar.html", "templates/admin/photos/index.html"}
	t.DisplayMultiple(files)

}

// Generates an image upload url for the blobstore and returns it as a string
func GetBlobstoreUploadPath(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	userKeyName := vars["userID"]
	ctx := appengine.NewContext(r)

	// Check to see if the page user is the same as the logged in user
	userIsOwner := utils.IsOwner(userKeyName, ctx)

	if !userIsOwner {
		api.ApiErrorResponse(w, "You cannot edit other profiles.", http.StatusInternalServerError)
		return
	}

	returnPath := "/user/" + userKeyName

	// The autosaved thumbnail images need to be POSTed to specific appengine blobstore "action" paths.
	// Have to specify a path to return to after the post succeeds
	imageUploadUrl, err := blobstore.UploadURL(ctx, returnPath, nil)
	if err != nil {
		api.ApiErrorResponse(w, "Could not generate blobstore upload: "+err.Error(), http.StatusInternalServerError)
		return
	}

	// Need to return the uploadUrl to use to post the image to
	uploadUrl := bytes.NewBufferString(imageUploadUrl.Path)
	io.Copy(w, uploadUrl)
	return
}

func Edit(rw http.ResponseWriter, req *http.Request, r render.Render, params martini.Params) {
	c := appengine.NewContext(req)
	var b banner.Banner

	intID, err := strconv.Atoi(params["id"])
	if err == nil {
		b.ID = int64(intID)
	}

	if b.ID > 0 {
		if err := b.Get(c); err != nil {
			http.Redirect(rw, req, "/admin?error="+err.Error(), http.StatusFound)
			return
		}
	}

	uploadURL, err := blobstore.UploadURL(c, "/admin/banners/"+strconv.Itoa(intID), nil)
	if err != nil {
		http.Redirect(rw, req, "/admin?error="+err.Error(), http.StatusFound)
		return
	}

	bag := make(map[string]interface{}, 0)
	bag["Host"] = req.URL.Host
	bag["Admin"] = true
	bag["Banner"] = b
	bag["URL"] = uploadURL
	bag["ActiveNav"] = "banners"
	r.HTML(200, "admin/banners/edit", bag)

	return
}

//Upload renders the new presentation upload page.
func Upload(c util.Context) (err error) {
	uploadURL, err := blobstore.UploadURL(c, "/admin/presentation/upload", nil)
	if err != nil {
		return
	}

	acts, err := activation.GetAfterTime(time.Now(), c)
	if err != nil {
		return
	}

	type actWithName struct {
		A *activation.Activation
		P *presentation.Presentation
	}

	ans := make([]actWithName, len(acts))

	for i, a := range acts {
		pk := a.Presentation
		var p *presentation.Presentation
		p, err = presentation.GetByKey(pk, c)
		if err != nil {
			c.Errorf("Could not load presentation: %v", err)
			continue
		}
		ans[i] = actWithName{a, p}
	}

	util.RenderLayout("upload.html", "Nahrať prezentáciu", struct {
		UploadURL *url.URL
		Ans       []actWithName
	}{uploadURL, ans}, c)
	return
}

func fileUpload(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	// New FileData
	fileData := new(FileData)

	// Get upload url
	uploadURL, err := blobstore.UploadURL(c, "/file?action=uploadProcess", nil)
	if err != nil {
		serveError(c, w, err)
		return
	}

	fileData.PostUrl = uploadURL.String()

	// New PageSetting
	pageSetting := new(PageSetting)

	// Setting pageSetting
	pageSetting.Title = "File Upload - " + config.Title
	pageSetting.Layout = "column1"
	pageSetting.ShowSidebar = false

	// New PageData
	pageData := &PageData{File: *fileData}

	// New Page
	page := NewPage(pageSetting, pageData)

	// Render page
	page.Render("file/upload", w)
}

func UploadUrl(c mpg.Context, w http.ResponseWriter, r *http.Request) {
	uploadURL, err := blobstore.UploadURL(c, routeUrl("import-opml"), nil)
	if err != nil {
		serveError(w, err)
		return
	}
	w.Write([]byte(uploadURL.String()))
}

// Uploads a file to the blobstore
func uploadFile(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	uploadURL, _ := blobstore.UploadURL(c, "/admin/files/handleUpload", nil)

	passedTemplate := new(bytes.Buffer)
	template.Must(template.ParseFiles("statuscode.ch/files/templates/upload.html")).Execute(passedTemplate, uploadURL)
	render.Render(w, r, passedTemplate)
}

func authUpload(pfc *PFContext) (interface{}, error) {
	c := pfc.C

	if uploadURL, err := blobstore.UploadURL(c, "/import", nil); err != nil {
		return nil, err
	} else {
		return map[string]string{"uploadUrl": uploadURL.String()}, nil
	}
}

func uploadInstructions(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	uploadURL, err := blobstore.UploadURL(c, "/upload", nil)
	w.Header().Set("Content-Type", "text/html")
	err = templates.ExecuteTemplate(w, "upload", uploadURL)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func submitUpload(c appengine.Context, w http.ResponseWriter, r *http.Request) {

	// c := appengine.NewContext(r)
	uploadURL, err := blobstore.UploadURL(c, "/blob2/processing-new-upload", nil)
	util_err.Err_http(w, r, err, false)

	w.Header().Set("Content-type", "text/html; charset=utf-8")
	err = upload2.Execute(w, uploadURL)
	util_err.Err_http(w, r, err, false)
}

func renderBillForm(ctx *Context, errs []string) error {
	uploadURL, err := blobstore.UploadURL(ctx.c, "/admin/bill/create", nil)
	if err != nil {
		return err
	}

	vendors, err := ctx.GetAllVendors()
	if err != nil {
		return err
	}
	return ctx.renderAdmin(newBillTmpl, NewBillForm{&Bill{}, errs, vendors, uploadURL})
}

// Get an URL for uploading a file to a visualization
func getVisualizationFileUploadUrl(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	vars := mux.Vars(r)

	uploadUrl, err := blobstore.UploadURL(c, "/api/visualizations/"+vars["key"]+"/files/upload", nil)
	if err != nil {
		common.ServeError(c, w, err)
		return
	}

	common.WriteJson(c, w, uploadUrl.Path)
}

func handleRoot(w http.ResponseWriter, r *http.Request) {
        c := appengine.NewContext(r)
        uploadURL, err := blobstore.UploadURL(c, "/upload", nil)
        if err != nil {
                serveError(c, w, err)
                return
        }
        w.Header().Set("Content-Type", "text/html")
        err = rootTemplate.Execute(w, uploadURL)
        if err != nil {
                c.Errorf("%v", err)
        }
}

func RestoreForm(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	uploadURL, err := blobstore.UploadURL(c, "/restore", nil)
	if err != nil {
		c.Errorf("%s", err)
		return
	}
	w.Header().Set("Content-Type", "text/html")
	err = restoreFormTemplate.Execute(w, uploadURL)
	if err != nil {
		c.Errorf("%v", err)
	}
}

func handleRoot(ctx *Context, w http.ResponseWriter, r *http.Request) error {
	uploadURL, err := blobstore.UploadURL(ctx.c, "/upload", nil)
	if err != nil {
		return err
	}

	ctx.SetTitle("Upload New Bill")

	render := struct {
		UploadURL *url.URL
	}{uploadURL}
	return ctx.Render(uploadTmpl, render)
}

func BlobPage(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	uploadURL, err := blobstore.UploadURL(c, "/blob/upload", nil)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	if err := htmlTemplate.Execute(w, uploadURL); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func handleAddItem(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	uploadOptions := &blobstore.UploadURLOptions{MaxUploadBytes: 8000000, MaxUploadBytesPerBlob: 300000}
	uploadURL, err := blobstore.UploadURL(c, "/upload", uploadOptions)
	if err != nil {
		serveError(c, w, err)
		return
	}
	w.Header().Set("Content-Type", "text/html")
	err = addItemTemplate.Execute(w, uploadURL)
	if err != nil {
		c.Errorf("%v", err)
	}
}

func handler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	c.Debugf("00")
	uploadURL, err := blobstore.UploadURL(c, "/upload", nil)
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		c.Errorf("01")
		return
	}
	err = htmlTemplate.Execute(w, uploadURL)
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		c.Errorf("02")
	}
}