func (this UserController) ListUsers(ctx framework.WebContext) framework.WebResult {
users, err := this.userService.List()
if err == nil {
return ctx.Json(users)
}
return ctx.Error(err)
}
// Start the authorization process
func (this *FacebookController) Auth(ctx framework.WebContext) framework.WebResult {
//can be used to pass state between server-to-server calls (roundtripped)
state := ""
//Get the Google URL which shows the Authentication page to the user
url := this.oauthCfg.AuthCodeURL(state)
//redirect user to that page
return ctx.Redirect(url)
}
func (this EventController) Test(ctx framework.WebContext) framework.WebResult {
//note: time.sleep frees the thread and allows other goroutines to execute
//sending 1000 concurrent requests with AB all complete within 5seconds
time.Sleep(1 * time.Second)
fmt.Println(ctx.Header())
fmt.Println("Test invoked")
return ctx.Text("test operation")
}
func (this UserController) GetUser(ctx framework.WebContext) framework.WebResult {
name, _ := ctx.Param("name")
email, _ := ctx.Param("email")
user, err := this.userService.Create(&contracts.User{Email: email, Name: name})
if err == nil {
return ctx.Json(user)
}
return ctx.Error(err)
}
func (this *GoogleController) TestHighLoad(ctx framework.WebContext) framework.WebResult {
n := randomizer.Int63()
email := fmt.Sprintf("*****@*****.**", n)
name := fmt.Sprintf("User %d", n)
dto := &contracts.User{Email: email, Name: name}
credentials := &contracts.UserAuthCredentials{
Type: framework.AuthType_Google,
AccessToken: fmt.Sprintf("Access token for user %s", name),
RefreshToken: fmt.Sprintf("Refresh token for user %s", name),
Expiry: time.Now().Add(1 * time.Hour),
}
_, err := this.userService.SaveWithCredentials(dto, credentials)
if err != nil {
log.Println(err)
return ctx.Error(err)
}
session := ctx.Session()
session.SetUser(&framework.SessionUser{
UserId: email,
AuthType: framework.AuthType_Google,
AuthData: credentials.AccessToken,
})
return ctx.Text("OK")
}
//adapted from Revel framework BinaryResult.Apply method
func (r *StreamResult) Write(ctx framework.WebContext) error {
var err error
// If we have a ReadSeeker, delegate to http.ServeContent
if rs, ok := r.Reader.(io.ReadSeeker); ok {
http.ServeContent(ctx, ctx.Req(), r.Name, r.ModTime, rs)
} else {
// Else, do a simple io.Copy.
if r.Length != -1 {
ctx.Header().Set("Content-Length", strconv.FormatInt(r.Length, 10))
}
ctx.WriteHeader(http.StatusOK)
//TODO: use a mime-type to file extension strategy like Revel does
//ctx.ContentType("application/octet-stream")
//ctx.ContentType(ContentTypeByFilename(r.Name))
_, err = io.Copy(ctx, r.Reader)
}
// Close the Reader if we can
if v, ok := r.Reader.(io.Closer); ok {
v.Close()
}
return err
}
func (r *TextResult) Write(ctx framework.WebContext) error {
ctx.WriteHeader(http.StatusOK)
ctx.ContentType("text/plain")
_, err := ctx.Write([]byte(r.Value))
return err
}
func (r *XmlResult) Write(ctx framework.WebContext) error {
data, err := xml.Marshal(r.Value)
if err == nil {
ctx.WriteHeader(http.StatusOK)
ctx.ContentType("application/xml")
ctx.Write(data)
}
return err
}
func (this *GoogleController) HandleRoot(ctx framework.WebContext) framework.WebResult {
session := ctx.Session()
if sessionUser := session.User(); sessionUser == nil {
return ctx.Template(notAuthenticatedTemplate, nil)
} else {
email := sessionUser.UserId
user, _ := this.userService.Get(email)
return ctx.Template(authenticatedTemplate, user.Name)
}
}
func (r *GenericResult) Write(ctx framework.WebContext) error {
if r.Status > 0 {
ctx.WriteHeader(r.Status)
} else {
ctx.WriteHeader(http.StatusOK)
}
if r.Message != "" {
ctx.Write([]byte(r.Message))
}
return nil
}
// Function that handles the callback from the Google server
func (this *FacebookController) AuthCallback(ctx framework.WebContext) framework.WebResult {
//Get the code from the response
code, _ := ctx.Param("code")
t := &oauth.Transport{Config: this.oauthCfg}
// Exchange the received code for a token
t.Exchange(code)
//now get user data based on the Transport which has the token
resp, err := t.Client().Get(this.profileInfoURL)
if err != nil {
log.Println(err)
return ctx.FrameworkError(framework.ToError(framework.Error_Web_UnableToAuthenticate, err))
}
userprofile := make(map[string]interface{})
decoder := json.NewDecoder(resp.Body)
err = decoder.Decode(&userprofile)
if err != nil {
log.Println(err)
return ctx.FrameworkError(framework.ToError(framework.Error_Web_UnableToAuthenticate, err))
}
fmt.Println(userprofile)
email := userprofile["email"].(string)
name := userprofile["name"].(string)
userDto := &contracts.User{Email: email, Name: name}
userCredentialsDto := &contracts.UserAuthCredentials{
Type: framework.AuthType_Facebook,
AccessToken: t.Token.AccessToken,
RefreshToken: t.Token.RefreshToken,
Expiry: t.Token.Expiry,
}
user, err2 := this.userService.SaveWithCredentials(userDto, userCredentialsDto)
if err2 != nil {
return ctx.Error(err2)
}
ctx.Session().SetUser(&framework.SessionUser{
UserId: user.Email,
AuthType: framework.AuthType_Facebook,
AuthData: t.AccessToken,
})
return ctx.Template(userInfoTemplate, fmt.Sprintf("Name: %s Email: %s", name, email))
}
func (this EventController) CreateEvent(ctx framework.WebContext) framework.WebResult {
return ctx.Unauthorized("Thou shall not create an event")
}
func (r *FrameworkErrorResult) Write(ctx framework.WebContext) error {
//TODO: implement properly
ctx.Write([]byte("Here goes FrameworkErrorResult: " + r.Err.Error()))
return nil
}
func (r *JsonResult) Write(ctx framework.WebContext) error {
data, err := json.Marshal(r.Value)
if err != nil {
return err
}
ctx.WriteHeader(http.StatusOK)
callback, _ := ctx.Param("callback")
if callback == "" {
//json
ctx.ContentType("application/json")
_, err = ctx.Write(data)
} else {
//jsonp
ctx.ContentType("application/javascript")
_, err = ctx.Write([]byte(fmt.Sprintf(jsonpFormat, callback)))
_, err = ctx.Write(data)
_, err = ctx.Write(jsonpEnclosing)
}
return err
}
func (r *RedirectResult) Write(ctx framework.WebContext) error {
ctx.Header().Set("Location", r.Url)
ctx.WriteHeader(r.Status)
return nil
}
func (this UserController) CreateUser(ctx framework.WebContext) framework.WebResult {
return ctx.Forbidden("Thou shall not create an user")
}
func (this UserController) Who(ctx framework.WebContext) framework.WebResult {
return ctx.Text("Anonymous")
}