Golang Page.Data方法代码示例

func Hash(args martini.Params, su models.User, r render.Render, p *models.Page) {
	var th models.HashID

	user_id, err := strconv.ParseInt(args["user_id"], 10, 10)
	if err != nil {
		log.Println(err)
	}

	image_id, err := strconv.ParseInt(args["image_id"], 10, 10)
	if err != nil {
		log.Println(err)
	}

	time_now := time.Now().Unix()

	th.Init(utils.AppCfg.SecretKey(), 6)
	th.SetIds(int(user_id), int(image_id), int(time_now))
	enc := th.Encrypt()
	log.Println(enc)
	dec := th.Decrypt()
	log.Println(dec)

	p.SetUser(su)
	p.SetTitle("")
	p.Data = th
	encoder.Render(p.Encoding, 200, "test/hash", p, r)
}

func Login(session sessions.Session, su models.User, r render.Render, p *models.Page) {

	// Check if we are already logged in
	if su.Id > 0 {
		r.Redirect(strings.Join([]string{utils.AppCfg.Url(), "albums"}, "/"), http.StatusFound)
		return
	}

	session.Set("loggedin", "false")

	// Init error holder
	errs := make(map[string]string)

	err_flash := session.Get("flash")
	if err_flash != nil {
		errs["flash"] = err_flash.(string)
		session.Set("flash", nil)
	}

	genform := utils.GenerateForm(&forms.Login{}, "/login", "POST", errs)

	p.SetUser(su)
	p.SetTitle("Login")
	p.Data = LoginVars{Form: genform}

	encoder.Render(p.Encoding, 200, "login", p, r)
}

func Profile(args martini.Params, su models.User, session sessions.Session, r render.Render, dbh *db.Dbh, p *models.Page) {
	name := args["user"]

	p.SetTitle("Profile", name)
	p.SetUser(su)
	p.Data = ""

	encoder.Render(p.Encoding, 200, "profile", p, r)
}

func Tags(su models.User, dbh *db.Dbh, p *models.Page, r render.Render) {
	tags := dbh.GetAllTags()

	p.SetUser(su)
	p.SetTitle("Tags")
	p.Data = tags
	p.Encoding = "json"

	encoder.Render(p.Encoding, 200, "tags", p, r)
}

func AlbumMove(req *http.Request, r render.Render, su models.User, dbh *db.Dbh, p *models.Page) {
	// Default status
	var status string = "Permission Denied"
	var code int = 401

	var reader io.Reader = req.Body
	b, e := ioutil.ReadAll(reader)
	if e != nil {
		log.Println(e)
	}

	var f Data
	err := json.Unmarshal(b, &f)
	if err != nil {
		log.Println(err)
	}
	log.Println(f)

	albumId := f.Md.AlbumId
	album := dbh.GetAlbumById(albumId)
	log.Println("album: ", albumId)

	if album.User == su.Id {
		status = "Success"
		code = 200

		var image models.Image
		for _, f := range f.Md.Images {
			imageId, err := strconv.ParseInt(f.Id, 10, 10)
			if err != nil {
				log.Println("invalid image id: ", f.Id)
			}
			log.Println("Moving: ", f.Name, imageId)

			image = dbh.GetImageById(imageId)
			if image.User != su.Id {
				status = "Permission Denied"
				code = 401
				continue
			}
			fromId := image.AlbumId
			image.AlbumId = albumId
			_ = dbh.UpdateImage(image)
			log.Printf("Moved %s from: %d to: %d status: %s code: %d\n", f.Name, fromId, albumId, status, code)
		}

	}
	p.Data = status
	encoder.Render("json", code, "", p, r)
}

func AlbumUpdate(req *http.Request, r render.Render, su models.User, dbh *db.Dbh, p *models.Page) {
	p.SetUser(su)

	var reader io.Reader = req.Body
	b, e := ioutil.ReadAll(reader)
	if e != nil {
		log.Println(e)
	}

	var f interface{}
	err := json.Unmarshal(b, &f)
	if err != nil {
		log.Println(err)
	}

	m := f.(map[string]interface{})
	md := m["data"].(map[string]interface{})

	// Default status
	var status string = "Permission Denied"
	var code int = 401

	mi := int64(md["Id"].(float64))
	mo := int64(md["Owner"].(float64))
	name := md["Name"].(string)

	album := dbh.GetAlbumById(mi)

	if album.Id == mi && album.User == mo && su.Id == mo {
		mAlbum := models.Album{
			Id:          mi,
			Description: md["Description"].(string),
			Name:        md["Name"].(string),
			User:        mo,
			Poster:      md["Poster"].(string),
			Private:     md["Private"].(bool),
			Privatekey:  md["Privatekey"].(string)}

		log.Printf("mAlbum: %+v\n", mAlbum)
		uAlbum := dbh.AlbumUpdate(mAlbum)
		log.Printf("uAlbum: %+v\n", uAlbum)
		status = "Success"
		code = 200
	}

	log.Println("Album Update: ", "Name: ", name, " Album Id: ", album.Id, "=", mi, " Album User: ", album.User, "=", mo, " Session: ", su.Id, "=", mo, " Status: ", status)

	p.Data = models.AlbumResult{Status: status}
	encoder.Render("json", code, "", p, r)
}

func AlbumCreate(req *http.Request, r render.Render, su models.User, dbh *db.Dbh, p *models.Page) {
	// Default status
	var status string = "Permission Denied"
	var code int = 401

	var reader io.Reader = req.Body
	b, e := ioutil.ReadAll(reader)
	if e != nil {
		log.Println(e)
	}

	adata := string(b)

	params := strings.Split(adata, "&")

	var name, privatekey, description string
	for _, val := range params {
		vars := strings.Split(val, "=")
		k := strings.ToLower(vars[0])
		v := vars[1]
		switch k {
		case "name":
			name = v
		case "privatekey":
			privatekey = v
		case "description":
			description = v
		}

	}
	if len(description) == 0 {
		const layout = "Auto-created 2 January 2006"
		t := time.Now()
		description = t.Format(layout)
	}

	// Add album
	nAlbum := models.Album{Name: name, User: su.Id, Privatekey: privatekey, Private: true, Description: description, Timestamp: time.Now().Unix()}
	album := dbh.AddAlbum(nAlbum)
	if album.Id > 0 {
		code = 200
		status = "Success"
	}

	p.Data = models.AlbumResult{Status: status}
	encoder.Render("json", code, "", p, r)
}

func ImagePage(args martini.Params, su models.User, res http.ResponseWriter, req *http.Request, r render.Render, dbh *db.Dbh, p *models.Page) {
	name := args["name"]

	image := dbh.FirstImageByName(name)
	tags := dbh.GetAllTagsByImageId(image.Id)

	errs := make(map[string]string)
	form := utils.GenerateForm(&forms.Tag{Image: name}, "/tag", "POST", errs)

	p.SetUser(su)
	p.SetTitle("Image")

	src := fmt.Sprintf("%s/i/%s", utils.AppCfg.Url(), name)
	fullsrc := fmt.Sprintf("%s/o/%s", utils.AppCfg.Url(), name)
	p.Data = ImagePageVars{Name: src, Full: fullsrc, Tags: tags, Form: form}

	encoder.Render(p.Encoding, 200, "image", p, r)
}

func ListThumb(args martini.Params, su models.User, r render.Render, p *models.Page) {

	files, _ := ioutil.ReadDir(utils.ImageCfg.Root())

	var imageLinks []ImageLink

	for _, f := range files {
		if strings.Contains(f.Name(), ".") && !strings.HasPrefix(f.Name(), ".") {
			imageLinks = append(imageLinks, ImageLink{Title: f.Name(), FileName: f.Name()})
		}
	}

	p.SetUser(su)
	p.SetTitle("List", "Thumbs")
	p.Data = ListVars{Title: "All Images", Description: "Listing of all images in database", ImageLinks: imageLinks}

	encoder.Render(p.Encoding, 200, "test/thumbs", p, r)
}

func ImageTrash(args martini.Params, su models.User, dbh *db.Dbh, r render.Render, p *models.Page) {
	album := args["album"]
	name := args["name"]

	// Default status
	var status string = "Permission Denied"
	var code int = 401

	log.Printf("Trashing image: %s from %s", name, album)

	image := dbh.FirstImageByName(name)
	if su.Id == image.User {
		image.Trashed = true
		dbh.UpdateImage(image)
		status = "Success"
		code = 200
	}

	p.SetUser(su)
	p.Data = TrashRecover{Name: name, Album: album, Action: "Trash", Status: status}

	encoder.Render("json", code, "", p, r)
}

func Tagged(args martini.Params, r render.Render, su models.User, dbh *db.Dbh, p *models.Page) {

	tag := args["tag"]

	images := dbh.GetImagesWithTag(tag)

	var imageLinks []imageLink
	for _, f := range images {
		if f.Trashed {
			log.Println("Trashed: ", f)
			continue
		}
		imageLinks = append(imageLinks, imageLink{Title: f.Name, FileName: f.Name})
	}

	p.SetUser(su)
	p.SetTitle("Tagged", tag)
	description := fmt.Sprintf("Images tagged as %s", tag)
	p.Data = TaggedVars{Title: tag, Description: description, ImageLinks: imageLinks}
	p.Encoding = "json"

	encoder.Render(p.Encoding, 200, "image_link", p, r)
}

func Account(su models.User, session sessions.Session, r render.Render, dbh *db.Dbh, p *models.Page) {

	// Init error holder
	errs := make(map[string]string)

	account := forms.Account{}
	account.Id = su.Id
	account.Email = su.Email
	account.Name = su.Name

	username := su.UserName
	if username == "" {
		username = genUserName(su.Email, dbh)
	}
	account.UserName = username
	genform := utils.GenerateForm(&account, "/account", "POST", errs)

	p.SetTitle("Account")
	p.SetUser(su)
	p.Data = accountVars{Form: genform}

	encoder.Render(p.Encoding, 200, "account", p, r)
}

func Album(args martini.Params, su models.User, session sessions.Session, r render.Render, dbh *db.Dbh, p *models.Page) {
	name := args["name"]
	auser := args["user"]
	key := args["key"]

	if auser != "" {
		log.Println("album user: ", auser)
	}

	album := dbh.GetAlbumByName(name)
	if su.Id != album.User && album.Private && album.Privatekey != key {
		session.Set("flash", "Login Required")
		r.Redirect(strings.Join([]string{utils.AppCfg.Url(), "login"}, "/"), http.StatusFound)
		return
	}

	images := dbh.GetAllImagesByAlbumId(album.Id)

	var imageLinks []imageLink
	for _, f := range images {
		if f.Trashed {
			continue
		}
		var file_name = f.Name
		if f.HashId != "" {
			file_name = f.HashId
		}
		log.Println(file_name, f)
		imageLinks = append(imageLinks, imageLink{Id: f.Id, Title: f.Name, FileName: file_name, Owner: f.User})
	}

	p.SetTitle("Album", name)
	p.SetUser(su)
	p.Data = AlbumVars{Title: name, Description: album.Description, ImageLinks: imageLinks}

	encoder.Render(p.Encoding, 200, "image_link", p, r)
}

func AlbumDelete(args martini.Params, req *http.Request, r render.Render, su models.User, dbh *db.Dbh, p *models.Page) {
	// Default status
	var result string = "Not Deleted"
	var status string = "Permission Denied"
	var code int = 401

	name := args["name"]

	album := dbh.GetAlbumByName(name)
	if album.User == su.Id {
		status = "Success"
		result = "Deleted"
		dAlbum := dbh.AlbumDelete(album)
		log.Printf("%+v", dAlbum)
	}
	if album.Id == 0 {
		status = "Album not found"
		code = 404
	}

	p.Data = models.AlbumResult{Name: name, Result: result, Status: status}
	log.Println("Album Delete: User: ", su.Id, " Album: ", name, " Result: ", result, " Status: ", status)
	encoder.Render("json", code, "", p, r)
}