mirror of
https://github.com/samsonjs/retrogit.git
synced 2026-03-25 09:25:49 +00:00
b7760bc67e
Not all handlers are converted yet. Inspired by http://blog.golang.org/error-handling-and-go, but also (ab)uses the error mechanism to handle redirects.
634 lines
18 KiB
Go
634 lines
18 KiB
Go
package retrogit
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"appengine"
|
|
"appengine/delay"
|
|
"appengine/mail"
|
|
"appengine/urlfetch"
|
|
|
|
"code.google.com/p/goauth2/oauth"
|
|
"github.com/google/go-github/github"
|
|
"github.com/gorilla/mux"
|
|
"github.com/gorilla/sessions"
|
|
)
|
|
|
|
var router *mux.Router
|
|
var githubOauthConfig oauth.Config
|
|
var githubOauthPublicConfig oauth.Config
|
|
var timezones Timezones
|
|
var sessionStore *sessions.CookieStore
|
|
var sessionConfig SessionConfig
|
|
var templates map[string]*Template
|
|
|
|
func init() {
|
|
templates = loadTemplates()
|
|
timezones = initTimezones()
|
|
sessionStore, sessionConfig = initSession()
|
|
githubOauthConfig = initGithubOAuthConfig(true)
|
|
githubOauthPublicConfig = initGithubOAuthConfig(false)
|
|
|
|
router = mux.NewRouter()
|
|
router.Handle("/", AppHandler(indexHandler)).Name("index")
|
|
|
|
router.Handle("/session/sign-in", AppHandler(signInHandler)).Name("sign-in").Methods("POST")
|
|
router.HandleFunc("/session/sign-out", signOutHandler).Name("sign-out").Methods("POST")
|
|
router.HandleFunc("/github/callback", githubOAuthCallbackHandler)
|
|
|
|
router.HandleFunc("/digest/view", viewDigestHandler).Name("view-digest")
|
|
router.HandleFunc("/digest/send", sendDigestHandler).Name("send-digest").Methods("POST")
|
|
router.HandleFunc("/digest/cron", digestCronHandler)
|
|
|
|
router.Handle("/account/settings", AppHandler(settingsHandler)).Name("settings").Methods("GET")
|
|
router.HandleFunc("/account/settings", saveSettingsHandler).Name("save-settings").Methods("POST")
|
|
router.HandleFunc("/account/set-initial-timezone", setInitialTimezoneHandler).Name("set-initial-timezone").Methods("POST")
|
|
router.HandleFunc("/account/delete", deleteAccountHandler).Name("delete-account").Methods("POST")
|
|
|
|
router.HandleFunc("/admin/users", usersAdminHandler)
|
|
router.HandleFunc("/admin/digest", digestAdminHandler).Name("digest-admin")
|
|
http.Handle("/", router)
|
|
}
|
|
|
|
func initGithubOAuthConfig(includePrivateRepos bool) (config oauth.Config) {
|
|
path := "config/github-oauth"
|
|
if appengine.IsDevAppServer() {
|
|
path += "-dev"
|
|
}
|
|
path += ".json"
|
|
configBytes, err := ioutil.ReadFile(path)
|
|
if err != nil {
|
|
log.Panicf("Could not read GitHub OAuth config from %s: %s", path, err.Error())
|
|
}
|
|
err = json.Unmarshal(configBytes, &config)
|
|
if err != nil {
|
|
log.Panicf("Could not parse GitHub OAuth config %s: %s", configBytes, err.Error())
|
|
}
|
|
repoScopeModifier := ""
|
|
if !includePrivateRepos {
|
|
repoScopeModifier = "public_"
|
|
}
|
|
config.Scope = fmt.Sprintf("%srepo user:email", repoScopeModifier)
|
|
config.AuthURL = "https://github.com/login/oauth/authorize"
|
|
config.TokenURL = "https://github.com/login/oauth/access_token"
|
|
return
|
|
}
|
|
|
|
func indexHandler(w http.ResponseWriter, r *http.Request) *AppError {
|
|
session, _ := sessionStore.Get(r, sessionConfig.CookieName)
|
|
userId, ok := session.Values[sessionConfig.UserIdKey].(int)
|
|
if !ok {
|
|
return templates["index-signed-out"].Render(w, nil)
|
|
}
|
|
c := appengine.NewContext(r)
|
|
account, err := getAccount(c, userId)
|
|
if account == nil {
|
|
// Can't look up the account, session cookie must be invalid, clear it.
|
|
session.Options.MaxAge = -1
|
|
session.Save(r, w)
|
|
return RedirectToRoute("index")
|
|
}
|
|
if err != nil {
|
|
return InternalError(err, "Could not look up account")
|
|
}
|
|
|
|
oauthTransport := githubOAuthTransport(c)
|
|
oauthTransport.Token = &account.OAuthToken
|
|
githubClient := github.NewClient(oauthTransport.Client())
|
|
|
|
var wg sync.WaitGroup
|
|
wg.Add(2)
|
|
var user *github.User
|
|
var userErr error
|
|
var emailAddress string
|
|
var emailAddressErr error
|
|
go func() {
|
|
user, _, userErr = githubClient.Users.Get("")
|
|
wg.Done()
|
|
}()
|
|
go func() {
|
|
emailAddress, emailAddressErr = account.GetDigestEmailAddress(githubClient)
|
|
wg.Done()
|
|
}()
|
|
wg.Wait()
|
|
if userErr != nil {
|
|
return GitHubFetchError(userErr, "user")
|
|
}
|
|
if emailAddressErr != nil {
|
|
return GitHubFetchError(userErr, "emails")
|
|
}
|
|
|
|
var repositoryCount string
|
|
if len(account.ExcludedRepoIds) > 0 {
|
|
repositoryCount = fmt.Sprintf("all but %d", len(account.ExcludedRepoIds))
|
|
} else {
|
|
repositoryCount = "all"
|
|
}
|
|
|
|
var settingsSummary = map[string]interface{}{
|
|
"Frequency": account.Frequency,
|
|
"RepositoryCount": repositoryCount,
|
|
"EmailAddress": emailAddress,
|
|
}
|
|
flashes := session.Flashes()
|
|
if len(flashes) > 0 {
|
|
session.Save(r, w)
|
|
}
|
|
var data = map[string]interface{}{
|
|
"User": user,
|
|
"SettingsSummary": settingsSummary,
|
|
"DetectTimezone": !account.HasTimezoneSet,
|
|
"Flashes": flashes,
|
|
}
|
|
return templates["index"].Render(w, data)
|
|
}
|
|
|
|
func signInHandler(w http.ResponseWriter, r *http.Request) *AppError {
|
|
config := &githubOauthConfig
|
|
if r.FormValue("include_private") != "1" {
|
|
config = &githubOauthPublicConfig
|
|
}
|
|
authCodeUrl := config.AuthCodeURL("")
|
|
if continueUrl := r.FormValue("continue_url"); continueUrl != "" {
|
|
if parsedAuthCodeUrl, err := url.Parse(authCodeUrl); err == nil {
|
|
authCodeQuery := parsedAuthCodeUrl.Query()
|
|
redirectUrl := authCodeQuery.Get("redirect_uri")
|
|
if parsedRedirectUrl, err := url.Parse(redirectUrl); err == nil {
|
|
redirectUrlQuery := parsedRedirectUrl.Query()
|
|
redirectUrlQuery.Set("continue_url", continueUrl)
|
|
parsedRedirectUrl.RawQuery = redirectUrlQuery.Encode()
|
|
authCodeQuery.Set("redirect_uri", parsedRedirectUrl.String())
|
|
parsedAuthCodeUrl.RawQuery = authCodeQuery.Encode()
|
|
authCodeUrl = parsedAuthCodeUrl.String()
|
|
}
|
|
}
|
|
}
|
|
return RedirectToUrl(authCodeUrl)
|
|
}
|
|
|
|
func signOutHandler(w http.ResponseWriter, r *http.Request) {
|
|
session, _ := sessionStore.Get(r, sessionConfig.CookieName)
|
|
session.Options.MaxAge = -1
|
|
session.Save(r, w)
|
|
indexUrl, _ := router.Get("index").URL()
|
|
http.Redirect(w, r, indexUrl.String(), http.StatusFound)
|
|
}
|
|
|
|
func viewDigestHandler(w http.ResponseWriter, r *http.Request) {
|
|
session, _ := sessionStore.Get(r, sessionConfig.CookieName)
|
|
userId := session.Values[sessionConfig.UserIdKey].(int)
|
|
c := appengine.NewContext(r)
|
|
account, err := getAccount(c, userId)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
oauthTransport := githubOAuthTransport(c)
|
|
oauthTransport.Token = &account.OAuthToken
|
|
githubClient := github.NewClient(oauthTransport.Client())
|
|
|
|
digest, err := newDigest(c, githubClient, account)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
var data = map[string]interface{}{
|
|
"Digest": digest,
|
|
}
|
|
if err := templates["digest-page"].Execute(w, data); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
func sendDigestHandler(w http.ResponseWriter, r *http.Request) {
|
|
session, _ := sessionStore.Get(r, sessionConfig.CookieName)
|
|
userId := session.Values[sessionConfig.UserIdKey].(int)
|
|
c := appengine.NewContext(r)
|
|
account, err := getAccount(c, userId)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
sent, err := sendDigestForAccount(account, c)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if sent {
|
|
session.AddFlash("Digest emailed!")
|
|
} else {
|
|
session.AddFlash("No digest was sent, it was empty or disabled.")
|
|
}
|
|
session.Save(r, w)
|
|
indexUrl, _ := router.Get("index").URL()
|
|
http.Redirect(w, r, indexUrl.String(), http.StatusFound)
|
|
}
|
|
|
|
func digestCronHandler(w http.ResponseWriter, r *http.Request) {
|
|
c := appengine.NewContext(r)
|
|
accounts, err := getAllAccounts(c)
|
|
if err != nil {
|
|
c.Errorf("Error looking up accounts: %s", err.Error())
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
for _, account := range accounts {
|
|
if account.Frequency == "weekly" {
|
|
now := time.Now().In(account.TimezoneLocation)
|
|
if now.Weekday() != account.WeeklyDay {
|
|
c.Infof("Skipping %d, since it wants weekly digests on %ss and today is a %s.",
|
|
account.GitHubUserId, account.WeeklyDay, now.Weekday())
|
|
continue
|
|
}
|
|
}
|
|
c.Infof("Enqueing task for %d...", account.GitHubUserId)
|
|
sendDigestForAccountFunc.Call(c, account.GitHubUserId)
|
|
}
|
|
fmt.Fprint(w, "Done")
|
|
}
|
|
|
|
var sendDigestForAccountFunc = delay.Func(
|
|
"sendDigestForAccount",
|
|
func(c appengine.Context, githubUserId int) error {
|
|
c.Infof("Sending digest for %d...", githubUserId)
|
|
account, err := getAccount(c, githubUserId)
|
|
if err != nil {
|
|
c.Errorf(" Error looking up account: %s", err.Error())
|
|
return err
|
|
}
|
|
sent, err := sendDigestForAccount(account, c)
|
|
if err != nil {
|
|
c.Errorf(" Error: %s", err.Error())
|
|
} else if sent {
|
|
c.Infof(" Sent!")
|
|
} else {
|
|
c.Infof(" Not sent, digest was empty")
|
|
}
|
|
return err
|
|
})
|
|
|
|
func sendDigestForAccount(account *Account, c appengine.Context) (bool, error) {
|
|
oauthTransport := githubOAuthTransport(c)
|
|
oauthTransport.Token = &account.OAuthToken
|
|
githubClient := github.NewClient(oauthTransport.Client())
|
|
|
|
emailAddress, err := account.GetDigestEmailAddress(githubClient)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if emailAddress == "disabled" {
|
|
return false, nil
|
|
}
|
|
|
|
digest, err := newDigest(c, githubClient, account)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
if digest.Empty() {
|
|
return false, nil
|
|
}
|
|
|
|
var data = map[string]interface{}{
|
|
"Digest": digest,
|
|
}
|
|
var digestHtml bytes.Buffer
|
|
if err := templates["digest-email"].Execute(&digestHtml, data); err != nil {
|
|
return false, err
|
|
}
|
|
|
|
digestMessage := &mail.Message{
|
|
Sender: "RetroGit <digests@retrogit.com>",
|
|
To: []string{emailAddress},
|
|
Subject: "RetroGit Digest",
|
|
HTMLBody: digestHtml.String(),
|
|
}
|
|
err = mail.Send(c, digestMessage)
|
|
return true, err
|
|
}
|
|
|
|
func githubOAuthCallbackHandler(w http.ResponseWriter, r *http.Request) {
|
|
code := r.FormValue("code")
|
|
c := appengine.NewContext(r)
|
|
oauthTransport := githubOAuthTransport(c)
|
|
token, err := oauthTransport.Exchange(code)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
oauthTransport.Token = token
|
|
githubClient := github.NewClient(oauthTransport.Client())
|
|
user, _, err := githubClient.Users.Get("")
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
account := &Account{
|
|
GitHubUserId: *user.ID,
|
|
OAuthToken: *token,
|
|
}
|
|
err = account.Put(c)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
session, _ := sessionStore.Get(r, sessionConfig.CookieName)
|
|
session.Values[sessionConfig.UserIdKey] = user.ID
|
|
session.Save(r, w)
|
|
continueUrl := r.FormValue("continue_url")
|
|
if continueUrl == "" || !strings.HasPrefix(continueUrl, "/") {
|
|
indexUrl, _ := router.Get("index").URL()
|
|
continueUrl = indexUrl.String()
|
|
}
|
|
http.Redirect(w, r, continueUrl, http.StatusFound)
|
|
}
|
|
|
|
func settingsHandler(w http.ResponseWriter, r *http.Request) *AppError {
|
|
session, _ := sessionStore.Get(r, sessionConfig.CookieName)
|
|
userId := session.Values[sessionConfig.UserIdKey].(int)
|
|
c := appengine.NewContext(r)
|
|
account, err := getAccount(c, userId)
|
|
if err != nil {
|
|
// TODO: redirect to sign in again
|
|
return InternalError(err, "Could not look up account")
|
|
}
|
|
|
|
oauthTransport := githubOAuthTransport(c)
|
|
oauthTransport.Token = &account.OAuthToken
|
|
githubClient := github.NewClient(oauthTransport.Client())
|
|
|
|
user, _, err := githubClient.Users.Get("")
|
|
if err != nil {
|
|
return GitHubFetchError(err, "user")
|
|
}
|
|
|
|
repos, err := getRepos(c, githubClient, account, user)
|
|
if err != nil {
|
|
return GitHubFetchError(err, "repositories")
|
|
}
|
|
|
|
emails, _, err := githubClient.Users.ListEmails(nil)
|
|
if err != nil {
|
|
return GitHubFetchError(err, "emails")
|
|
}
|
|
emailAddresses := make([]string, len(emails))
|
|
for i := range emails {
|
|
emailAddresses[i] = *emails[i].Email
|
|
}
|
|
accountEmailAddress, err := account.GetDigestEmailAddress(githubClient)
|
|
if err != nil {
|
|
return GitHubFetchError(err, "emails")
|
|
}
|
|
|
|
flashes := session.Flashes()
|
|
if len(flashes) > 0 {
|
|
session.Save(r, w)
|
|
}
|
|
|
|
var data = map[string]interface{}{
|
|
"Account": account,
|
|
"User": user,
|
|
"Timezones": timezones,
|
|
"Repos": repos,
|
|
"EmailAddresses": emailAddresses,
|
|
"AccountEmailAddress": accountEmailAddress,
|
|
"Flashes": flashes,
|
|
}
|
|
return templates["settings"].Render(w, data)
|
|
}
|
|
|
|
func saveSettingsHandler(w http.ResponseWriter, r *http.Request) {
|
|
session, _ := sessionStore.Get(r, sessionConfig.CookieName)
|
|
userId := session.Values[sessionConfig.UserIdKey].(int)
|
|
c := appengine.NewContext(r)
|
|
account, err := getAccount(c, userId)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
oauthTransport := githubOAuthTransport(c)
|
|
oauthTransport.Token = &account.OAuthToken
|
|
githubClient := github.NewClient(oauthTransport.Client())
|
|
|
|
user, _, err := githubClient.Users.Get("")
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
repos, err := getRepos(c, githubClient, account, user)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
account.Frequency = r.FormValue("frequency")
|
|
weeklyDay, err := strconv.Atoi(r.FormValue("weekly_day"))
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
account.WeeklyDay = time.Weekday(weeklyDay)
|
|
|
|
timezoneName := r.FormValue("timezone_name")
|
|
_, err = time.LoadLocation(timezoneName)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
account.TimezoneName = timezoneName
|
|
|
|
account.ExcludedRepoIds = make([]int, 0)
|
|
for _, repo := range repos.AllRepos {
|
|
repoId := *repo.ID
|
|
_, included := r.Form[fmt.Sprintf("repo-%d", repoId)]
|
|
if !included {
|
|
account.ExcludedRepoIds = append(account.ExcludedRepoIds, repoId)
|
|
}
|
|
}
|
|
|
|
account.DigestEmailAddress = r.FormValue("email_address")
|
|
|
|
err = account.Put(c)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
session.AddFlash("Settings saved.")
|
|
session.Save(r, w)
|
|
settingsUrl, _ := router.Get("settings").URL()
|
|
http.Redirect(w, r, settingsUrl.String(), http.StatusFound)
|
|
}
|
|
|
|
func setInitialTimezoneHandler(w http.ResponseWriter, r *http.Request) {
|
|
session, _ := sessionStore.Get(r, sessionConfig.CookieName)
|
|
userId := session.Values[sessionConfig.UserIdKey].(int)
|
|
c := appengine.NewContext(r)
|
|
account, err := getAccount(c, userId)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
timezoneName := r.FormValue("timezone_name")
|
|
_, err = time.LoadLocation(timezoneName)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
account.TimezoneName = timezoneName
|
|
|
|
err = account.Put(c)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
// Since we've now computed an initial timezone for the user, start a
|
|
// background task to compute their digest. This ensures that we have most
|
|
// of the relevant data already cached if they choose to view or email their
|
|
// digest immediately.
|
|
cacheDigestForAccountFunc.Call(c, account.GitHubUserId)
|
|
}
|
|
|
|
var cacheDigestForAccountFunc = delay.Func(
|
|
"cacheDigestForAccount",
|
|
func(c appengine.Context, githubUserId int) error {
|
|
c.Infof("Caching digest for %d...", githubUserId)
|
|
account, err := getAccount(c, githubUserId)
|
|
if err != nil {
|
|
c.Errorf(" Error looking up account: %s", err.Error())
|
|
// Not returning error since we don't want these tasks to be
|
|
// retried.
|
|
return nil
|
|
}
|
|
|
|
oauthTransport := githubOAuthTransport(c)
|
|
oauthTransport.Token = &account.OAuthToken
|
|
githubClient := github.NewClient(oauthTransport.Client())
|
|
_, err = newDigest(c, githubClient, account)
|
|
if err != nil {
|
|
c.Errorf(" Error computing digest: %s", err.Error())
|
|
}
|
|
c.Infof(" Done!")
|
|
return nil
|
|
})
|
|
|
|
func deleteAccountHandler(w http.ResponseWriter, r *http.Request) {
|
|
session, _ := sessionStore.Get(r, sessionConfig.CookieName)
|
|
userId := session.Values[sessionConfig.UserIdKey].(int)
|
|
c := appengine.NewContext(r)
|
|
account, err := getAccount(c, userId)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
account.Delete(c)
|
|
session.Options.MaxAge = -1
|
|
session.Save(r, w)
|
|
|
|
indexUrl, _ := router.Get("index").URL()
|
|
http.Redirect(w, r, indexUrl.String(), http.StatusFound)
|
|
}
|
|
|
|
func usersAdminHandler(w http.ResponseWriter, r *http.Request) {
|
|
c := appengine.NewContext(r)
|
|
accounts, err := getAllAccounts(c)
|
|
if err != nil {
|
|
c.Errorf("Error looking up accounts: %s", err.Error())
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
users := make([]map[string]interface{}, len(accounts))
|
|
for i := range accounts {
|
|
account := &accounts[i]
|
|
oauthTransport := githubOAuthTransport(c)
|
|
oauthTransport.Token = &account.OAuthToken
|
|
githubClient := github.NewClient(oauthTransport.Client())
|
|
|
|
user, _, err := githubClient.Users.Get("")
|
|
|
|
emailAddress, err := account.GetDigestEmailAddress(githubClient)
|
|
if err != nil {
|
|
emailAddress = err.Error()
|
|
}
|
|
|
|
repos, reposErr := getRepos(c, githubClient, account, user)
|
|
|
|
users[i] = map[string]interface{}{
|
|
"Account": account,
|
|
"User": user,
|
|
"EmailAddress": emailAddress,
|
|
"Repos": repos,
|
|
"ReposError": reposErr,
|
|
}
|
|
}
|
|
var data = map[string]interface{}{
|
|
"Users": users,
|
|
}
|
|
if err := templates["users-admin"].Execute(w, data); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
func digestAdminHandler(w http.ResponseWriter, r *http.Request) {
|
|
userId, err := strconv.Atoi(r.FormValue("user_id"))
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
c := appengine.NewContext(r)
|
|
account, err := getAccount(c, userId)
|
|
if account == nil {
|
|
http.Error(w, "Couldn't find account", http.StatusNotFound)
|
|
return
|
|
}
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
oauthTransport := githubOAuthTransport(c)
|
|
oauthTransport.Token = &account.OAuthToken
|
|
githubClient := github.NewClient(oauthTransport.Client())
|
|
|
|
digest, err := newDigest(c, githubClient, account)
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
var data = map[string]interface{}{
|
|
"Digest": digest,
|
|
}
|
|
if err := templates["digest-admin"].Execute(w, data); err != nil {
|
|
http.Error(w, err.Error(), http.StatusInternalServerError)
|
|
}
|
|
}
|
|
|
|
func githubOAuthTransport(c appengine.Context) *oauth.Transport {
|
|
appengineTransport := &urlfetch.Transport{Context: c}
|
|
appengineTransport.Deadline = time.Second * 60
|
|
cachingTransport := &CachingTransport{
|
|
Transport: appengineTransport,
|
|
Context: c,
|
|
}
|
|
return &oauth.Transport{
|
|
Config: &githubOauthConfig,
|
|
Transport: cachingTransport,
|
|
}
|
|
}
|