Exemple #1
0
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)
	}
}
Exemple #2
0
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)
	}
}
Exemple #3
0
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)

}
Exemple #4
0
// 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
}
Exemple #5
0
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
}
Exemple #6
0
//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
}
Exemple #7
0
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)
}
Exemple #8
0
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()))
}
Exemple #9
0
// 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)
}
Exemple #10
0
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
	}
}
Exemple #11
0
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
	}
}
Exemple #12
0
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})
}
Exemple #14
0
// 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)
}
Exemple #15
0
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)
        }
}
Exemple #16
0
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)
}
Exemple #18
0
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
	}
}
Exemple #19
0
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)
	}
}
Exemple #20
0
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")
	}
}
Exemple #21
0
func newImage(w http.ResponseWriter, r *http.Request) {

	c := appengine.NewContext(r)
	if err := users.CheckPerm(w, r, users.OP_UPDATE); err != nil {
		return
	}

	url, err := blobstore.UploadURL(c, "/images/upload", nil)
	if err != nil {
		app.ServeError(c, w, err)
		return
	}

	fmt.Fprintf(w, "%s", url)
}
Exemple #22
0
func ImageUploadURLHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	imageUploadURL, err := Router.GetRoute("imageUpload").URL()
	if err != nil {
		core.HandleError(c, w, err)
		return
	}

	uploadURL, err := blobstore.UploadURL(c, imageUploadURL.Path, nil)
	if err != nil {
		core.HandleError(c, w, err)
		return
	}

	core.HandleJSON(c, w, map[string]string{"url": uploadURL.Path})
}
func uploadTranslationHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != "GET" {
		panic(&core.Error{http.StatusMethodNotAllowed, ""})
	}

	c := appengine.NewContext(r)
	uploadURL, err := blobstore.UploadURL(c, "/admin/translation/onUploaded", nil)
	if err != nil {
		panic(&core.Error{http.StatusInternalServerError, err.Error()})
	}

	w.Header().Set("Content-Type", "text/html")
	err = uploadTemplate.Execute(w, uploadURL)
	if err != nil {
		panic(&core.Error{http.StatusInternalServerError, err.Error()})
	}
}
Exemple #24
0
func OfShow(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	if s, ok := sess.IsSess(w, r, c); ok {
		u, _ := model.GetCta(c, s.User)
		tc := make(map[string]interface{})
		tc["Sess"] = s
		oferta, _ := model.GetOferta(c, r.FormValue("IdOft"))
		var id string
		if oferta.IdEmp != "none" {
			id = oferta.IdEmp
		} else {
			id = r.FormValue("IdEmp")
		}
		fd := ofToForm(*oferta)
		empresa, err := u.GetEmpresa(c, id)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		tc["Empresa"] = empresa
		fd.IdEmp = empresa.IdEmp
		oferta.Empresa = empresa.Nombre
		fd.Categorias = model.ListCat(c, oferta.IdCat)

		/*
		 * Se crea el form para el upload del blob
		 */
		blobOpts := blobstore.UploadURLOptions{
			MaxUploadBytesPerBlob: 1048576,
		}
		uploadURL, err := blobstore.UploadURL(c, "/r/ofimgup", &blobOpts)
		if err != nil {
			serveError(c, w, err)
			return
		}
		fd.UploadURL = strings.Replace(uploadURL.String(), "http", "https", 1)
		//fd.UploadURL = uploadURL

		tc["FormDataOf"] = fd
		ofadmTpl.ExecuteTemplate(w, "oferta", tc)
	} else {
		http.Redirect(w, r, "/r/registro", http.StatusFound)
	}
}
Exemple #25
0
// 画像のアップロード先URL取得
func handleGetImageUrl(w http.ResponseWriter, r *http.Request) {
	if r.Method != "GET" {
		http.Error(w, "リクエストエラー", http.StatusBadRequest)
		return
	}
	c := appengine.NewContext(r)
	uuid := uuid.New()
	option := blobstore.UploadURLOptions{
		StorageBucket: "images",
	}
	uploadUrl, err := blobstore.UploadURL(c, "/api/image/upload?key="+uuid, &option)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	iur := ImageUrlResponse{
		UploadUrl: uploadUrl.String(),
		Uuid:      uuid,
	}
	w.Header().Set("Content-Type", "application/json;charset=utf-8")
	w.Write(StructToJson(w, iur))
}
Exemple #26
0
// rootHandler returns the landing page, which includes a blobstore upload URL.
func rootHandler(c appengine.Context, w http.ResponseWriter, r *http.Request) *appError {
	logoutURL, err := user.LogoutURL(c, "/")
	if err != nil {
		c.Warningf("creating logout URL: %v", err)
		logoutURL = "/"
	}
	uploadURL, err := blobstore.UploadURL(c, "/upload", nil)
	if err != nil {
		return appErrorf(err, "could not create blobstore upload url")
	}
	username := "******"
	if u := user.Current(c); u != nil {
		username = u.String()
	}
	err = rootTemplate.Execute(w, &rootTemplateData{
		LogoutURL: logoutURL,
		UploadURL: uploadURL.String(),
		User:      username,
	})
	if err != nil {
		return appErrorf(err, "could not write template")
	}
	return nil
}
Exemple #27
0
// Modifica si hay, Crea si no hay
// Requiere IdEmp. IdOft es opcional, si no hay lo crea, si hay modifica
func OfMod(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	if s, ok := sess.IsSess(w, r, c); ok {
		u, _ := model.GetCta(c, s.User)
		tc := make(map[string]interface{})
		tc["Sess"] = s
		var fd FormDataOf
		var valid bool
		var ofertamod model.Oferta

		if r.FormValue("IdOft") == "new" {
			if empresa, err := u.GetEmpresa(c, r.FormValue("IdEmp")); err != nil {
				http.Redirect(w, r, "/r/le?d=o", http.StatusFound)
			} else {
				tc["Empresa"] = empresa
				fd.IdEmp = empresa.IdEmp
				fd.Empresa = empresa.Nombre
				ofertamod.IdEmp = empresa.IdEmp
				ofertamod.Oferta = "Nueva oferta"
				ofertamod.FechaHora = time.Now().Add(time.Duration(model.GMTADJ) * time.Second)    // 5 horas menos
				ofertamod.FechaHoraPub = time.Now().Add(time.Duration(model.GMTADJ) * time.Second) // 5 horas menos
				ofertamod.Empresa = strings.ToUpper(empresa.Nombre)
				ofertamod.BlobKey = "none"
				o, err := model.NewOferta(c, &ofertamod)
				model.Check(err)
				fd = ofToForm(*o)
				fd.Ackn = "Ok"
			}
		} else {
			/*
			 * Se pide un id oferta que en teoría existe, se consulta y se cambia
			 * Se valida y si no existe se informa un error
			 */
			fd, valid = ofForm(w, r, true)

			ofertamod.IdOft = fd.IdOft
			ofertamod.IdEmp = fd.IdEmp
			ofertamod.IdCat = fd.IdCat
			ofertamod.Oferta = fd.Oferta
			ofertamod.Descripcion = fd.Descripcion
			ofertamod.Enlinea = fd.Enlinea
			ofertamod.Url = fd.Url
			ofertamod.FechaHoraPub = fd.FechaHoraPub
			ofertamod.StatusPub = fd.StatusPub
			//ofertamod.BlobKey = fd.BlobKey
			ofertamod.FechaHora = time.Now().Add(time.Duration(model.GMTADJ) * time.Second)

			oferta, keyOferta := model.GetOferta(c, ofertamod.IdOft)
			if oferta.IdOft != "none" {
				ofertamod.BlobKey = oferta.BlobKey
				ofertamod.Codigo = oferta.Codigo
				empresa, err := u.GetEmpresa(c, ofertamod.IdEmp)
				if err != nil {
					http.Error(w, err.Error(), http.StatusInternalServerError)
					return
				}
				tc["Empresa"] = empresa
				fd.IdEmp = empresa.IdEmp
				fd.Empresa = empresa.Nombre
				ofertamod.Empresa = strings.ToUpper(empresa.Nombre)
				emplogo := model.GetLogo(c, empresa.IdEmp)
				if emplogo != nil {
					// Tenga lo que tenga, se pasa Sp4 a Oferta.Promocion
					if emplogo.Sp4 != "" {
						ofertamod.Promocion = emplogo.Sp4
						ofertamod.Descuento = strings.Replace(emplogo.Sp4, "s180", "s70", 1)
					}
				}
				// TODO
				// es preferible poner un regreso avisando que no existe la empresa
				if valid {
					// Ya existe
					err := model.PutOferta(c, &ofertamod)
					model.Check(err)

					// Se borran las relaciones oferta-sucursal
					err = model.DelOfertaSucursales(c, oferta.IdOft)
					model.Check(err)

					// Se crea un mapa de Estados para agregar a OfertaEstado
					edomap := make(map[string]string, 32)

					// Se reconstruyen las Relaciones oferta-sucursal con las solicitadas
					idsucs := strings.Fields(r.FormValue("schain"))

					for _, idsuc := range idsucs {
						suc := model.GetSuc(c, u, idsuc, ofertamod.IdEmp)

						lat, _ := strconv.ParseFloat(suc.Geo1, 64)
						lng, _ := strconv.ParseFloat(suc.Geo2, 64)

						var ofsuc model.OfertaSucursal
						ofsuc.IdOft = ofertamod.IdOft
						ofsuc.IdSuc = idsuc
						ofsuc.IdEmp = ofertamod.IdEmp
						ofsuc.Sucursal = suc.Nombre
						ofsuc.Lat = lat
						ofsuc.Lng = lng
						ofsuc.Empresa = ofertamod.Empresa
						ofsuc.Oferta = ofertamod.Oferta
						ofsuc.Descripcion = ofertamod.Descripcion
						ofsuc.Promocion = ofertamod.Promocion
						ofsuc.Descuento = ofertamod.Descuento
						ofsuc.Url = ofertamod.Url
						ofsuc.StatusPub = ofertamod.StatusPub
						ofsuc.FechaHora = time.Now().Add(time.Duration(model.GMTADJ) * time.Second)

						// Se añade el estado de la sucursal al mapa de estados
						edomap[suc.DirEnt] = oferta.IdOft

						errOs := ofertamod.PutOfertaSucursal(c, &ofsuc)
						model.Check(errOs)

					}
					// Se limpia la relación OfertaEstado
					_ = ofertamod.DelOfertaEstado(c)

					// Se guarda la relación OfertaEstado
					errOe := ofertamod.PutOfertaEstado(c, edomap)
					model.Check(errOe)

					var tituloOf string
					tituloOf = ""
					if strings.ToLower(strings.TrimSpace(ofertamod.Oferta)) != "nueva oferta" {
						tituloOf = ofertamod.Oferta
					}
					putSearchData(c, ofertamod.Empresa+" "+tituloOf+" "+ofertamod.Descripcion+" "+r.FormValue("pchain"), keyOferta, oferta.IdOft, ofertamod.IdCat, ofertamod.Enlinea)

					// Se despacha la generación de diccionario de palabras
					// Se agrega pcves a la descripción
					//fmt.Fprintf(w,"http://movil.%s.appspot.com/backend/generatesearch?kind=Oferta&field=Descripcion&id=%s&value=%s&categoria=%s",
					//appengine.AppID(c), keyOferta.Encode(), ofertamod.Descripcion+" "+r.FormValue("pchain"), strconv.Itoa(ofertamod.IdCat))
					//_ = generatesearch(c, keyOferta, ofertamod.Descripcion+" "+r.FormValue("pchain"), ofertamod.IdCat)

					fd = ofToForm(ofertamod)
					fd.Ackn = "Ok"
				}
			} else {
				// no existe la oferta
			}
		}

		fd.Categorias = model.ListCat(c, ofertamod.IdCat)

		/*
		 * Se crea el form para el upload del blob
		 */
		blobOpts := blobstore.UploadURLOptions{
			MaxUploadBytesPerBlob: 1048576,
		}
		uploadURL, err := blobstore.UploadURL(c, "/r/ofimgup", &blobOpts)
		if err != nil {
			serveError(c, w, err)
			return
		}
		fd.UploadURL = strings.Replace(uploadURL.String(), "http", "https", 1)
		//fd.UploadURL = uploadURL
		tc["FormDataOf"] = fd

		ofadmTpl.ExecuteTemplate(w, "oferta", tc)
	} else {
		http.Redirect(w, r, "/r/registro", http.StatusFound)
	}

	/*
	 * FETCH PARA MVBLOB/GENERATE
	 */
	cronsecs := 3600
	cachename := "mvblob_cron"
	if _, err := memcache.Get(c, cachename); err == memcache.ErrCacheMiss {
		slot := strconv.Itoa(cronsecs)
		item := &memcache.Item{
			Key:        cachename,
			Value:      []byte(slot),
			Expiration: time.Duration(cronsecs) * time.Second,
		}
		if err := memcache.Add(c, item); err == memcache.ErrNotStored {
			//c.Errorf("memcache.Add %v : %v", cachename, err)
			if err := memcache.Set(c, item); err == memcache.ErrNotStored {
				c.Errorf("Memcache.Set %v : %v", cachename, err)
			} else {
				c.Infof("memcached %v", cachename)
				mvblobFetch(c)
			}
		} else {
			c.Infof("memcached %v", cachename)
			mvblobFetch(c)
		}
	} else {
		// DO NOTHING
	}
}
Exemple #28
0
func articleAdd(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	if r.Method != "POST" {
		// Show article add page

		//因为编辑器的原因 ,在这里就要知道上传的路径
		// 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)
		pageSetting.Title = "Article Manager - Add - " + config.Title
		pageSetting.Layout = "column1"

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

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

		// Render page
		err = page.Render("article/add", w)
		if err != nil {
			serveError(c, w, err)
			return
		}
		return
	}

	// Process post data

	// Parse form data
	if err := r.ParseForm(); err != nil {
		serveError(c, w, err)
		return
	}

	// Custom ID
	var customID string
	if r.FormValue("customid") != "" {
		// Check custom id is exists
		if checkIdIsExists("Article", r.FormValue("customid"), c) {
			customID = genID()
		} else {
			customID = r.FormValue("customid")
		}
	} else {
		customID = genID()
	}

	// Create articleDB
	articleDB := &ArticleDB{
		ID:      customID,
		Date:    time.Now(),
		Title:   r.FormValue("title"),
		Content: []byte(r.FormValue("content")),
	}

	// Save to datastore
	if _, err := datastore.Put(c, datastore.NewIncompleteKey(c, "Article", nil), articleDB); err != nil {
		serveError(c, w, err)
	} else {
		http.Redirect(w, r, "/article?action=manager", http.StatusFound)
	}
}
Exemple #29
0
func EditPost(blog_config map[string]interface{}) func(w http.ResponseWriter, req *http.Request) {
	template_dir := "templates/"
	l := func(w http.ResponseWriter, req *http.Request) {
		appcontext := appengine.NewContext(req)

		context := map[string]interface{}{}

		name := req.URL.Query().Get(":name")
		if name != "" {
			query := post.GetPostsMatchingUrl(req.URL.Query().Get(":name"))
			idx, err := post.GetCount(appcontext, query)

			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
			}

			if idx < 1 {
				context["articlesource"] = "Enter your post here!"
				context["labels"] = "visible"
				context["title"] = "No post with that URL found, making new post!"
			} else {
				var ps []post.Post
				keys, err := query.GetAll(appcontext, &ps)
				if err != nil {
					http.Error(w, err.Error(), http.StatusInternalServerError)
				}

				p := ps[0]
				tags, err := post.GetTagSlice(appcontext, keys[0])
				if err != nil {
					http.Error(w, err.Error(), http.StatusInternalServerError)
				}

				content, err := post.GetPostContent(appcontext, p)
				if err != nil {
					http.Error(w, err.Error(), http.StatusInternalServerError)
				}

				context["articlesource"] = content
				context["labels"] = strings.Join(tags, ", ")
				context["title"] = p.Title
			}
		} else {
			context["articlesource"] = "Enter your post here!"
			context["labels"] = "visible, enter, labels, here"
			context["title"] = "enter title here"
		}

		key := fmt.Sprintf("%v", rand.Int())
		tok, err := channel.Create(appcontext, key)
		if err != nil {
			http.Error(w, "Couldn't create Channel", http.StatusInternalServerError)
			appcontext.Errorf("channel.Create: %v", err)
			return
		}

		posturl := "/admin/post?g=" + key
		uploadurl, err := blobstore.UploadURL(appcontext, posturl, nil)
		if err != nil {
			http.Error(w, "Couldn't create blob URL", http.StatusInternalServerError)
			appcontext.Errorf("blobstore.UploadURL: %v", err)
			return
		}

		context["token"] = tok
		context["session"] = key
		context["uploadurl"] = uploadurl

		total_con := config.Stringify_map(config.Merge(blog_config, context))
		c := mustache.RenderFile(template_dir+"edit.html.mustache", total_con)
		io.WriteString(w, c)

		if err != nil {
			appcontext.Errorf("mainTemplate: %v", err)
		}
	}
	return admin_layout(blog_config, l)
}
Exemple #30
0
func renderRoot(w http.ResponseWriter, r *http.Request, filter []int) {
	c := appengine.NewContext(r)
	//log.Println(c)
	u := user.Current(c)
	//need to check if user is logged in so that the login/logout button
	//is toggled correctly
	var status *Status = &Status{LoggedIn: false, CurrentUser: nil}
	if u == nil {
		status.reset()
	} else if matched, _ := regexp.MatchString(".*@cornell.edu", u.String()); !matched {
		status.reset()
		http.Redirect(w, r, "/logout", http.StatusFound)
	} else {
		status.set(true, u)
	}
	var now Period
	e1 := datastore.Get(c, currentSemesterKey(c), &now)
	log.Printf("The value of now is %v", &now)
	if e1 != nil {
		if e1 == datastore.ErrNoSuchEntity {
			now.Semester = 0
			now.Year = 2015
			updateSemesterData(c, &now)
		} else {
			log.Println("DATASTORE PERIOD ERROR")
			http.Error(w, e1.Error(), http.StatusInternalServerError)
		}
	}
	var tileKey *datastore.Key
	if filter != nil {
		tileKey = tileRootKey(c, filter[0], filter[1])
	} else {
		tileKey = tileRootKey(c, now.Semester, now.Year)
	}
	qs := datastore.NewQuery("Tile").Ancestor(tileKey).Order("-LastUpdate")
	tiles := make([]Tile, 0)
	if _, err := qs.GetAll(c, &tiles); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	ccperiods := make([]Period, 0)
	ssperiods := make([]Period, 0)
	fallqs := datastore.NewQuery("Date").Ancestor(CCRoot(c)).Order("-Semester").Order("-Year")
	springqs := datastore.NewQuery("Date").Ancestor(SSRoot(c)).Order("-Semester").Order("-Year")
	fallqs.GetAll(c, &ccperiods)
	springqs.GetAll(c, &ssperiods)
	log.Println(ccperiods, ssperiods)
	//debug
	//log.Print(tiles)

	//serve the root template

	funcMap := template.FuncMap{
		"divide":   div,
		"incr":     incr,
		"cong":     congz,
		"ustring":  ustring,
		"contains": contains,
		"isAdmin":  isAdmin,
		"netID":    netID,
		"format":   fmtMembers,
	}

	//	fp3 := path.Join("templates", "welcome.html")
	templ := template.Must(template.New("welcome.html").Funcs(funcMap).ParseFiles("templates/welcome.html"))
	//obtain a new uploadURL for team photo, for blobstore
	uploadURL, err := blobstore.UploadURL(c, "/submit", nil)
	if err != nil {
		panic("oh no!")
	}
	w.Header().Set("Content-Type", "text/html")
	templ.Execute(w, map[string]interface{}{
		"Tiles":     tiles,
		"LoggedIn":  status,
		"uploadURL": uploadURL,
		"ccs":       ccperiods,
		"sss":       ssperiods,
		"now":       now,
	})
}