Exemplo n.º 1
0
// RetrieveLocation retrieves a location.
func RetrieveLocation(c *gin.Context) (model.Location, bool, int64, int, error) {
	var location model.Location
	var currentUserId int64
	isAuthor := false
	id := c.Params.ByName("id")
	if db.ORM.First(&location, "id = ?", id).RecordNotFound() {
		return location, isAuthor, currentUserId, http.StatusNotFound, errors.New("Location is not found.")
	}
	currentUser, err := userService.CurrentUser(c)
	if err == nil {
		currentUserId = currentUser.Id
		isAuthor = currentUser.Id == location.UserId
	}
	assignRelatedUser(&location)
	var commentList model.CommentList
	comments, currentPage, hasPrev, hasNext, _ := commentService.RetrieveComments(location)
	commentList.Comments = comments
	commentService.SetCommentPageMeta(&commentList, currentPage, hasPrev, hasNext, location.CommentCount)
	location.CommentList = commentList
	var likingList model.LikingList
	likings, currentPage, hasPrev, hasNext, _ := likingRetriever.RetrieveLikings(location)
	likingList.Likings = likings
	currentUserlikedCount := db.ORM.Model(&location).Where("id =?", currentUserId).Association("Likings").Count()
	log.Debugf("Current user like count : %d", currentUserlikedCount)
	likingMeta.SetLikingPageMeta(&likingList, currentPage, hasPrev, hasNext, location.LikingCount, currentUserlikedCount)
	location.LikingList = likingList
	return location, isAuthor, currentUserId, http.StatusOK, nil
}
Exemplo n.º 2
0
// RetrieveOauthStatus retrieves ouath status that provider connected or not.
func RetrieveOauthStatus(c *gin.Context) (oauthStatusMap, int, error) {
	var oauthStatus oauthStatusMap
	var connections []model.Connection
	oauthStatus = make(oauthStatusMap)
	currentUser, err := userService.CurrentUser(c)
	if err != nil {
		return oauthStatus, http.StatusUnauthorized, err
	}
	db.ORM.Model(&currentUser).Association("Connections").Find(&connections)
	for _, connection := range connections {
		log.Debugf("connection.ProviderId : %d", connection.ProviderId)
		switch connection.ProviderId {
		case google.ProviderId:
			oauthStatus["google"] = true
		case github.ProviderId:
			oauthStatus["github"] = true
		case yahoo.ProviderId:
			oauthStatus["yahoo"] = true
		case facebook.ProviderId:
			oauthStatus["facebook"] = true
		case twitter.ProviderId:
			oauthStatus["twitter"] = true
		case linkedin.ProviderId:
			oauthStatus["linkedin"] = true
		case kakao.ProviderId:
			oauthStatus["kakao"] = true
		case naver.ProviderId:
			oauthStatus["naver"] = true
		}
	}
	log.Debugf("oauthStatus : %v", oauthStatus)
	return oauthStatus, http.StatusOK, nil
}
Exemplo n.º 3
0
Arquivo: file.go Projeto: tka/goyangi
// CreateFiles creates files.
func CreateFiles(c *gin.Context) (int, error) {
	var forms FilesForm
	start := time.Now()
	c.BindWith(&forms, binding.JSON)
	log.Debugf("CreateFiles c form : %v", forms)

	user, _ := userService.CurrentUser(c)
	sqlStrBuffer := new(bytes.Buffer)
	stringHelper.Concat(sqlStrBuffer, "INSERT INTO file(user_id, name, size, created_at) VALUES ")
	values := []interface{}{}
	for _, file := range forms.Files {
		stringHelper.Concat(sqlStrBuffer, "(?, ?, ?, ?),")
		values = append(values, user.Id, file.Name, file.Size, time.Now())

	}
	// sqlStrBuffer.Truncate(sqlStrBuffer.Len() - 1) is slower than slice.
	if len(values) > 0 {
		sqlStr := sqlStrBuffer.String()
		sqlStr = sqlStr[0 : len(sqlStr)-1]
		log.Debugf("sqlStr for File : %s", sqlStr)
		db.ORM.Exec(sqlStr, values...)
		elapsed := time.Since(start)
		log.Debugf("CreateFiles elapsed : %s", elapsed)
	}

	return http.StatusCreated, nil
}
Exemplo n.º 4
0
// RetrieveArticle retrieve an article.
func RetrieveArticle(c *gin.Context) (model.Article, bool, int64, int, error) {
	var article model.Article
	var count int
	var currentUserId int64
	var isAuthor bool
	id := c.Params.ByName("id")
	if db.ORM.First(&article, "id = ?", id).RecordNotFound() {
		return article, isAuthor, currentUserId, http.StatusNotFound, errors.New("Article is not found.")
	}
	log.Debugf("Article : %s\n", article)
	log.Debugf("Count : %s\n", count)
	currentUser, err := userService.CurrentUser(c)
	if err == nil {
		currentUserId = currentUser.Id
		isAuthor = currentUser.Id == article.UserId
	}

	assignRelatedUser(&article)
	var commentList model.CommentList
	comments, currentPage, hasPrev, hasNext, _ := commentService.RetrieveComments(article)
	commentList.Comments = comments
	commentService.SetCommentPageMeta(&commentList, currentPage, hasPrev, hasNext, article.CommentCount)
	article.CommentList = commentList
	var likingList model.LikingList
	likings, currentPage, hasPrev, hasNext, _ := likingRetriever.RetrieveLikings(article)
	likingList.Likings = likings
	currentUserlikedCount := db.ORM.Model(&article).Where("id =?", currentUserId).Association("Likings").Count()
	log.Debugf("Current user like count : %d", currentUserlikedCount)
	likingMeta.SetLikingPageMeta(&likingList, currentPage, hasPrev, hasNext, article.LikingCount, currentUserlikedCount)
	article.LikingList = likingList
	return article, isAuthor, currentUserId, http.StatusOK, nil
}
Exemplo n.º 5
0
// canUserWrite check that user can write a location.
func canUserWrite(c *gin.Context) bool {
	canWrite := false
	_, err := userService.CurrentUser(c)
	if err == nil {
		canWrite = true
	}
	return canWrite
}
Exemplo n.º 6
0
// @Title test
// @Description test API.
// @Accept  json
// @Param   theString        form   string     true        "The string that required."
// @Param   theInt        form   int  false        "The int that optional."
// @Success 200 {object} response.BasicResponse "OK"
// @Failure 401 {object} response.BasicResponse "Authentication required"
// @Resource /experiments/test
// @Router /experiments [get]
func test(c *gin.Context) {
	currentUser, err := userService.CurrentUser(c)
	log.Debugf("header : %s", c.Request.Header.Get("X-Auth-Token"))
	// userService.SetCookieHandler(c, "elsa", "qqqq11")
	if err != nil {
		c.JSON(200, gin.H{"user": nil})
	} else {
		c.JSON(200, gin.H{"user": currentUser})
	}

}
Exemplo n.º 7
0
// UploadImages uploads images to a storage.
func UploadImages(c *gin.Context) (int, error) {
	r := c.Request
	reader, err := r.MultipartReader()
	user, _ = userService.CurrentUser(c)
	s3UploadPath = config.UploadS3Path + strconv.FormatInt(user.Id, 10) + "/"
	if err != nil {
		return http.StatusInternalServerError, err
	}
	Upload(reader, KindUploaderBasic)
	return http.StatusOK, nil
}
Exemplo n.º 8
0
// UploadAndSyncArticles uploads images and sync articles.
func UploadAndSyncArticles(c *gin.Context) (int, error) {
	r := c.Request
	reader, err := r.MultipartReader()
	user, _ = userService.CurrentUser(c)
	if err != nil {
		return http.StatusInternalServerError, err
	}
	Upload(reader, KindUploaderArticle)

	return http.StatusOK, nil
}
Exemplo n.º 9
0
// CurrentUserIdentical check that userId is same as current user's Id.
func CurrentUserIdentical(c *gin.Context, userId int64) (int, error) {
	currentUser, err := userService.CurrentUser(c)
	if err != nil {
		return http.StatusUnauthorized, errors.New("Auth failed.")
	}
	if currentUser.Id != userId {
		return http.StatusForbidden, errors.New("User is not identical.")
	}

	return http.StatusOK, nil
}
Exemplo n.º 10
0
// UploadAndSyncArticles uploads images and sync articles.
func UploadAndSyncArticles(c *gin.Context) (int, error) {
	r := c.Request
	reader, err := r.MultipartReader()
	user, _ = userService.CurrentUser(c)
	if err != nil {
		return http.StatusInternalServerError, err
	}
	// concurrency.Concurrent(reader, KindUploaderArticle)
	concurrency.Concurrent(reader, concurrency.ConcurrencyAgent(reader, Article업로더, ArticleUploader, ArticleCargador, ArticleShàngchuán, Articleзагрузчик))

	return http.StatusOK, nil
}
Exemplo n.º 11
0
// AuthRequired run function when user logged in.
func AuthRequired(f func(c *gin.Context)) gin.HandlerFunc {
	return func(c *gin.Context) {
		_, err := userService.CurrentUser(c)
		if err != nil {
			log.Error("Auth failed.")
			response.KnownErrorJSON(c, http.StatusUnauthorized, "error.loginPlease", errors.New("Auth failed."))
			return
		}
		f(c)
		return
	}
}
Exemplo n.º 12
0
// CreateArticle creates an article.
func CreateArticle(c *gin.Context) (model.Article, int, error) {
	var form ArticleForm
	c.BindWith(&form, binding.Form)
	log.Debugf("struct map : %s\n", form)
	user, _ := userService.CurrentUser(c)
	form.UserId = user.Id
	article := model.Article{}
	modelHelper.AssignValue(&article, &form)
	if db.ORM.Create(&article).Error != nil {
		return article, http.StatusInternalServerError, errors.New("User is not created.")
	}
	return article, http.StatusCreated, nil
}
Exemplo n.º 13
0
// CreateLocation creates a location.
func CreateLocation(c *gin.Context) (model.Location, int, error) {
	var form LocationForm
	c.BindWith(&form, binding.Form)
	log.Debugf("struct map : %s\n", form)
	user, _ := userService.CurrentUser(c)
	form.UserId = user.Id
	location := model.Location{}
	modelHelper.AssignValue(&location, &form)
	if db.ORM.Create(&location).Error != nil {
		return location, http.StatusInternalServerError, errors.New("User is not created.")
	}
	return location, http.StatusCreated, nil
}
Exemplo n.º 14
0
// canUserWrite check that user can write an article.
func canUserWrite(c *gin.Context, category int) bool {
	canWrite := false
	user, err := userService.CurrentUser(c)
	if err == nil {
		if category == 100 {
			if userPermission.HasAdmin(&user) {
				canWrite = true
			}
		} else {
			canWrite = true
		}
	}
	return canWrite
}
Exemplo n.º 15
0
// AdminRequired run function when user logged in and user has an admin role.
func AdminRequired(f func(c *gin.Context)) gin.HandlerFunc {
	return func(c *gin.Context) {
		user, err := userService.CurrentUser(c)
		if err == nil {
			if HasAdmin(&user) {
				f(c)
				log.Debug("User has admin role.")
				return
			}
		}
		log.Error("Admin role required.")
		response.KnownErrorJSON(c, http.StatusUnauthorized, "error.adminRequired", errors.New("Admin role required."))
		return
	}
}
Exemplo n.º 16
0
// UpdateUserLikedCount updates user liked count.
func UpdateUserLikedCount(c *gin.Context) (int, error) {
	log.Debug("UpdateUserLikedCount performed")
	currentUserSrc, err := userService.CurrentUser(c)
	var currentUser model.User
	if err != nil {
		return http.StatusUnauthorized, err
	}
	db.ORM.First(&currentUser, currentUserSrc.Id)
	currentUser.LikedCount = db.ORM.Model(currentUser).Association("Liked").Count()
	log.Debugf("LikedCount : %d", currentUser.LikedCount)
	if db.ORM.Save(currentUser).Error != nil {
		return http.StatusInternalServerError, errors.New("User liked count is not updated.")
	}
	return http.StatusOK, nil
}
Exemplo n.º 17
0
Arquivo: file.go Projeto: tka/goyangi
// CreateFile creates a file.
func CreateFile(c *gin.Context) (int, error) {
	var form FileForm
	c.BindWith(&form, binding.Form)
	log.Debugf("CreateFile form : %v", form)
	// err = json.Unmarshal(formDataBuffer[:n], &articles)
	// file := model.File{Name: form.Name, Size: form.Size}
	user, _ := userService.CurrentUser(c)
	form.UserId = user.Id
	file := model.File{}
	modelHelper.AssignValue(&file, &form)
	if db.ORM.Create(&file).Error != nil {
		return http.StatusInternalServerError, errors.New("File is not created.")
	}
	return http.StatusCreated, nil
}
Exemplo n.º 18
0
// RevokeOauth revokes oauth connection.
func RevokeOauth(c *gin.Context, providerID int64) (oauthStatusMap, int, error) {
	var oauthStatus oauthStatusMap
	var connection model.Connection
	currentUser, err := userService.CurrentUser(c)
	if err != nil {
		return oauthStatus, http.StatusUnauthorized, err
	}
	if db.ORM.First(&connection, "user_id= ? and provider_id = ? ", currentUser.Id, providerID).RecordNotFound() {
		return oauthStatus, http.StatusNotFound, errors.New("Connection is not found.")
	}
	if db.ORM.Delete(&connection).Error != nil {
		return oauthStatus, http.StatusInternalServerError, errors.New("Connection not revoked from user.")
	}
	oauthStatus, status, err := RetrieveOauthStatus(c)
	return oauthStatus, status, err
}
Exemplo n.º 19
0
// CreateArticles creates articles.
func CreateArticles(c *gin.Context) (int, error) {
	var forms ArticlesForm
	c.BindWith(&forms, binding.JSON)
	log.Debugf("CreateFiles c form : %v", forms)

	user, _ := userService.CurrentUser(c)
	sqlStrBuffer := new(bytes.Buffer)
	stringHelper.Concat(sqlStrBuffer, "INSERT INTO article(user_id, title, url, content, image_name, category_id, created_at) VALUES ")
	values := []interface{}{}
	for _, article := range forms.Articles {
		stringHelper.Concat(sqlStrBuffer, "(?, ?, ?, ?, ?, ?, ?),")
		values = append(values, user.Id, article.Title, article.Url, article.Content, article.ImageName, 0, time.Now())
	}
	// sqlStrBuffer.Truncate(sqlStrBuffer.Len() - 1) is slower than slice.
	if len(values) > 0 {
		sqlStr := sqlStrBuffer.String()
		sqlStr = sqlStr[0 : len(sqlStr)-1]
		log.Debugf("sqlStr for File : %s", sqlStr)
		db.ORM.Exec(sqlStr, values...)
	}

	return http.StatusCreated, nil
}
Exemplo n.º 20
0
// CreateOauthUser creates oauth user.
func CreateOauthUser(c *gin.Context, oauthUser *OauthUser, connection *model.Connection) (model.User, int, error) {
	var registrationForm userService.RegistrationForm
	var user model.User
	modelHelper.AssignValue(&registrationForm, oauthUser)
	registrationForm.Password = random.GenerateRandomString(12)
	if len(registrationForm.Username) == 0 {
		if len(registrationForm.Email) > 0 {
			registrationForm.Username = strings.Split(registrationForm.Email, "@")[0]
		} else {
			registrationForm.Username = "******"
		}
	}
	registrationForm.Username = userService.SuggestUsername(registrationForm.Username)
	generatedPassword, err := bcrypt.GenerateFromPassword([]byte(registrationForm.Password), 10)
	if err != nil {
		return user, http.StatusInternalServerError, errors.New("Password not generated.")
	}
	registrationForm.Password = string(generatedPassword)
	currentUser, err := userService.CurrentUser(c)
	if err != nil {
		log.Errorf("currentUser : %v", currentUser)
		user, err = userService.CreateUserFromForm(registrationForm)
		if err != nil {
			return user, http.StatusInternalServerError, errors.New("User is not created.")
		}
	} else {
		if db.ORM.Where("id = ?", currentUser.Id).First(&user).RecordNotFound() {
			return user, http.StatusInternalServerError, errors.New("User is not found.")
		}
	}
	db.ORM.Model(&user).Association("Connections").Append(connection)
	if db.ORM.Save(&user).Error != nil {
		return user, http.StatusInternalServerError, errors.New("Connection not appended to user.")
	}
	return user, http.StatusOK, nil
}