Golang IsObjectIdHex示例

说明

golang isobjectidhex示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: gopkg/in/mgo/v2/bson

示例#1
文件: utils.go 项目: N4SJAMK/teamboard-api-go

func getTicket(db *mgo.Database, boardIDHex, ticketIDHex string) (
	*models.Ticket, *APIError,
) {
	if !bson.IsObjectIdHex(boardIDHex) || !bson.IsObjectIdHex(ticketIDHex) {
		return nil, &APIError{
			"Both 'board_id' and 'ticket_id' must be a valid 'ObjectIDs'",
			http.StatusBadRequest}
	}

	var (
		ticket      = models.Ticket{}
		ticketQuery = db.C("tickets").Find(bson.M{
			"_id":      bson.ObjectIdHex(ticketIDHex),
			"board_id": bson.ObjectIdHex(boardIDHex),
		})
	)

	if err := ticketQuery.One(&ticket); err != nil {
		if err == mgo.ErrNotFound {
			return nil, &APIError{"Ticket not found", http.StatusNotFound}
		}
		return nil, &APIError{err.Error(), http.StatusInternalServerError}
	}

	return &ticket, nil
}

示例#2
文件: ask.go 项目: coralproject/xenia

// DeleteSubmission deletes a submission as well as updating a form's stats.
func DeleteSubmission(context interface{}, db *db.DB, id, formID string) error {
	log.Dev(context, "DeleteSubmission", "Started : Submission[%s]", id)

	if !bson.IsObjectIdHex(id) {
		log.Error(context, "DeleteSubmission", ErrInvalidID, "Completed")
		return ErrInvalidID
	}

	if !bson.IsObjectIdHex(formID) {
		log.Error(context, "Delete", ErrInvalidID, "Completed")
		return ErrInvalidID
	}

	if err := submission.Delete(context, db, id); err != nil {
		log.Error(context, "DeleteSubmission", err, "Completed")
		return err
	}

	if _, err := form.UpdateStats(context, db, formID); err != nil {
		log.Error(context, "DeleteSubmission", err, "Completed")
		return err
	}

	log.Dev(context, "DeleteSubmission", "Started")
	return nil
}

示例#3
文件: models.go 项目: j3lte/se-poc

func SavePerson(p *Person) {
	c := getCollection()

	log.Printf("Saving person: %s", p.Id.Hex())

	log.Printf("Person has valid objectid: %s", bson.IsObjectIdHex(p.Id.Hex()))

	// Does the object exist?
	if !bson.IsObjectIdHex(p.Id.Hex()) {
		p.Id = bson.NewObjectId()
		err := c.Insert(p)

		log.Printf("Inserted person: %v", p.Id)
		if err != nil {
			log.Panic("Error whilst inserting person: %v", err)
		}
	} else {
		err := c.UpdateId(p.Id, p)

		log.Printf("Saved person: %v", p.Id)
		if err != nil {
			log.Panic("Error whilst updating person: %v", err)
		}
	}
}

示例#4
文件: FileService.go 项目: ClaudeXin/leanote

// 是否是我的文件
func (this *FileService) IsMyFile(userId, fileId string) bool {
	// 如果有问题会panic
	if !bson.IsObjectIdHex(fileId) || !bson.IsObjectIdHex(userId) {
		return false
	}
	return db.Has(db.Files, bson.M{"UserId": bson.ObjectIdHex(userId), "_id": bson.ObjectIdHex(fileId)})
}

示例#5
文件: groups.go 项目: cedmundo/hablo

// DelAdmin removes a member from an existing group
func DelAdmin(c *echo.Context) (int, interface{}) {
	digitsID, ok := c.Get("digitsID").(int64)
	if !ok {
		return msg.Forbidden("session required")
	}

	// Get group id and convert from string to objectId
	rawMID := c.Param("mid")
	if !bson.IsObjectIdHex(rawMID) {
		return msg.BadRequest("bad id: not a ObjectId")
	}

	// find the group
	memberID := bson.ObjectIdHex(rawMID)

	// Get group id and convert from string to objectId
	rawGID := c.Param("gid")
	if !bson.IsObjectIdHex(rawGID) {
		return msg.BadRequest("bad id: not a ObjectId")
	}

	// find the group
	groupID := bson.ObjectIdHex(rawGID)
	err := mangos.Update(constants.CGroups, bson.M{
		"$and": []bson.M{
			bson.M{"_id": groupID},
			bson.M{"admins": digitsID},
		},
	}, bson.M{"$pull": bson.M{"admins": memberID}})
	if err != nil {
		return msg.InternalError(err)
	}

	return msg.Ok("deleted admin")
}

示例#6
文件: server.go 项目: jaspalgill/cmpe273-assignment3

func (loccontroller Controller) Plan(writer http.ResponseWriter, request *http.Request, param httprouter.Params) {
	
	var detail RoutePlan

	arr := make([]Cordnts, 0)
	var map1 map[string]Cordnts
	map1 = make(map[string]Cordnts)

	json.NewDecoder(request.Body).Decode(&detail)
	if !bson.IsObjectIdHex(detail.Strt_locid) {
		writer.WriteHeader(400)
		return
	}
	strtpt = detail.Strt_locid
	strtid := bson.ObjectIdHex(detail.Strt_locid)
	if err := loccontroller.session.DB("jaspalgill").C("locations").FindId(strtid).One(&intLoc); err != nil {
		writer.WriteHeader(400)
		return
	}
	var bstroute BestRoute
	iniCordnts.Latitude = intLoc.Coordinate.Latitude
	iniCordnts.Longitude = intLoc.Coordinate.Longitude
	for l := 0; l < len(detail.Loc_id); l++ {
		id := detail.Loc_id[l]
		if !bson.IsObjectIdHex(id) {
			writer.WriteHeader(400)
			return
		} else {
			nid := bson.ObjectIdHex(id)
			var locatn Loc
			if err := loccontroller.session.DB("jaspalgill").C("locations").FindId(nid).One(&locatn); err != nil {
				writer.WriteHeader(400)
				return
			} else {
				var cordnt Cordnts
				cordnt.Latitude = locatn.Coordinate.Latitude
				cordnt.Longitude = locatn.Coordinate.Longitude
				map1[detail.Loc_id[l]] = cordnt
				arr = append(arr, cordnt)
			}
		}
	}
	Loop(iniCordnts, arr, map1)

	bstroute.id = bson.NewObjectId()
	bstroute.stats = "planning"
	bstroute.totldst = totldst
	bstroute.total_cost = totlcost
	bstroute.total_dur = totldur
	bstroute.Strt_locid = strtpt
	bstroute.bstroute_locid = bstRout
	loccontroller.session.DB("jaspalgill").C("cmpe273").Insert(bstroute)
	
	jsn, _ := json.Marshal(bstroute)

	writer.Header().Set("Content-Type", "application/json")
	writer.WriteHeader(200)
	fmt.Fprintf(writer, "%sess", jsn)
}

示例#7
文件: serverInterface.go 项目: joshheinrichs/cmpt436-project

/*
 * Handle all inbound websocket messages. This is where all payments and purchases
 * are given to the back-end, to be processed appropriately. There is no need for
 * this handle function to return a value to the webserver, because the webserver
 * rebroadcasts incoming feed items on its own, automatically. Just return an error
 * if the webserver should not be rebroadcasting: e.g. if an invalid purchase is made.
 *
 * This function is passed in a userId, which it uses to fill in the FeedItem, if
 * necessary. It then returns a new, filled-in feeditem.
 */
func HandleFeedItem(fi *FeedItem, userId string) (*FeedItem, error) {
	if !bson.IsObjectIdHex(fi.GroupID) || !bson.IsObjectIdHex(userId) {
		return nil, errors.New(invalidBsonIdHexErrorMessage)
	}
	switch fi.Type {
	case FeedItemTypeComment:
		comment := &Comment{}
		err := json.Unmarshal(fi.Content, comment)
		if err != nil {
			return nil, err
		}
		comment.UserID = userId
		return InsertAsFeedItem(FeedItemContent(comment), fi.GroupID)
	case FeedItemTypeNotification:
		notification := &Notification{}
		err := json.Unmarshal(fi.Content, notification)
		if err != nil {
			return nil, err
		}
		return InsertAsFeedItem(FeedItemContent(notification), fi.GroupID)
	case FeedItemTypePayment:
		payment := &Payment{}
		err := json.Unmarshal(fi.Content, payment)
		if err != nil {
			return nil, err
		}
		payment.UserId = userId
		group, err := FindGroup(bson.ObjectIdHex(fi.GroupID))
		if err != nil {
			return nil, err
		}
		err = PayMember(group, payment.PayerID, payment.PayeeID, payment.AmountInCents)
		if err != nil {
			return nil, err
		}
		return InsertAsFeedItem(FeedItemContent(payment), fi.GroupID)
	case FeedItemTypePurchase:
		purchase := &Purchase{}
		err := json.Unmarshal(fi.Content, purchase)
		if err != nil {
			return nil, err
		}
		purchase.UserId = userId
		group, err := FindGroup(bson.ObjectIdHex(fi.GroupID))
		if err != nil {
			return nil, err
		}
		err = DoPurchase(group, purchase.PayerID,
			purchase.AmountInCents, purchase.Expected)
		if err != nil {
			return nil, err
		}
		return InsertAsFeedItem(FeedItemContent(purchase), fi.GroupID)
	default:
		return nil, errors.New(fmt.Sprint("invalid FeedItem type: ", fi.Type))
	}
}

示例#8
文件: validation.go 项目: grebett/validation

// This function check if the real type behind the interface value is the one wished by the validators
func checkType(validator *Validator, valueToTest interface{}, errors *[]*DataError) bool {
	kind := reflect.ValueOf(valueToTest).Kind()
	switch kind {
	case reflect.Slice:
		array := validator.Type[0:2] // indeed, the type representation string begins with []
		_type := validator.Type[2:]  // here we have the type after []
		if array != "[]" {
			*errors = append(*errors, &DataError{Type: "Validation error", Reason: "Type mismatch", Field: validator.Field, Value: reflect.TypeOf(valueToTest).String()})
			return false
		} else {
			for _, value := range valueToTest.([]interface{}) {
				vtype := reflect.TypeOf(value).String()
				if vtype != _type {
					// _type can be bson.ObjectId... which is basicly a string. So the condition above may fail but the type is in fact correct. Let's check:
					if stringValue, ok := value.(string); ok && _type == "bson.ObjectId" && bson.IsObjectIdHex(stringValue) {
						return true
					} else {
						*errors = append(*errors, &DataError{Type: "Validation error", Reason: "Type mismatch", Field: validator.Field, Value: "[] contains " + reflect.TypeOf(value).String()})
						return false
					}
				}
			}
		}
	case reflect.Map:
		// json maps are map[string]interface{}, but we could test for more...
		parts := strings.SplitAfter(validator.Type, "]")
		for key, value := range valueToTest.(map[string]interface{}) {
			vtype := reflect.TypeOf(value)

			// such as is the string key a correct ObjectId ?
			if parts[0] == "map[bson.ObjectId]" {
				if !bson.IsObjectIdHex(key) {
					*errors = append(*errors, &DataError{Type: "Validation error", Reason: "Type mismatch", Field: validator.Field, Value: "one of the indexes at least is not valid ObjectId: " + key})
					return false
				}
			}

			// or test the real value behind interface{}
			if vtype.String() != parts[1] {
				*errors = append(*errors, &DataError{Type: "Validation error", Reason: "Type mismatch", Field: validator.Field, Value: "one of the map values is of type: " + vtype.String()})
				return false
			}
		}
	default:
		if _type := reflect.TypeOf(valueToTest); _type != nil && _type.String() != validator.Type {
			// bson.ObjectId is match as a string, let's try to save them off the error pireflect.TypeOf(valueToTest)reflect.TypeOf(valueToTest)t
			if _type.String() == "string" && bson.IsObjectIdHex(valueToTest.(string)) && validator.Type == "bson.ObjectId" {
				return true
			} else {
				// ok, let'em fall
				*errors = append(*errors, &DataError{Type: "Validation error", Reason: "Type mismatch", Field: validator.Field, Value: _type.String()})
				return false
			}
		}
	}
	return true
}

示例#9
文件: default_mongo_store.go 项目: phuc0302/go-oauth2

// Find token with credential
func (d *DefaultMongoStore) queryTokenWithCredential(table string, clientID string, userID string) Token {
	/* Condition validation */
	if len(clientID) == 0 || len(userID) == 0 || !bson.IsObjectIdHex(clientID) || !bson.IsObjectIdHex(userID) {
		return nil
	}

	token := new(DefaultToken)
	if err := mongo.EntityWithCriteria(table, bson.M{"user_id": bson.ObjectIdHex(userID), "client_id": bson.ObjectIdHex(clientID)}, token); err != nil {
		return nil
	}
	return token
}

示例#10
文件: address.go 项目: ninnemana/API

func DeleteAddress(w http.ResponseWriter, req *http.Request, params martini.Params, enc encoding.Encoder, shop *cart.Shop) string {

	var c cart.Customer

	customerId := params["id"]
	if !bson.IsObjectIdHex(customerId) {
		apierror.GenerateError("invalid customer reference", nil, w, req)
		return ""
	}

	c.Id = bson.ObjectIdHex(customerId)
	c.ShopId = shop.Id
	if err := c.Get(); err != nil {
		apierror.GenerateError("", err, w, req)
		return ""
	}

	addressId := params["address"]
	if !bson.IsObjectIdHex(addressId) {
		apierror.GenerateError("invalid address reference", nil, w, req)
		return ""
	}

	// Make sure this isn't the default address
	if c.DefaultAddress != nil && c.DefaultAddress.Id.Hex() == addressId {
		apierror.GenerateError("removing a default address is not allowed", nil, w, req)
		return ""
	}

	found := false
	for i, addr := range c.Addresses {
		if addr.Id.Hex() == addressId {
			c.Addresses = append(c.Addresses[:i], c.Addresses[i+1:]...)
			found = true
			break
		}
	}

	if !found {
		apierror.GenerateError("invalid address reference", nil, w, req)
		return ""
	}

	if err := c.Update(); err != nil {
		apierror.GenerateError(err.Error(), err, w, req)
		return ""
	}

	return ""
}

示例#11
文件: gallery.go 项目: coralproject/xenia

// RemoveAnswer adds an answer to a form gallery. Duplicated answers
// are de-duplicated automatically and will not return an error.
func RemoveAnswer(context interface{}, db *db.DB, id, submissionID, answerID string) (*Gallery, error) {
	log.Dev(context, "RemoveAnswer", "Started : Gallery[%s]", id)

	if !bson.IsObjectIdHex(id) {
		log.Error(context, "RemoveAnswer", ErrInvalidID, "Completed")
		return nil, ErrInvalidID
	}

	if !bson.IsObjectIdHex(submissionID) {
		log.Error(context, "RemoveAnswer", ErrInvalidID, "Completed")
		return nil, ErrInvalidID
	}

	objectID := bson.ObjectIdHex(id)

	answer := Answer{
		SubmissionID: bson.ObjectIdHex(submissionID),
		AnswerID:     answerID,
	}

	if err := answer.Validate(); err != nil {
		log.Error(context, "RemoveAnswer", err, "Completed")
		return nil, err
	}

	f := func(c *mgo.Collection) error {
		u := bson.M{
			"$pull": bson.M{
				"answers": answer,
			},
		}
		log.Dev(context, "RemoveAnswer", "MGO : db.%s.update(%s, %s)", c.Name, mongo.Query(objectID), mongo.Query(u))
		return c.UpdateId(objectID, u)
	}

	if err := db.ExecuteMGO(context, Collection, f); err != nil {
		log.Error(context, "RemoveAnswer", err, "Completed")
		return nil, err
	}

	gallery, err := Retrieve(context, db, id)
	if err != nil {
		log.Error(context, "RemoveAnswer", err, "Completed")
		return nil, err
	}

	log.Dev(context, "RemoveAnswer", "Completed")
	return gallery, nil
}

示例#12
文件: GetData.go 项目: DeepaDhingra/cmpe273-assignment2

func (uc UserController) GetUser(rw http.ResponseWriter, req *http.Request, p httprouter.Params) {
	// Grab id
	id := p.ByName("location_id")

	// Verify id is ObjectId, otherwise bail
	if !bson.IsObjectIdHex(id) {
		rw.WriteHeader(404)
		return
	}

	// Grab id
	oid := bson.ObjectIdHex(id)

	// Stub user
	u := UserLocation{}
	// Fetch user
	if err := uc.session.DB("mongodatabase").C("CMPE273").FindId(oid).One(&u); err != nil {
		rw.WriteHeader(404)
		return
	}

	// Marshal provided interface into JSON structure
	uj, _ := json.Marshal(u)

	// Write content-type, statuscode, payload
	rw.Header().Set("Content-Type", "application/json")
	rw.WriteHeader(200)
	fmt.Fprintf(rw, "%s", uj)
}

示例#13
文件: interface.go 项目: bfloriang/dock2box

func (c *InterfaceController) Delete(w http.ResponseWriter, r *http.Request) {
	// Get ID
	id := mux.Vars(r)["id"]

	// Validate ObjectId
	if !bson.IsObjectIdHex(id) {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	// Get object id
	oid := bson.ObjectIdHex(id)

	// Initialize empty struct
	s := models.Interface{}

	// Get entry
	if err := c.session.DB(c.database).C("interfaces").FindId(oid).One(&s); err != nil {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	// Remove entry
	if err := c.session.DB(c.database).C("interfaces").RemoveId(oid); err != nil {
		w.WriteHeader(http.StatusNotFound)
		return
	}

	// Write status
	jsonWriter(w, r, s, http.StatusOK, c.envelope)
}

示例#14
文件: package.go 项目: makohill/androidfancier.cn

// URL: /p/{packageId}
// 显示第三方包详情
func showPackageHandler(handler *Handler) {
	vars := mux.Vars(handler.Request)

	packageId := vars["packageId"]

	if !bson.IsObjectIdHex(packageId) {
		http.NotFound(handler.ResponseWriter, handler.Request)
		return
	}

	c := handler.DB.C(CONTENTS)

	package_ := Package{}
	err := c.Find(bson.M{"_id": bson.ObjectIdHex(packageId), "content.type": TypePackage}).One(&package_)

	if err != nil {
		message(handler, "没找到该包", "请检查链接是否正确", "error")
		fmt.Println("showPackageHandler:", err.Error())
		return
	}

	var categories []PackageCategory

	c = handler.DB.C(PACKAGE_CATEGORIES)
	c.Find(nil).All(&categories)

	handler.renderTemplate("package/show.html", BASE, map[string]interface{}{
		"package":    package_,
		"categories": categories,
		"active":     "package",
	})
}

示例#15
文件: user.go 项目: MingxiaoGuo/CMPE273-assignment2

func (uc UserController) UpdateLocations(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
	id := p.ByName("id")

	if !bson.IsObjectIdHex(id) {
		w.WriteHeader(404)
		return
	}

	oid := bson.ObjectIdHex(id)
	l := structure.Location{}
	json.NewDecoder(r.Body).Decode(&l)
	str := getURL(l.Address, l.City, l.State)
	getLocation(&l, str)
	l.Id = oid
	if err := uc.session.DB("cmpe273_project").C("hello").Update(bson.M{"_id": l.Id}, bson.M{"$set": bson.M{"address": l.Address, "city": l.City, "state": l.State, "zip": l.Zip, "coordinate.lat": l.Coordinate.Lat, "coordinate.lng": l.Coordinate.Lng}}); err != nil {
		w.WriteHeader(404)
		return
	}
	if err := uc.session.DB("cmpe273_project").C("hello").FindId(oid).One(&l); err != nil {
		w.WriteHeader(404)
		return
	}
	lj, _ := json.Marshal(l)

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(201)
	fmt.Fprintf(w, "%s", lj)
}

示例#16
文件: demoserver.go 项目: rm8x/golang-demoserver

func (c *appContext) unlockHandler(w http.ResponseWriter, r *http.Request) {

	p := r.URL.Path
	selector := p[8:]
	fmt.Println(p)
	fmt.Println(selector)

	//verify selector is ObjectId, otherwise bail
	if !bson.IsObjectIdHex(selector) {
		fmt.Println("selector is not valid bson ObjectId hex")
		w.WriteHeader(404)
		return
	}
	oid := bson.ObjectIdHex(selector)
	//todo: make more improved~!!!!
	info := Submitter{} //stub
	s := c.db.Copy()
	defer s.Close()
	err := s.DB("db-init-2").C("submitter").FindId(oid).One(&info);
	if err != nil {
		w.WriteHeader(404)
		return
	}
	w.Header().Set("Content-Type", "text")
	w.WriteHeader(200)
	fmt.Fprintf(w, "%s", "path=\n")
	fmt.Fprintf(w, "%s", selector)
	fmt.Fprintf(w, "%s", info)
	return
}

示例#17
文件: Go-Server.go 项目: Noman-Khan-SJSU/cmpe273-assignment2

//Update an already existing address
func (uc LocationController) UpdateLocation(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
	var i InputAddress
	var o OutputAddress
	id := p.ByName("location_id")
	if !bson.IsObjectIdHex(id) {
		w.WriteHeader(404)
		return
	}
	oid := bson.ObjectIdHex(id)
	if err := uc.session.DB("mongolocations").C("locations").FindId(oid).One(&o); err != nil {
		w.WriteHeader(404)
		return
	}
	json.NewDecoder(r.Body).Decode(&i)
	googResCoor := getGoogleCoordinates(i.Address + "+" + i.City + "+" + i.State + "+" + i.Zip)
	fmt.Println("resp is: ", googResCoor.Coordinate.Lat, googResCoor.Coordinate.Lang)
	o.Address = i.Address
	o.City = i.City
	o.State = i.State
	o.Zip = i.Zip
	o.Coordinate.Lat = googResCoor.Coordinate.Lat
	o.Coordinate.Lang = googResCoor.Coordinate.Lang
	c := uc.session.DB("mongolocations").C("locations")
	id2 := bson.M{"_id": oid}
	err := c.Update(id2, o)
	if err != nil {
		panic(err)
	}
	uj, _ := json.Marshal(o)
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(201)
	fmt.Fprintf(w, "%s", uj)
}

示例#18
文件: NotebookService.go 项目: intZz/leanote

// 更新笔记, api
func (this *NotebookService) UpdateNotebookApi(userId, notebookId, title, parentNotebookId string, seq, usn int) (bool, string, info.Notebook) {
	if notebookId == "" {
		return false, "notebookIdNotExists", info.Notebook{}
	}

	// 先判断usn是否和数据库的一样, 如果不一样, 则冲突, 不保存
	notebook := this.GetNotebookById(notebookId)
	// 不存在
	if notebook.NotebookId == "" {
		return false, "notExists", notebook
	} else if notebook.Usn != usn {
		return false, "conflict", notebook
	}
	notebook.Usn = userService.IncrUsn(userId)
	notebook.Title = title

	updates := bson.M{"Title": title, "Usn": notebook.Usn, "Seq": seq, "UpdatedTime": time.Now()}
	if parentNotebookId != "" && bson.IsObjectIdHex(parentNotebookId) {
		updates["ParentNotebookId"] = bson.ObjectIdHex(parentNotebookId)
	} else {
		updates["ParentNotebookId"] = ""
	}
	ok := db.UpdateByIdAndUserIdMap(db.Notebooks, notebookId, userId, updates)
	if ok {
		return ok, "", this.GetNotebookById(notebookId)
	}
	return false, "", notebook
}

示例#19
文件: submission.go 项目: coralproject/xenia

// RemoveFlag removes a flag from a given Submission in
// the MongoDB database collection.
func RemoveFlag(context interface{}, db *db.DB, id, flag string) (*Submission, error) {
	log.Dev(context, "RemoveFlag", "Started : Submission[%s]", id)

	if !bson.IsObjectIdHex(id) {
		log.Error(context, "RemoveFlag", ErrInvalidID, "Completed")
		return nil, ErrInvalidID
	}

	objectID := bson.ObjectIdHex(id)

	f := func(c *mgo.Collection) error {
		u := bson.M{
			"$pull": bson.M{
				"flags": flag,
			},
		}
		log.Dev(context, "RemoveFlag", "MGO : db.%s.update(%s, %s)", c.Name, mongo.Query(objectID), mongo.Query(u))
		return c.UpdateId(objectID, u)
	}

	if err := db.ExecuteMGO(context, Collection, f); err != nil {
		log.Error(context, "RemoveFlag", err, "Completed")
		return nil, err
	}

	submission, err := Retrieve(context, db, id)
	if err != nil {
		log.Error(context, "RemoveFlag", err, "Completed")
		return nil, err
	}

	log.Dev(context, "RemoveFlag", "Completed")
	return submission, nil
}

示例#20
文件: submission.go 项目: coralproject/xenia

// UpdateStatus updates a form submissions status inside the MongoDB database
// collection.
func UpdateStatus(context interface{}, db *db.DB, id, status string) (*Submission, error) {
	log.Dev(context, "UpdateStatus", "Started : Submission[%s]", id)

	if !bson.IsObjectIdHex(id) {
		log.Error(context, "UpdateStatus", ErrInvalidID, "Completed")
		return nil, ErrInvalidID
	}

	objectID := bson.ObjectIdHex(id)

	f := func(c *mgo.Collection) error {
		u := bson.M{
			"$set": bson.M{
				"status":       status,
				"date_updated": time.Now(),
			},
		}
		log.Dev(context, "UpdateStatus", "MGO : db.%s.update(%s, %s)", c.Name, mongo.Query(objectID), mongo.Query(u))
		return c.UpdateId(objectID, u)
	}

	if err := db.ExecuteMGO(context, Collection, f); err != nil {
		log.Error(context, "UpdateStatus", err, "Completed")
		return nil, err
	}

	submission, err := Retrieve(context, db, id)
	if err != nil {
		log.Error(context, "UpdateStatus", err, "Completed")
		return nil, err
	}

	log.Dev(context, "UpdateStatus", "Completed")
	return submission, nil
}

示例#21
文件: submission.go 项目: coralproject/xenia

// Create adds a new Submission based on a given Form into
// the MongoDB database collection.
func Create(context interface{}, db *db.DB, formID string, submission *Submission) error {
	log.Dev(context, "Create", "Started : Form[%s]", formID)

	if !bson.IsObjectIdHex(formID) {
		log.Error(context, "Create", ErrInvalidID, "Completed")
		return ErrInvalidID
	}

	if err := submission.Validate(); err != nil {
		return err
	}

	// FIXME: handle Number field maybe with https://docs.mongodb.com/v3.0/tutorial/create-an-auto-incrementing-field/ to resolve race condition
	count, err := Count(context, db, formID)
	if err != nil {
		log.Error(context, "Create", err, "Completed")
		return err
	}

	submission.Number = count + 1

	f := func(c *mgo.Collection) error {
		log.Dev(context, "Create", "MGO : db.%s.insert(%s)", c.Name, mongo.Query(submission))
		return c.Insert(submission)
	}

	if err := db.ExecuteMGO(context, Collection, f); err != nil {
		log.Error(context, "Create", err, "Completed")
		return err
	}

	log.Dev(context, "Create", "Completed")
	return nil
}

示例#22
文件: groups.go 项目: cedmundo/hablo

// Update patches a group in database
func Update(c *echo.Context) (int, interface{}) {
	digitsID, ok := c.Get("digitsID").(int64)
	if !ok {
		return msg.Forbidden("session required")
	}

	// Bind request body to a group update
	var group models.GroupUpdate
	err := c.Bind(&group)
	if err != nil {
		return msg.BadRequest(err)
	}

	// Get group id and convert from string to objectId
	rawGID := c.Param("gid")
	if !bson.IsObjectIdHex(rawGID) {
		return msg.BadRequest("bad id: not a ObjectId")
	}

	// Update the object, only if its a admin
	groupID := bson.ObjectIdHex(rawGID)
	err = mangos.Update(constants.CGroups, bson.M{
		"$and": []bson.M{
			bson.M{"_id": groupID},
			bson.M{"admins": digitsID},
		},
	}, bson.M{"$set": group})
	if err != nil {
		return msg.InternalError(err)
	}

	return msg.Ok(group)
}

示例#23
文件: submission.go 项目: coralproject/xenia

// RetrieveMany retrieves a list of Submission's from the MongoDB database collection.
func RetrieveMany(context interface{}, db *db.DB, ids []string) ([]Submission, error) {
	log.Dev(context, "RetrieveMany", "Started")

	var objectIDs = make([]bson.ObjectId, len(ids))

	for i, id := range ids {
		if !bson.IsObjectIdHex(id) {
			log.Error(context, "RetrieveMany", ErrInvalidID, "Completed")
			return nil, ErrInvalidID
		}

		objectIDs[i] = bson.ObjectIdHex(id)
	}

	var submissions []Submission
	f := func(c *mgo.Collection) error {
		q := bson.M{
			"_id": bson.M{
				"$in": objectIDs,
			},
		}
		log.Dev(context, "RetrieveMany", "MGO : db.%s.find(%s)", c.Name, mongo.Query(q))
		return c.Find(q).All(&submissions)
	}

	if err := db.ExecuteMGO(context, Collection, f); err != nil {
		log.Error(context, "RetrieveMany", err, "Completed")
		return nil, err
	}

	log.Dev(context, "RetrieveMany", "Started")
	return submissions, nil
}

示例#24
文件: groups.go 项目: cedmundo/hablo

// Retrieve writes the requested group from database
func Retrieve(c *echo.Context) (int, interface{}) {
	digitsID, ok := c.Get("digitsID").(int64)
	if !ok {
		return msg.Forbidden("session required")
	}

	// Get group id and convert it from string to objectid
	rawGID := c.Param("gid")
	if !bson.IsObjectIdHex(rawGID) {
		return msg.BadRequest("bad id: not a ObjectId")
	}

	// find the group
	groupID := bson.ObjectIdHex(rawGID)
	var group models.Group
	err := mangos.FindOne(constants.CGroups, bson.M{"_id": groupID}, &group)
	if err != nil {
		return msg.InternalError(err)
	}

	// check if user is member (is not part of the query because we need to light bson query)
	for _, member := range group.Members {
		if member == digitsID {
			return msg.Ok(group)
		}
	}

	return msg.Forbidden("you must be part of the group")
}

示例#25
文件: submission.go 项目: coralproject/xenia

// Count returns the count of current submissions for a given
// form id in the Form Submissions MongoDB database collection.
func Count(context interface{}, db *db.DB, formID string) (int, error) {
	log.Dev(context, "Count", "Completed : Form[%s]", formID)

	if !bson.IsObjectIdHex(formID) {
		log.Error(context, "Count", ErrInvalidID, "Completed")
		return 0, ErrInvalidID
	}

	formObjectID := bson.ObjectIdHex(formID)

	var count int
	f := func(c *mgo.Collection) error {
		var err error

		q := bson.M{
			"form_id": formObjectID,
		}
		log.Dev(context, "Count", "MGO : db.%s.find(%s).count()", c.Name, mongo.Query(q))
		count, err = c.Find(q).Count()
		return err
	}

	if err := db.ExecuteMGO(context, Collection, f); err != nil {
		log.Error(context, "Count", err, "Completed")
		return 0, err
	}

	log.Dev(context, "Count", "Completed")
	return count, nil
}

示例#26
文件: assingment2.go 项目: abhishekcs04/CMPE273_Assignment-2

func getLoc(w http.ResponseWriter, r *http.Request, p httprouter.Params) {

	uc := NewUserController(getSession())
	id := p.ByName("id")

	if !bson.IsObjectIdHex(id) {
		w.WriteHeader(404)
		return
	}

	oid := bson.ObjectIdHex(id)

	v := Reply{}

	if err := uc.session.DB("cmpe273").C("users").FindId(oid).One(&v); err != nil {
		w.WriteHeader(404)
		return
	}

	uj, _ := json.Marshal(v)

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	fmt.Fprintf(w, "%s", uj)

}

示例#27
文件: user.go 项目: SpazCode/go-deploy

// GetUser retrieves an individual user resource
func (uc UserController) GetUser(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
	// Get the user's id from the parameters
	id := p.ByName("id")

	// Check to ensure that this is a BSON object
	if !bson.IsObjectIdHex(id) {
		w.WriteHeader(404)
		return
	}

	// Grab the object's id
	oid := bson.ObjectIdHex(id)

	// Stub an example user
	u := models.User{}

	// Fetch the user data
	if err := uc.session.DB("go-deploy").C("users").FindId(oid).One(&u); err != nil {
		w.WriteHeader(404)
		return
	}

	// Marshal provided interface into JSON structure
	uj, _ := json.Marshal(u)

	// Write content-type, statuscode, payload
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	fmt.Fprintf(w, "%s", uj)
}

示例#28
文件: UserController.go 项目: fishkel-truelogic/hello-world

func GetUserById(w http.ResponseWriter, r *http.Request) {
	fmt.Println("------------------ GetUserById ------------------")

	vars := mux.Vars(r)
	if bson.IsObjectIdHex(vars["id"]) {

		id := bson.ObjectIdHex(vars["id"])

		result := model.User{}

		result = data.FindOneBy(bson.M{"_id": id})

		j, err := json.Marshal(result)

		if err != nil {
			log.Fatal(err)
		}

		fmt.Fprintf(w, string(j))
	} else {
		w.WriteHeader(http.StatusBadRequest)
		return
	}

}

示例#29
文件: user.go 项目: greatontime/golangtut

// GetUser retrieves an individual user resource
func (uc UserController) GetUser(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
	// Grab id
	id := p.ByName("id")

	// Verify id is ObjectId, otherwise bail
	if !bson.IsObjectIdHex(id) {
		w.WriteHeader(404)
		return
	}

	// Grab id
	oid := bson.ObjectIdHex(id)

	// Stub user
	u := models.User{}

	// Fetch user
	if err := uc.session.DB("go_rest_tutorial").C("users").FindId(oid).One(&u); err != nil {
		w.WriteHeader(404)
		return
	}

	// Marshal provided interface into JSON structure
	uj, _ := json.Marshal(u)

	// Write content-type, statuscode, payload
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(200)
	fmt.Fprintf(w, "%s", uj)
}

示例#30
文件: context.go 项目: jmcarbo/smtpd-1

func NewContext(req *http.Request) (*Context, error) {
	vars := mux.Vars(req)
	sess, err := sessionStore.Get(req, "gsmtpd")
	ctx := &Context{
		Vars:      vars,
		Session:   sess,
		DataStore: DataStore,
		ClientIp:  parseRemoteAddr(req),
		IsJson:    headerMatch(req, "Accept", "application/json"),
		Ds:        DataStore.Storage.(*data.MongoDB),
	}

	if err != nil {
		return ctx, err
	}

	//try to fill in the user from the session
	if user, ok := sess.Values["user"].(string); ok {
		if bson.IsObjectIdHex(user) {
			uid := bson.ObjectIdHex(user)
			err := ctx.Ds.Users.Find(bson.M{"_id": uid}).One(&ctx.User)

			if err != nil {
				ctx.User = nil
				return ctx, nil
			}
		} else {
			ctx.User = nil
		}
	}

	return ctx, err
}

展开阅读全文