Esempi in Golang per PrintStackAndError

Esempio n. 1

File: post_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 2

File: brand_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 3

File: followbrand_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 4

File: product_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 5

File: note_services.go Progetto: kobeld/duoerl

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 := &notes.Note{
		Id:      noteId,
		Article: *articles.NewArticle(input.Title, input.Content, authorId),
	}

	if err = note.Save(); err != nil {
		utils.PrintStackAndError(err)
		return
	}

	return
}

Esempio n. 6

File: brand_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 7

File: wish_item_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 8

File: own_item_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 9

File: brand_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 10

File: cache_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 11

File: user_curd.go Progetto: kobeld/duoerl

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
}

Esempio n. 12

File: followbrand_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 13

File: followbrand_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 14

File: review_services.go Progetto: kobeld/duoerl

// 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
}

Esempio n. 15

File: product_services.go Progetto: kobeld/duoerl

// 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
}

Esempio n. 16

File: brand_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 17

File: wish_item_services.go Progetto: kobeld/duoerl

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

}

Esempio n. 18

File: own_item_services.go Progetto: kobeld/duoerl

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

}

Esempio n. 19

File: product_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 20

File: post_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 21

File: user_services.go Progetto: kobeld/duoerl

func GetUsers() (apiUsers []*duoerlapi.User, err error) {
	dbUsers, err := users.FindAll(nil)
	if err != nil {
		utils.PrintStackAndError(err)
		return
	}

	apiUsers = toApiUsers(dbUsers)

	return
}

Esempio n. 22

File: note_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 23

File: product_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 24

File: user_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 25

File: brand_services.go Progetto: kobeld/duoerl

// 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
}

Esempio n. 26

File: own_item_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 27

File: brand_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 28

File: user_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 29

File: review_services.go Progetto: kobeld/duoerl

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
}

Esempio n. 30

File: followbrand_services.go Progetto: kobeld/duoerl

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
}