func GetCommit(c *gin.Context) {
repo := session.Repo(c)
parsed, err := token.ParseRequest(c.Request, func(t *token.Token) (string, error) {
return repo.Hash, nil
})
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
if parsed.Text != repo.FullName {
c.AbortWithStatus(http.StatusUnauthorized)
return
}
commit := c.Param("sha")
branch := c.Query("branch")
if len(branch) == 0 {
branch = repo.Branch
}
build, err := store.GetBuildCommit(c, repo, commit, branch)
if err != nil {
c.AbortWithError(http.StatusNotFound, err)
return
}
c.JSON(http.StatusOK, build)
}
func GetBuild(c *gin.Context) {
if c.Param("number") == "latest" {
GetBuildLast(c)
return
}
repo := session.Repo(c)
num, err := strconv.Atoi(c.Param("number"))
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
build, err := store.GetBuildNumber(c, repo, num)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
jobs, _ := store.GetJobList(c, build)
out := struct {
*model.Build
Jobs []*model.Job `json:"jobs"`
}{build, jobs}
c.IndentedJSON(http.StatusOK, &out)
}
func WhiskyListR(c *gin.Context) {
// dependency injection
var (
whiskyStore = c.MustGet(WhiskyStoreKey).(WhiskyStore)
user = GetUser(c)
)
// get whiskies
list, err := whiskyStore.GetAllWhiskies()
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
// transform list into alphabet map
whiskies := map[string][]Whisky{}
for _, whisky := range list {
group := strings.ToUpper(whisky.Distillery[0:1])
whiskies[group] = append(whiskies[group], whisky)
}
c.HTML(http.StatusOK, "list.html", gin.H{
"User": user,
"Whiskies": whiskies,
})
}
func (s *Server) getTagsFile(c *gin.Context) {
id := c.Param("id")
content_path := c.Param("path")[1:] // '/' を消す
tag, err := TagFileFromFile(s.tagFilepath(id))
if err != nil {
c.AbortWithError(500, err)
return
}
bucket, err := tag.Bucket(s)
if err != nil {
c.AbortWithError(500, err)
return
}
content, found := bucket.Contents[content_path]
if !found {
c.AbortWithError(500, fmt.Errorf("content %s not found", content_path))
return
}
content_body, err := ioutil.ReadFile(s.hashFilepath(content.Hash))
if err != nil {
c.AbortWithError(500, err)
return
}
content_body, err = decode(content_body, tag.EncryptKey, tag.EncryptIv, content.Attr)
if err != nil {
c.AbortWithError(500, err)
return
}
c.Data(200, "text/plain", content_body)
}
func (m *PresencesController) create(ctx *gin.Context) {
presenceIn, topic, e := m.preCheckTopic(ctx)
if e != nil {
return
}
user, e := m.preCheckUser(ctx)
if e != nil {
return
}
isReadAccess := topic.IsUserReadAccess(user)
if !isReadAccess {
e := errors.New("No Read Access to topic " + presenceIn.Topic + " for user " + user.Username)
ctx.AbortWithError(http.StatusForbidden, e)
ctx.JSON(http.StatusForbidden, e)
return
}
var presence = models.Presence{}
err := presence.Upsert(user, topic, presenceIn.Status)
if err != nil {
log.Errorf("Error while InsertPresence %s", err)
ctx.AbortWithError(http.StatusInternalServerError, err)
ctx.JSON(http.StatusInternalServerError, err)
return
}
go models.WSPresence(&models.WSPresenceJSON{Action: "create", Presence: presence})
//out := &presenceJSONOut{Presence: presence}
//ctx.JSON(http.StatusCreated, nil)
}
func (u *AccountHandler) sendLoginToken(c *gin.Context, player *ge.PlayerStruct) {
if token, err := u.createLoginToken(player); err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
} else {
c.JSON(http.StatusOK, gin.H{"Token": token})
}
}
func CallRpcServiceWithContext(c *gin.Context, env Env, name, method string, req interface{}, res rpcResponse) bool {
// Get the service TCP client
client, err := getEnvTcpClient(name, env)
if goutils.HasErrorAndPrintStack(err) {
c.AbortWithError(http.StatusInternalServerError, err)
return true
}
err = client.Call(method, req, res)
if err != nil {
// Check if it is not found error
if err.Error() == "not found" {
c.AbortWithStatus(http.StatusNotFound)
} else {
goutils.PrintStackAndError(err)
c.AbortWithError(http.StatusInternalServerError, err)
}
return true
}
if res.HasError() {
c.JSON(http.StatusBadRequest, res.ReturnErrorMap())
return true
}
return false
}
func (rc *ResourceController) GetResource(ctx *gin.Context) {
var id bson.ObjectId
req := ctx.Request
resourceType := getResourceType(req.URL)
// Validate id as a bson Object ID
id, err := toBsonObjectID(ctx.Param("id"))
if err != nil {
ctx.AbortWithError(http.StatusBadRequest, err)
return
}
logger.Log.WithFields(
logrus.Fields{"resource type": resourceType, "id": id}).Info("GetResource")
resource, err := rc.LoadResource(resourceType, id)
if err != nil {
if err == mgo.ErrNotFound {
ctx.String(http.StatusNotFound, "Not Found")
ctx.Abort()
return
} else {
ctx.AbortWithError(http.StatusBadRequest, err)
return
}
}
logger.Log.WithFields(logrus.Fields{"resource": resource}).Info("GetResource")
ctx.JSON(http.StatusOK, resource)
}
func PatientEmrAttachments(r *gin.Context) {
id := r.Param("id")
if id == "" {
r.AbortWithStatus(http.StatusBadRequest)
return
}
var query string
var err error
var o []patientEmrAttachmentsResult
module := r.Param("module")
if module == "" {
query = "SELECT p.patient AS patient, p.module AS module, p.oid AS oid, p.annotation AS annotation, p.summary AS summary, p.stamp AS stamp, DATE_FORMAT(p.stamp, '%m/%d/%Y') AS date_mdy, m.module_name AS type, m.module_class AS module_namespace, p.locked AS locked, p.id AS id FROM patient_emr p LEFT OUTER JOIN modules m ON m.module_table = p.module WHERE p.patient = ? AND m.module_hidden = 0"
_, err = model.DbMap.Select(&o, query, id)
} else {
query = "SELECT p.patient AS patient, p.module AS module, p.oid AS oid, p.annotation AS annotation, p.summary AS summary, p.stamp AS stamp, DATE_FORMAT(p.stamp, '%m/%d/%Y') AS date_mdy, m.module_name AS type, m.module_class AS module_namespace, p.locked AS locked, p.id AS id FROM patient_emr p LEFT OUTER JOIN modules m ON m.module_table = p.module WHERE p.patient = ? AND p.module = ? AND m.module_hidden = 0"
_, err = model.DbMap.Select(&o, query, id, module)
}
if err != nil {
log.Print(err.Error())
r.AbortWithError(http.StatusInternalServerError, err)
return
}
r.JSON(http.StatusOK, o)
return
}
func (u *userHandler) Edit(c *gin.Context) {
var user models.User
currentUser := utils.MustGetCurrentUser(c)
if err := c.Bind(&user); err != nil {
errors := userResource.ParseError(err)
if len(errors) > 0 {
c.Error(errors[0])
return
}
}
userId := c.Param("userId")
if currentUser.Role != models.Admin {
user.Role = models.NormalUser
}
if currentUser.Role == models.NormalUser {
user.DeleteAt = nil
}
if err := userResource.Edit(userId, &user); err != nil {
c.AbortWithError(400, err)
return
}
c.JSON(200, user)
}
func CategoriesHandler(context *gin.Context, database *db.Context) {
result, err := database.Categories()
if err != nil {
context.AbortWithError(http.StatusInternalServerError, err)
}
context.JSON(http.StatusOK, result)
}
func (u *users) Authorize(c *gin.Context) {
var user model.User
db := database.GetDB()
if err := c.Bind(&user); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
} else {
if id, err := user.Auth(db); err != nil {
c.AbortWithError(http.StatusBadRequest, errors.New("Password or email incorrect"))
} else if u, err := url.Parse(c.Request.Referer()); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
} else {
s := session.GetSession(c.Request)
s.Values["user_id"] = id
session.Save(c.Request, c.Writer)
q := u.Query()
if err := db.Model(&user).Preload("Role").Preload("Organization").First(&user, id).Error; err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
} else if q.Get("response_type") != "code" || q.Get("client_id") == "" || q.Get("redirect_uri") == "" {
c.AbortWithError(http.StatusBadRequest, errors.New("Unsupported request"))
} else {
params := url.Values{}
params.Add("response_type", q.Get("response_type"))
params.Add("client_id", q.Get("client_id"))
params.Add("redirect_uri", q.Get("redirect_uri"))
params.Add("scope", q.Get("scope"))
c.Redirect(http.StatusFound, "/auth?"+params.Encode())
}
}
}
}
func _createMenu(c *gin.Context) {
var btn1 menu.Button
var btn1_sub1 menu.Button
var btn1_sub2 menu.Button
btn1_sub1.SetAsScanCodePushButton("push", "push")
btn1_sub2.SetAsScanCodeWaitMsgButton("waitmsg", "waitmsg")
var btn1_subs = []menu.Button{btn1_sub1, btn1_sub2}
btn1.SetAsSubMenuButton("扫毛", btn1_subs)
var btn2 menu.Button
btn2.SetAsLocationSelectButton("车位号", "location")
btns := []menu.Button{btn1, btn2}
var menu_ menu.Menu
menu_.Buttons = btns
err := menu.Create(global.WechatClient, &menu_)
var wxMenu = &model.WXMenu{
Id: bson.NewObjectId(),
Menu: menu.Menu{
Buttons: btns,
},
}
log.Println("创建菜单 ", err)
err = mgowrap.Save(wxMenu)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
log.Println("保存menu")
}
func CreateMenu(c *gin.Context) {
var btn1 menu.Button
btn1.SetAsScanCodeWaitMsgButton("扫码", "park")
var btn2 menu.Button
btn2.SetAsLocationSelectButton("锁号", "number")
var btn3 menu.Button
btn3.SetAsClickButton("充值", "encharge")
var btn4 menu.Button
btn4.SetAsClickButton("我的", "my")
btns := []menu.Button{btn1, btn2, btn3, btn4}
var menu_ menu.Menu
menu_.Buttons = btns
err := menu.Create(global.WechatClient, &menu_)
var wxMenu = &model.WXMenu{
Id: bson.NewObjectId(),
Menu: menu.Menu{
Buttons: btns,
},
}
log.Println("创建菜单 ", err)
err = mgowrap.Save(wxMenu)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
log.Println("保存menu")
}
// Delete deletes requested topic only if user is Tat admin, or admin on topic
func (t *TopicsController) Delete(ctx *gin.Context) {
topicRequest, err := GetParam(ctx, "topic")
if err != nil {
return
}
var user = models.User{}
err = user.FindByUsername(utils.GetCtxUsername(ctx))
if err != nil {
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Error while fetching user."})
return
}
paramJSON := paramTopicUserJSON{
Topic: topicRequest,
Username: user.Username,
Recursive: false,
}
topic, e := t.preCheckUser(ctx, ¶mJSON)
if e != nil {
return
}
err = topic.Delete(&user)
if err != nil {
ctx.AbortWithError(http.StatusInternalServerError, errors.New(err.Error()))
return
}
ctx.JSON(http.StatusOK, "")
}
// FriendshipShow takes a given ID from gin.Context
// @returns a specific friendship JSON object
func FriendshipShow(c *gin.Context) {
friendship := models.Friendship{}
if database.DBCon.First(&friendship, c.Param("id")).RecordNotFound() {
c.AbortWithError(http.StatusNotFound, appError.RecordNotFound).
SetMeta(appError.RecordNotFound)
return
}
var fd models.FriendshipData
database.DBCon.First(&friendship.User, friendship.UserID)
database.DBCon.First(&friendship.Friend, friendship.FriendID)
database.DBCon.First(&fd, friendship.FriendshipDataID)
if friendship.UserID == fd.PositiveUserID {
friendship.Balance = fd.Balance
} else {
friendship.Balance = -fd.Balance
}
data, err := jsonapi.Marshal(friendship)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err).
SetMeta(appError.JSONParseFailure)
return
}
c.Data(http.StatusOK, "application/vnd.api+json", data)
}
func (t *TopicsController) preCheckUserAdminOnTopic(ctx *gin.Context, topicName string) (models.Topic, error) {
topic := models.Topic{}
errfinding := topic.FindByTopic(topicName, true)
if errfinding != nil {
e := errors.New(errfinding.Error())
ctx.AbortWithError(http.StatusInternalServerError, e)
return topic, e
}
if utils.IsTatAdmin(ctx) { // if Tat admin, ok
return topic, nil
}
user, err := PreCheckUser(ctx)
if err != nil {
return models.Topic{}, err
}
if !topic.IsUserAdmin(&user) {
e := fmt.Errorf("user %s is not admin on topic %s", user.Username, topic.Topic)
ctx.AbortWithError(http.StatusForbidden, e)
return models.Topic{}, e
}
return topic, nil
}
func (rc *ResourceController) GetResources(ctx *gin.Context) {
req := ctx.Request
resourceType := getResourceType(req.URL)
logger.Log.WithFields(
logrus.Fields{"resource type": resourceType}).Info("GetResources")
resources := ptm_models.NewSliceForResourceName(resourceType, 0, 0)
c := rc.Database().C(ptm_models.GetCollectionName(resourceType))
// retrieve all documents in the collection
// TODO Restrict this to resource type, just to be extra safe
query := buildSearchQuery(resourceType, ctx)
logger.Log.WithFields(
logrus.Fields{"query": query}).Info("GetResources")
err := c.Find(query).All(resources)
if err != nil {
if err == mgo.ErrNotFound {
ctx.String(http.StatusNotFound, "Not Found")
ctx.Abort()
return
} else {
ctx.AbortWithError(http.StatusBadRequest, err)
return
}
}
ctx.JSON(http.StatusOK, resources)
}
func (h *StaticHandler) Handle(c *gin.Context) {
if !h.Cache {
c.Writer.Header().Add("Cache-Control",
"no-cache, no-store, must-revalidate")
c.Writer.Header().Add("Pragma", "no-cache")
c.Writer.Header().Add("Expires", "0")
}
path := filepath.Join(h.Root, filepath.FromSlash(
filepath.Clean("/"+c.Param("filepath"))))
isDir, err := IsDirectory(path)
if err != nil {
c.AbortWithError(500, err)
return
}
ok := false
if isDir {
ok, err = h.HandleDirList(path, c)
if err != nil {
c.AbortWithError(500, err)
return
}
}
if !ok {
if h.ContentType != "" {
c.Writer.Header().Add("Content-Type", h.ContentType)
}
h.fileServer.ServeHTTP(c.Writer, c.Request)
}
}
func Generate8bit(c *gin.Context) {
name := c.Param("name")
gender := c.Param("gender")
switch {
case gender == "m":
gender = "male"
case gender == "f":
gender = "female"
case gender == "male" || gender == "female":
//do nothing
default:
c.AbortWithError(http.StatusInternalServerError, errors.New("Invalid parameters"))
return
}
log.Println(name)
InitAssets()
img := GenerateIdenticon8bits(gender, []byte(name))
c.Header("Content-Type", "image/png")
c.Stream(func(w io.Writer) bool {
png.Encode(w, img)
return false
})
}
// List list all users matching Criteria
func (u *UsersController) List(ctx *gin.Context) {
criteria := u.buildCriteria(ctx)
listAsAdmin := false
if isTatAdmin(ctx) {
listAsAdmin = true
} else {
user, e := PreCheckUser(ctx)
if e != nil {
ctx.AbortWithError(http.StatusInternalServerError, e)
return
}
listAsAdmin = user.CanListUsersAsAdmin
}
count, users, err := userDB.ListUsers(criteria, listAsAdmin)
if err != nil {
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
out := &tat.UsersJSON{
Count: count,
Users: users,
}
ctx.JSON(http.StatusOK, out)
}
func suggest(c *gin.Context) {
cfg := getConfig(c)
conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
for {
movie, err := cfg.Store.GetRandom()
if err != nil {
continue
}
if err := conn.WriteJSON(movie); err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
time.Sleep(socketWaitFor)
}
}
// FriendshipIndex takes in query params through
// gin.Context and is restricted to the currentUser
// @returns an array of friendship JSON objects
func FriendshipIndex(c *gin.Context) {
friendships := []models.Friendship{}
var curUser models.User
database.DBCon.First(&curUser, c.Keys["CurrentUserID"])
database.DBCon.Model(&curUser).Related(&friendships, "Friendships")
// Get user and friend and friendshipData
// TODO: n + 1 query problem here, so we'll figure this out later
for i := range friendships {
var fd models.FriendshipData
database.DBCon.First(&friendships[i].Friend, friendships[i].FriendID)
database.DBCon.First(&fd, friendships[i].FriendshipDataID)
if curUser.ID == fd.PositiveUserID {
friendships[i].Balance = fd.Balance
} else {
friendships[i].Balance = -fd.Balance
}
friendships[i].User = curUser
}
data, err := jsonapi.Marshal(friendships)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err).
SetMeta(appError.JSONParseFailure)
return
}
c.Data(http.StatusOK, "application/vnd.api+json", data)
}
func GetAddonFiles(ctx *gin.Context) {
user := ctx.Params.ByName("user")
repository := ctx.Params.ByName("repository")
filepath := ctx.Params.ByName("filepath")[1:] // strip the leading "/"
log.Info("Request for: " + filepath)
lastReleaseTag, lastReleaseBranch := getLastRelease(user, repository)
switch filepath {
case "addons.xml":
GetAddonsXML(ctx)
return
case "addons.xml.md5":
GetAddonsXMLChecksum(ctx)
writeChangelog(user, repository)
return
case "fanart.jpg":
fallthrough
case "icon.png":
ctx.Redirect(302, fmt.Sprintf(githubUserContentURL+"/"+filepath, user, repository, lastReleaseBranch))
return
}
switch {
case addonZipRE.MatchString(filepath):
addonZip(ctx, user, repository, lastReleaseTag)
case addonChangelogRE.MatchString(filepath):
addonChangelog(ctx, user, repository)
default:
ctx.AbortWithError(404, errors.New(filepath))
}
}
func convertByFileHandler(c *gin.Context) {
s := c.MustGet("statsd").(*statsd.Client)
r, ravenOk := c.Get("sentry")
file, header, err := c.Request.FormFile("file")
if err != nil {
c.AbortWithError(http.StatusBadRequest, ErrFileInvalid).SetType(gin.ErrorTypePublic)
s.Increment("invalid_file")
return
}
ext := c.Query("ext")
source, err := converter.NewConversionSource("", file, ext)
if err != nil {
s.Increment("conversion_error")
if ravenOk {
r.(*raven.Client).CaptureError(err, map[string]string{"url": header.Filename})
}
c.Error(err)
return
}
conversionHandler(c, *source)
}
func addonZip(ctx *gin.Context, user string, repository string, lastReleaseTag string) {
release := getReleaseByTag(user, repository, lastReleaseTag)
// if there a release with an asset that matches a addon zip, use it
if release != nil {
client := github.NewClient(nil)
assets, _, _ := client.Repositories.ListReleaseAssets(user, repository, *release.ID, nil)
platformStruct := xbmc.GetPlatform()
platform := platformStruct.OS + "_" + platformStruct.Arch
var assetAllPlatforms string
for _, asset := range assets {
if strings.HasSuffix(*asset.Name, platform+".zip") {
assetPlatform := *asset.BrowserDownloadURL
log.Info("Using release asset for " + platform + ": " + assetPlatform)
ctx.Redirect(302, assetPlatform)
return
}
if addonZipRE.MatchString(*asset.Name) {
assetAllPlatforms = *asset.BrowserDownloadURL
log.Info("Found all platforms release asset: " + assetAllPlatforms)
continue
}
}
if assetAllPlatforms != "" {
log.Info("Using release asset for all platforms: " + assetAllPlatforms)
ctx.Redirect(302, assetAllPlatforms)
return
}
}
ctx.AbortWithError(404, errors.New("Release asset not found."))
}
func (m *MessagesController) updateMessage(ctx *gin.Context, messageIn *messageJSON, message models.Message, user models.User, topic models.Topic) {
info := ""
if messageIn.Action == "update" {
if !topic.CanUpdateMsg && !topic.CanUpdateAllMsg {
ctx.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("You can't update a message on topic %s", topic.Topic)})
return
}
if !topic.CanUpdateAllMsg && message.Author.Username != user.Username {
ctx.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Could not update a message from another user %s than you %s", message.Author.Username, user.Username)})
return
}
message.Text = messageIn.Text
err := message.Update(user, topic)
if err != nil {
log.Errorf("Error while update a message %s", err)
ctx.AbortWithError(http.StatusInternalServerError, err)
return
}
info = fmt.Sprintf("Message updated in %s", topic.Topic)
} else {
ctx.AbortWithError(http.StatusBadRequest, errors.New("Invalid action : "+messageIn.Action))
return
}
go models.WSMessage(&models.WSMessageJSON{Action: messageIn.Action, Username: user.Username, Message: message})
out := &messageJSONOut{Message: message, Info: info}
ctx.JSON(http.StatusOK, out)
}
func HomeR(c *gin.Context) {
// dependency injection
var (
whiskyStore = c.MustGet(WhiskyStoreKey).(WhiskyStore)
reviewStore = c.MustGet(ReviewStoreKey).(ReviewStore)
user = GetUser(c)
)
// temporary variables
var (
activity []Review
trending []Whisky
err error
)
// get activity stream for user
activity, err = reviewStore.GetActivity(user.ID, LIMIT)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
// get trending whiskies
trending, err = whiskyStore.GetTrending(LIMIT)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
c.HTML(http.StatusOK, "home.html", gin.H{
"User": user,
"Activity": activity,
"Trending": trending,
})
}
func EditReviewFormR(c *gin.Context) {
// dependency injection
var (
reviewStore = c.MustGet(ReviewStoreKey).(ReviewStore)
user = GetUser(c)
)
// only authenticated users can perform this action
if !user.Authenticated() {
c.AbortWithStatus(http.StatusUnauthorized)
return
}
// fetch review
id, err := strconv.Atoi(c.Param("id"))
if err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
review, err := reviewStore.GetReview(id)
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
c.HTML(http.StatusOK, "review-form.html", gin.H{
"Action": "Edit",
"User": user,
"Form": review,
"Errors": map[string]string{},
})
}
func UserListR(c *gin.Context) {
// dependency injection
var (
userStore = c.MustGet(UserStoreKey).(UserStore)
user = GetUser(c)
)
// get users
list, err := userStore.GetAllUser()
if err != nil {
c.AbortWithError(http.StatusInternalServerError, err)
return
}
// transform list into alphabet map
users := map[string][]User{}
for _, user := range list {
group := strings.ToUpper(user.Name[0:1])
users[group] = append(users[group], user)
}
c.HTML(http.StatusOK, "users.html", gin.H{
"User": user,
"Users": users,
})
}
