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 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 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 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: "******"=", mo, " Session: ", su.Id, "=", mo, " Status: ", status)
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)
}
// MapEncoder intercepts the request's URL, detects the requested format,
// and injects the correct encoder dependency for this request. It rewrites
// the URL to remove the format extension, so that routes can be defined
// without it.
func MapEncoder(c martini.Context, w http.ResponseWriter, r *http.Request, p *models.Page) {
// Get the format extension
matches := rxExt.FindStringSubmatch(r.URL.Path)
ft := ".html"
if len(matches) > 1 {
// Rewrite the URL without the format extension
l := len(r.URL.Path) - len(matches[1])
if strings.HasSuffix(r.URL.Path, "/") {
l--
}
r.URL.Path = r.URL.Path[:l]
ft = matches[1]
}
// Inject the requested encoder
switch ft {
case ".json":
p.SetEncoding("json")
default:
p.SetEncoding("html")
}
}
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 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 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: "******"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 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 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 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: "******" Album: ", name, " Result: ", result, " 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 NotFound(su models.User, r render.Render, p *models.Page) {
p.SetUser(su)
p.SetTitle("404")
encoder.Render(p.Encoding, 404, "notfound", p, r)
}
func Index(su models.User, r render.Render, p *models.Page) {
p.SetUser(su)
p.SetTitle("")
encoder.Render(p.Encoding, 200, "index", p, r)
}