// HandleShow serve a get request at /users/1
func HandleShow(context router.Context) error {
// Find the user
user, err := users.Find(context.ParamInt("id"))
if err != nil {
context.Logf("#error parsing user id: %s", err)
return router.NotFoundError(err)
}
userMeta := fmt.Sprintf("%s – %s", user.Name, user.Summary)
// Set up view
view := view.New(context)
// Find the first image which matches this user
image, err := images.Find(user.ImageID)
if err == nil {
// only add image key if we have one
view.AddKey("image", image)
}
// Render the Template
view.AddKey("user", user)
view.AddKey("meta_title", userMeta)
view.AddKey("meta_desc", userMeta)
view.AddKey("meta_keywords", user.Keywords())
return view.Render()
}
// POST users/create
func HandleCreate(context router.Context) error {
// Authorise
err := authorise.Path(context)
if err != nil {
return router.NotAuthorizedError(err)
}
// Setup context
params, err := context.Params()
if err != nil {
return router.InternalError(err)
}
// We should check for duplicates in here
id, err := users.Create(params.Map())
if err != nil {
return router.InternalError(err, "Error", "Sorry, an error occurred creating the user record.")
} else {
context.Logf("#info Created user id,%d", id)
}
// Redirect to the new user
p, err := users.Find(id)
if err != nil {
return router.InternalError(err, "Error", "Sorry, an error occurred finding the new user record.")
}
return router.Redirect(context, p.URLIndex())
}
// HandleUpdate or PUT /users/1/update
func HandleUpdate(context router.Context) error {
// Find the user
id := context.ParamInt("id")
user, err := users.Find(id)
if err != nil {
context.Logf("#error Error finding user %s", err)
return router.NotFoundError(err)
}
// Authorise
err = authorise.Resource(context, user)
if err != nil {
return router.NotAuthorizedError(err)
}
// We expect only one image, what about replacing the existing when updating?
// At present we just create a new image
files, err := context.ParamFiles("image")
if err != nil {
return router.InternalError(err)
}
// Get the params
params, err := context.Params()
if err != nil {
return router.InternalError(err)
}
var imageID int64
if len(files) > 0 {
fileHandle := files[0]
// Create an image (saving the image representation on disk)
imageParams := map[string]string{"name": user.Name, "status": "100"}
imageID, err = images.Create(imageParams, fileHandle)
if err != nil {
return router.InternalError(err)
}
params.Set("image_id", fmt.Sprintf("%d", imageID))
delete(params, "image")
}
err = user.Update(params.Map())
if err != nil {
return router.InternalError(err)
}
// Redirect to user
return router.Redirect(context, user.URLShow())
}
// POST /users/1/destroy
func HandleDestroy(context router.Context) error {
// Set the user on the context for checking
user, err := users.Find(context.ParamInt("id"))
if err != nil {
return router.NotFoundError(err)
}
// Authorise
err = authorise.Resource(context, user)
if err != nil {
return router.NotAuthorizedError(err)
}
// Destroy the user
user.Destroy()
// Redirect to users root
return router.Redirect(context, user.URLIndex())
}
// HandleUpdateShow serves a get request at /users/1/update (show form to update)
func HandleUpdateShow(context router.Context) error {
// Setup context for template
view := view.New(context)
user, err := users.Find(context.ParamInt("id"))
if err != nil {
context.Logf("#error Error finding user %s", err)
return router.NotFoundError(err)
}
// Authorise
err = authorise.Resource(context, user)
if err != nil {
return router.NotAuthorizedError(err)
}
view.AddKey("user", user)
// view.AddKey("admin_links", helpers.Link("Destroy User", url.Destroy(user), "method=post"))
return view.Render()
}
// CurrentUser returns the saved user (or an empty anon user) for the current session cookie
// Strictly speaking this should be authenticate.User
func CurrentUser(context router.Context) *users.User {
// First check if the user has already been set on context, if so return it
if context.Get("current_user") != nil {
return context.Get("current_user").(*users.User)
}
// Start with an anon user by default (role 0, id 0)
user := &users.User{}
// Build the session from the secure cookie, or create a new one
session, err := auth.Session(context, context.Request())
if err != nil {
context.Logf("#error problem retrieving session")
return user
}
// Fetch the current user record if we have one recorded in the session
var id int64
ids := session.Get(auth.SessionUserKey)
if len(ids) > 0 {
id, err = strconv.ParseInt(ids, 10, 64)
if err != nil {
context.Logf("#error Error decoding session user key:%s\n", err)
return user
}
}
if id != 0 {
u, err := users.Find(id)
if err != nil {
context.Logf("#info User not found from session id:%d\n", id)
return user
}
user = u
}
return user
}
// HandleSetup responds to a POST at /fragmenta/setup
// by creating our first user and page
func HandleSetup(context router.Context) error {
// If we have pages or users already, do not proceed
if !missingUsersAndPages() {
return router.NotAuthorizedError(nil)
}
// Take the details given and create the first user
params := map[string]string{
"email": context.Param("email"),
"password": context.Param("password"),
"name": nameFromEmail(context.Param("email")),
"status": "100",
"role": "100",
"title": "Administrator",
}
uid, err := users.Create(params)
if err != nil {
return router.InternalError(err)
}
context.Logf("#info Created user #%d", uid)
user, err := users.Find(uid)
if err != nil {
return router.InternalError(err)
}
// Login this user automatically - save cookie
session, err := auth.Session(context, context.Request())
if err != nil {
return router.InternalError(err)
}
context.Logf("#info Automatic login for first user: %d %s", user.Id, user.Email)
session.Set(auth.SessionUserKey, fmt.Sprintf("%d", user.Id))
session.Save(context)
// Load our welcomepage template html
// and put it into the text field of a new page with id 1
welcomeText, err := ioutil.ReadFile("src/pages/views/welcome.html.got")
if err != nil {
return router.InternalError(err)
}
params = map[string]string{
"status": "100",
"name": "Fragmenta",
"url": "/",
"text": string(welcomeText),
}
_, err = pages.Create(params)
if err != nil {
return router.InternalError(err)
}
// Create another couple of simple pages as examples (about and privacy)
params = map[string]string{
"status": "100",
"name": "About Us",
"url": "/about",
"text": "<section class=\"narrow\"><h1>About us</h1><p>About us</p></section>",
}
_, err = pages.Create(params)
if err != nil {
return router.InternalError(err)
}
params = map[string]string{
"status": "100",
"name": "Privacy Policy",
"url": "/privacy",
"text": "<section class=\"narrow\"><h1>Privacy Policy</h1><p>We respect your privacy.</p></section>",
}
_, err = pages.Create(params)
if err != nil {
return router.InternalError(err)
}
// Redirect back to the newly populated home page
return router.Redirect(context, "/")
}