func CreatePost(input *duoerlapi.PostInput) (originInput *duoerlapi.PostInput, err error) {
originInput = input
// simple validation
if input.Content == "" {
err = global.CanNotBeBlankError
return
}
postId, err := utils.ToObjectId(input.Id)
if err != nil {
utils.PrintStackAndError(err)
return
}
authorId, err := utils.ToObjectId(input.AuthorId)
if err != nil {
utils.PrintStackAndError(err)
return
}
post := &posts.Post{
Id: postId,
Content: input.Content,
AuthorId: authorId,
}
if err = post.Save(); err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func CreateBrand(brandInput *duoerlapi.BrandInput) (input *duoerlapi.BrandInput, err error) {
input = brandInput
oId, err := utils.ToObjectId(brandInput.Id)
if err != nil {
utils.PrintStackAndError(err)
return
}
brand := &brands.Brand{
Id: oId,
Name: brandInput.Name,
Alias: brandInput.Alias,
Intro: brandInput.Intro,
Country: brandInput.Country,
Website: brandInput.Website,
Logo: brandInput.Logo,
}
if err = brand.Save(); err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func CreateFollowBrand(userId, brandId string) (err error) {
userOId, err := utils.ToObjectId(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
brandOId, err := utils.ToObjectId(brandId)
if err != nil {
utils.PrintStackAndError(err)
return
}
// Validation, check if the record has been created
followBrand, err := followbrands.FindByUserAndBrandId(userOId, brandOId)
if followBrand != nil {
return
}
followBrand = &followbrands.FollowBrand{
UserId: userOId,
BrandId: brandOId,
}
if err = followBrand.Save(); err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func AllProducts() (apiProducts []*duoerlapi.Product, err error) {
// Find all the products
dbProducts, err := products.FindAll(bson.M{})
if err != nil {
utils.PrintStackAndError(err)
return
}
// Collect brand/author Ids and find them
brandIds, authorIds := products.CollectBrandAndAuthorIds(dbProducts)
dbBrands, err := brands.FindByIds(brandIds)
if err != nil {
utils.PrintStackAndError(err)
return
}
dbAuthors, err := users.FindByIds(authorIds)
if err != nil {
utils.PrintStackAndError(err)
return
}
// Build the brandMap and authorMap
brandMap := brands.BuildBrandMap(dbBrands)
authorMap := users.BuildUserMap(dbAuthors)
apiProducts = toApiProducts(dbProducts, brandMap, authorMap)
return
}
func CreateNote(input *duoerlapi.NoteInput) (originInput *duoerlapi.NoteInput, err error) {
originInput = input
noteId, err := utils.ToObjectId(input.Id)
if err != nil {
utils.PrintStackAndError(err)
return
}
authorId, err := utils.ToObjectId(input.AuthorId)
if err != nil {
utils.PrintStackAndError(err)
return
}
note := ¬es.Note{
Id: noteId,
Article: *articles.NewArticle(input.Title, input.Content, authorId),
}
if err = note.Save(); err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func ShowBrand(brandId, userId string) (apiBrand *duoerlapi.Brand, err error) {
brandOId, err := utils.ToObjectId(brandId)
if err != nil {
utils.PrintStackAndError(err)
return
}
brand, err := brands.FindById(brandOId)
if err != nil {
utils.PrintStackAndError(err)
return
}
apiBrand = toApiBrand(brand)
apiBrand.BrandStats = getBrandStats(brandOId)
// Not login user
if userId == "" {
return
}
if followBrand := GetFollowBrand(userId, brandId); followBrand != nil {
apiBrand.HasFollowed = true
}
return
}
func AddWishItem(userId, productId string) (err error) {
userOId, err := utils.ToObjectId(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
productOId, err := utils.ToObjectId(productId)
if err != nil {
utils.PrintStackAndError(err)
return
}
// Validation, check if the record has been created
wishItem, err := wishitems.FindByUserAndProductId(userOId, productOId)
if wishItem != nil {
return
}
wishItem = &wishitems.WishItem{
UserId: userOId,
ProductId: productOId,
}
if err = wishItem.Save(); err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func AddOwnItem(ownItemInput *duoerlapi.OwnItemInput) (err error) {
userOId, err := utils.ToObjectId(ownItemInput.UserId)
if err != nil {
utils.PrintStackAndError(err)
return
}
productOId, err := utils.ToObjectId(ownItemInput.ProductId)
if err != nil {
utils.PrintStackAndError(err)
return
}
// Validation, check if the record has been created
ownItem, err := ownitems.FindByUserAndProductId(userOId, productOId)
if ownItem != nil {
return
}
ownItem = &ownitems.OwnItem{
UserId: userOId,
ProductId: productOId,
GotFrom: ownItemInput.GotFrom,
}
if err = ownItem.Save(); err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func UpdateBrand(input *duoerlapi.BrandInput) (originInput *duoerlapi.BrandInput, err error) {
originInput = input
brandOId, err := utils.ToObjectId(input.Id)
if err != nil {
utils.PrintStackAndError(err)
return
}
brand, err := brands.FindById(brandOId)
if err != nil {
utils.PrintStackAndError(err)
return
}
brand.Name = input.Name
brand.Alias = input.Alias
brand.Intro = input.Intro
brand.Country = input.Country
brand.Logo = input.Logo
brand.Website = input.Website
if err = brand.Save(); err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func populateCachedCategoriesRelated() {
apiCategoryMap := make(map[string]*duoerlapi.Category)
apiSubCategoryMap := make(map[string]*duoerlapi.SubCategory)
apiEfficacyMap := make(map[string]*duoerlapi.Efficacy)
apiCategories := []*duoerlapi.Category{}
apiSubCategories := []*duoerlapi.SubCategory{}
// Get all Categories
allCategories, err := categories.FindAll(nil)
if err != nil {
utils.PrintStackAndError(err)
return
}
for _, category := range allCategories {
switch category.Level {
case categories.LEVEL_ONE:
apiCategory := toApiCategory(category)
apiCategoryMap[apiCategory.Id] = apiCategory
apiCategories = append(apiCategories, apiCategory)
case categories.LEVEL_TWO:
apiSubCategory := toApiSubCategory(category)
apiSubCategories = append(apiSubCategories, apiSubCategory)
apiSubCategoryMap[apiSubCategory.Id] = apiSubCategory
}
}
for _, apiSubCategory := range apiSubCategories {
if apiCategory, exist := apiCategoryMap[apiSubCategory.ParentId]; exist {
apiCategory.SubCategories = append(apiCategory.SubCategories, apiSubCategory)
}
}
// Get all Efficacies
allEfficacies, err := efficacies.FindAll(nil)
if err != nil {
utils.PrintStackAndError(err)
return
}
for _, efficacy := range allEfficacies {
apiEfficacy := toApiEfficacy(efficacy)
apiEfficacyMap[apiEfficacy.Id] = apiEfficacy
if apiCategory, exist := apiCategoryMap[apiEfficacy.ParentId]; exist {
apiCategory.Efficacies = append(apiCategory.Efficacies, apiEfficacy)
}
}
global.Categories = apiCategories
global.CategoryMap = apiCategoryMap
global.SubCategoryMap = apiSubCategoryMap
global.EfficacyMap = apiEfficacyMap
return
}
func FetchByIdHex(idHex string) (user *User, err error) {
userId, err := utils.ToObjectId(idHex)
if err != nil {
utils.PrintStackAndError(err)
return
}
user, err = FindById(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func GetFollowBrand(userId, brandId string) (followBrand *followbrands.FollowBrand) {
userOId, err := utils.ToObjectId(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
brandOId, err := utils.ToObjectId(brandId)
if err != nil {
utils.PrintStackAndError(err)
return
}
followBrand, _ = followbrands.FindByUserAndBrandId(userOId, brandOId)
return
}
func GetBrandFollowers(brandIdHex string) (apiUsers []*duoerlapi.User, err error) {
brandId, err := utils.ToObjectId(brandIdHex)
if err != nil {
utils.PrintStackAndError(err)
return
}
followbrandz, err := followbrands.FindByBrandId(brandId)
if err != nil {
utils.PrintStackAndError(err)
return
}
maxNum := len(followbrandz)
// Get random number users
if maxNum > configs.BRAND_SHOW_FOLLOWER_NUM {
randIndex, err := randutil.IntRange(0, maxNum)
if err != nil {
utils.PrintStackAndError(err)
randIndex = 0
}
leftIndex := randIndex - configs.BRAND_SHOW_FOLLOWER_NUM
if leftIndex < 0 {
followbrandz = followbrandz[0:configs.BRAND_SHOW_FOLLOWER_NUM]
} else {
followbrandz = followbrandz[leftIndex:randIndex]
}
}
followerIds := []bson.ObjectId{}
for _, followBrand := range followbrandz {
followerIds = append(followerIds, followBrand.UserId)
}
followers, err := users.FindByIds(followerIds)
if err != nil {
utils.PrintStackAndError(err)
return
}
apiUsers = toApiUsers(followers)
return
}
// Todo: Validation Needed
func CreateReview(input *duoerlapi.ReviewInput) (originInput *duoerlapi.ReviewInput, err error) {
originInput = input
oId, err := utils.ToObjectId(input.Id)
if err != nil {
utils.PrintStackAndError(err)
return
}
productOId, err := utils.ToObjectId(input.ProductId)
if err != nil {
utils.PrintStackAndError(err)
return
}
// Check if the product exists
product, err := products.FindById(productOId)
if err != nil {
utils.PrintStackAndError(err)
return
}
authorOId, err := utils.ToObjectId(input.AuthorId)
if err != nil {
utils.PrintStackAndError(err)
return
}
review := &reviews.Review{
Id: oId,
AuthorId: authorOId,
ProductId: productOId,
BrandId: product.BrandId,
Content: input.Content,
Rating: input.Rating,
EfficacyIds: utils.TurnPlainIdsToObjectIds(input.EfficacyIds),
}
if err = review.Save(); err != nil {
utils.PrintStackAndError(err)
return
}
return
}
// For edit product form
func EditProduct(productId string) (productInput *duoerlapi.ProductInput, err error) {
productOId, err := utils.ToObjectId(productId)
if err != nil {
utils.PrintStackAndError(err)
return
}
product, err := products.FindById(productOId)
if err != nil {
utils.PrintStackAndError(err)
return
}
productInput = toProductInput(product)
return
}
func EditBrand(brandId string) (brandInput *duoerlapi.BrandInput, err error) {
brandOId, err := utils.ToObjectId(brandId)
if err != nil {
utils.PrintStackAndError(err)
return
}
brand, err := brands.FindById(brandOId)
if err != nil {
utils.PrintStackAndError(err)
return
}
brandInput = toBrandInput(brand)
return
}
func GetWishItem(userId, productId string) (wishItem *wishitems.WishItem, err error) {
userOId, err := utils.ToObjectId(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
productOId, err := utils.ToObjectId(productId)
if err != nil {
utils.PrintStackAndError(err)
return
}
wishItem, err = wishitems.FindByUserAndProductId(userOId, productOId)
return
}
func GetOwnItem(userId, productId string) (ownItem *ownitems.OwnItem, err error) {
userOId, err := utils.ToObjectId(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
productOId, err := utils.ToObjectId(productId)
if err != nil {
utils.PrintStackAndError(err)
return
}
ownItem, _ = ownitems.FindByUserAndProductId(userOId, productOId)
return
}
func ShowProduct(productId, userId string) (apiProduct *duoerlapi.Product, err error) {
productOId, err := utils.ToObjectId(productId)
if err != nil {
utils.PrintStackAndError(err)
return
}
product, err := products.FindById(productOId)
if err != nil {
utils.PrintStackAndError(err)
return
}
brand, err := brands.FindById(product.BrandId)
if err != nil {
utils.PrintStackAndError(err)
return
}
author, err := users.FindById(product.AuthorId)
if err != nil {
utils.PrintStackAndError(err)
return
}
apiProduct = toApiProduct(product, brand, author)
// Not login user
if userId == "" {
return
}
if wishItem, _ := GetWishItem(userId, productId); wishItem != nil {
apiProduct.HasWished = true
}
if ownItem, _ := GetOwnItem(userId, productId); ownItem != nil {
apiProduct.HasOwned = true
}
return
}
func GetUserPosts(userIdHex string) (apiPosts []*duoerlapi.Post, err error) {
userId, err := utils.ToObjectId(userIdHex)
if err != nil {
utils.PrintStackAndError(err)
return
}
postz, err := posts.FindSomeByAuthorId(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
for _, post := range postz {
apiPosts = append(apiPosts, toApiPost(post, nil))
}
return
}
func GetUsers() (apiUsers []*duoerlapi.User, err error) {
dbUsers, err := users.FindAll(nil)
if err != nil {
utils.PrintStackAndError(err)
return
}
apiUsers = toApiUsers(dbUsers)
return
}
func GetUserNotes(userIdHex string) (apiNotes []*duoerlapi.Note, err error) {
userId, err := utils.ToObjectId(userIdHex)
if err != nil {
utils.PrintStackAndError(err)
return
}
notez, err := notes.FindSomeByUserId(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
for _, note := range notez {
apiNotes = append(apiNotes, toApiNote(note, nil))
}
return
}
func GetBrandProducts(brandId string) (apiProducts []*duoerlapi.Product, err error) {
brandOId, err := utils.ToObjectId(brandId)
if err != nil {
utils.PrintStackAndError(err)
return
}
productz, err := products.FindByBrandId(brandOId)
if err != nil {
utils.PrintStackAndError(err)
return
}
for _, product := range productz {
apiProducts = append(apiProducts, toApiProduct(product, nil, nil))
}
return
}
func GetUser(userId string) (apiUser *duoerlapi.User, err error) {
user, err := users.FetchByIdHex(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
apiUser = toApiUser(user)
return
}
// Need to be cached
func AllBrands() (apiBrands []*duoerlapi.Brand, err error) {
dbBrands, err := brands.FindAll(bson.M{})
if err != nil {
utils.PrintStackAndError(err)
return
}
apiBrands = toApiBrands(dbBrands)
return
}
func RemoveOwnItem(userId, productId string) (err error) {
userOId, err := utils.ToObjectId(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
productOId, err := utils.ToObjectId(productId)
if err != nil {
utils.PrintStackAndError(err)
return
}
err = ownitems.DeleteByUserAndProductId(userOId, productOId)
if err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func getBrandStats(brandId bson.ObjectId) (brandStats *duoerlapi.BrandStats) {
var err error
brandStats = new(duoerlapi.BrandStats)
brandStats.FollowerCount, err = followbrands.CountBrandFollowerByBrandId(brandId)
if err != nil {
utils.PrintStackAndError(err)
}
brandStats.ProductCount, err = products.CountProductByBrandId(brandId)
if err != nil {
utils.PrintStackAndError(err)
}
brandStats.ReviewCount, err = reviews.CountReviewByBrandId(brandId)
if err != nil {
utils.PrintStackAndError(err)
}
return brandStats
}
func UpdateProfile(userInput *duoerlapi.UserInput) (err error) {
user, err := users.FetchByIdHex(userInput.Id)
if err != nil {
utils.PrintStackAndError(err)
return
}
user.AvatarUrl = userInput.Avatar
user.Profile.Gender = userInput.Profile.Gender
user.Profile.Location = userInput.Profile.Location
user.Profile.Description = userInput.Profile.Description
user.Profile.HairTexture = userInput.Profile.HairTexture
user.Profile.SkinTexture = userInput.Profile.SkinTexture
user.Profile.Birthday, _ = time.Parse(global.DATE_BIRTHDAY, userInput.Profile.Birthday)
if err = user.Save(); err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func GetReviewsInBrand(brandIdHex string) (apiReviews []*duoerlapi.Review, err error) {
brandId, err := utils.ToObjectId(brandIdHex)
if err != nil {
utils.PrintStackAndError(err)
return
}
reviewz, err := reviews.FindSomeByBrandId(brandId)
if err != nil {
utils.PrintStackAndError(err)
return
}
apiReviews, err = makeApiReviews(reviewz)
if err != nil {
utils.PrintStackAndError(err)
return
}
return
}
func DeleteFollowBrand(userId, brandId string) (err error) {
userOId, err := utils.ToObjectId(userId)
if err != nil {
utils.PrintStackAndError(err)
return
}
brandOId, err := utils.ToObjectId(brandId)
if err != nil {
utils.PrintStackAndError(err)
return
}
err = followbrands.DeleteByUserAndBrandId(userOId, brandOId)
if err != nil {
utils.PrintStackAndError(err)
return
}
return
}