コード例 #1
0
ファイル: dao.go プロジェクト: yaosxi/mgox
func (q *Query) Count(collectionName interface{}) (int, error) {
	if q.dao.Err != nil {
		return -1, q.dao.Err
	}
	if q.dao.db == nil {
		q.dao.Connect()
		if q.dao.Err != nil {
			return -1, q.dao.Err
		}
		defer q.dao.Close()
	}

	log4go.Debug("count")

	c := q.dao.db.C(getCollectionName(collectionName))
	var mgoQuery *mgo.Query
	if q.dao.isID(q.queries...) {
		log4go.Debug("query id: %s", q.queries[0])
		if str, ok := q.queries[0].(string); ok {
			mgoQuery = c.FindId(bson.ObjectIdHex(str))
		} else {
			mgoQuery = c.FindId(q.queries[0])
		}
	} else {
		selector := q.dao.getM(q.queries...)
		log4go.Debug("queries: %s", selector)
		mgoQuery = c.Find(selector)
	}
	var n int
	n, q.dao.Err = mgoQuery.Count()
	log4go.Debug(n)
	return n, q.dao.Err
}
コード例 #2
0
ファイル: dao_test.go プロジェクト: yaosxi/mgox
func TestGet(t *testing.T) {

	var user User
	err := mgox.Dao().Get().Result(&user)
	if handleError(t, err) {
		return
	}
	log4go.Debug(user)

	id := user.Id
	user = User{}
	err = mgox.Dao().Get(id).Result(&user)
	if handleError(t, err) {
		return
	}
	log4go.Debug(user)

	user = User{}
	err = mgox.Dao().Get("name", "yaosxi2").Result(&user)
	if handleError(t, err) {
		return
	}
	log4go.Debug(user)

	var users []User
	err = mgox.Dao().Find().Result(&users)
	if handleError(t, err) {
		return
	}
}
コード例 #3
0
ファイル: dao_test.go プロジェクト: yaosxi/mgox
func TestFind(t *testing.T) {
	var users []User
	err := mgox.Dao().Find().Result(&users)
	if handleError(t, err) {
		return
	}
	log4go.Debug(users)

	p := mgox.Page{Count: 1}
	err = mgox.Dao().Find().Page(&p).Sort("age", "-name").Result(&users)
	if handleError(t, err) {
		return
	}
	log4go.Debug(users)

	var user User
	err = mgox.Dao().Find(users[0].Id).Result(&user)
	if handleError(t, err) {
		return
	}
	log4go.Debug(user)

	user = User{}
	err = mgox.Dao().Find("name", "yaosxi2").Result(&user)
	if handleError(t, err) {
		return
	}
	log4go.Debug(user)
}
コード例 #4
0
ファイル: dao_test.go プロジェクト: yaosxi/mgox
func TestLast(t *testing.T) {
	var user User
	err := mgox.Dao().Find("name", "yaosxi").IgnoreNFE().Last(&user)
	if handleError(t, err) {
		return
	}
	log4go.Debug(user.Name)

	user = User{}
	err = mgox.Dao().Find("name", "name").IgnoreNFE().Last(&user)
	if handleError(t, err) {
		return
	}
	log4go.Debug(user.Name)
}
コード例 #5
0
ファイル: dao.go プロジェクト: yaosxi/mgox
func (d *dao) Close() {
	if d.db != nil {
		d.db.Session.Close()
		d.db = nil
		log4go.Debug("Closed DB connection succssfully")
	}
}
コード例 #6
0
ファイル: config.go プロジェクト: yaosxi/mgox
func init() {
	db := new(PropertyReader)
	db.init("conf/mgox.properties")
	DBConfig.Host = db.m["host"]
	DBConfig.Database = db.m["database"]
	DBConfig.Username = db.m["username"]
	DBConfig.Password = db.m["password"]
	log4go.Debug(fmt.Sprintf("host=%s,database=%s,username=%s", DBConfig.Host, DBConfig.Database, DBConfig.Username))
}
コード例 #7
0
ファイル: dao_test.go プロジェクト: yaosxi/mgox
func TestCount(t *testing.T) {
	n, err := mgox.Dao().Find().Count(UserCollectionName)
	if handleError(t, err) {
		return
	}
	if n != 4 {
		log4go.Debug(n)
		t.Fail()
	}
}
コード例 #8
0
ファイル: dao_test.go プロジェクト: yaosxi/mgox
func TestExist(t *testing.T) {

	b, err := mgox.Dao().Find().Exist("user")
	if handleError(t, err) {
		return
	}
	if !b {
		log4go.Debug(b)
		t.Fail()
		return
	}

	b, err = mgox.Dao().Find("56597ab9f918ad09b4000001").Exist("user")
	if handleError(t, err) {
		return
	}
	if !b {
		log4go.Debug(b)
		t.Fail()
		return
	}

	b, err = mgox.Dao().Find("name", "yaosxi").Exist("user")
	if handleError(t, err) {
		return
	}
	if !b {
		log4go.Debug(b)
		t.Fail()
		return
	}

	b, err = mgox.Dao().Find(bson.M{"name": "yaosxi"}).Exist("user")
	if handleError(t, err) {
		return
	}
	if !b {
		log4go.Debug(b)
		t.Fail()
		return
	}
}
コード例 #9
0
ファイル: dao_test.go プロジェクト: yaosxi/mgox
func TestConnection(t *testing.T) {
	dao := mgox.Dao().Connect()
	defer dao.Close()
	var user = new(User)
	dao.Find().IgnoreNFE().First(user)
	log4go.Debug(user.Id)
	dao.Find().IgnoreNFE().First(user)
	err := dao.Find().IgnoreNFE().First(user)
	if handleError(t, err) {
		return
	}
}
コード例 #10
0
ファイル: dao.go プロジェクト: yaosxi/mgox
func (d *dao) Remove(collectionName interface{}, selector interface{}) error {
	if d.Err != nil {
		return d.Err
	}

	if d.db == nil {
		d.Connect()
		if d.Err != nil {
			return d.Err
		}
		defer d.Close()
	}

	log4go.Debug("remove")

	c := d.db.C(getCollectionName(collectionName))

	var id bson.ObjectId
	if strId, ok := selector.(string); ok {
		if strId == "" {
			d.Err = errors.New("id can't be empty")
			return d.Err
		}
		id = bson.ObjectIdHex(strId)
	} else if oId, ok := selector.(bson.ObjectId); ok {
		if oId == "" {
			d.Err = errors.New("id can't be empty")
			return d.Err
		}
		id = oId
	} else if _, ok := selector.(bson.M); ok {

	} else if _, ok := selector.(map[string]interface{}); ok {

	} else {
		d.Err = errors.New("unrecognized selector for remove")
		return d.Err
	}

	if id != "" {
		d.Err = c.RemoveId(id)
	} else {
		_, d.Err = c.RemoveAll(selector)
	}

	return d.Err
}
コード例 #11
0
ファイル: dao.go プロジェクト: yaosxi/mgox
func (q *Query) Last(result interface{}) error {
	if q.dao.Err != nil {
		return q.dao.Err
	}
	if q.dao.db == nil {
		q.dao.Connect()
		if q.dao.Err != nil {
			return q.dao.Err
		}
		defer q.dao.Close()
	}
	count, _ := q.Count(result)
	if q.dao.Err != nil {
		return q.dao.Err
	}
	if count == 0 {
		count = 1
	}
	log4go.Debug("last")
	q.page = &Page{Cursor: count - 1, Count: 1}
	return q.Result(result)
}
コード例 #12
0
ファイル: dao.go プロジェクト: yaosxi/mgox
func (q *Query) First(result interface{}) error {
	log4go.Debug("first")
	q.page = &Page{Count: 1}
	return q.Result(result)
}
コード例 #13
0
ファイル: dao.go プロジェクト: yaosxi/mgox
func (d *dao) Insert(docs ...interface{}) error {

	if d.Err != nil {
		return d.Err
	}

	for i, _ := range docs {

		if docs[i] == nil {
			d.Err = errors.New("cannot insert empty document")
			return d.Err
		}

		mType := reflect.TypeOf(docs[i])
		mValue := reflect.ValueOf(docs[i])
		mType, mValue = getElem(mType, mValue)

		if mType.Kind() == reflect.Struct && mValue.IsValid() {
			field := mValue.FieldByName("Id")
			if field.IsValid() && field.String() == "" && field.CanSet() {
				field.Set(reflect.ValueOf(bson.NewObjectId()))
			}
			now := reflect.ValueOf(time.Now())
			field = mValue.FieldByName("FirstCreated")
			if field.CanSet() {
				field.Set(now)
			}
			field = mValue.FieldByName("LastModified")
			if field.CanSet() {
				field.Set(now)
			}

			// This will force mongo db store localcreated field in a local time , not UTC time.
			field = mValue.FieldByName("LocalCreated")
			if field.CanSet() {
				_, offset := time.Now().Local().Zone()
				//				zoneName,offset:=time.Now().Local().Zone()
				//				println("zone name is:%s,offset is:%d",zoneName,offset)
				newtime := time.Now().Add(time.Duration(offset * 1000000000))
				//				fmt.Println("newtime:",newtime)
				nowlocal := reflect.ValueOf(newtime)
				field.Set(nowlocal)
			}

			if d.uid != nil {
				field = mValue.FieldByName("FirstCreator")
				if field.CanSet() {
					field.Set(reflect.ValueOf(d.uid))
				}
				field = mValue.FieldByName("LastModifier")
				if field.CanSet() {
					field.Set(reflect.ValueOf(d.uid))
				}
			}

		} else if mType.Kind() == reflect.Map {
			m, ok := docs[i].(bson.M)
			if !ok {
				m, _ = docs[i].(map[string]interface{})
			}
			if len(m) > 0 {
				if _, ok := m["_id"]; !ok {
					m["_id"] = bson.NewObjectId()
				}
				now := time.Now()
				m["firstcreated"] = now
				m["lastmodified"] = now
				if d.uid != nil {
					m["firstcreator"] = d.uid
					m["lastmodifier"] = d.uid
				}
			}
		}
	}

	if d.db == nil {
		d.Connect()
		if d.Err != nil {
			return d.Err
		}
		defer d.Close()
	}

	log4go.Debug("insert")

	d.Err = d.db.C(getCollectionName(docs[0])).Insert(docs...)
	return d.Err
}
コード例 #14
0
ファイル: dao.go プロジェクト: yaosxi/mgox
func (d *dao) update(operator string, collectionName interface{}, selector interface{}, updates ...interface{}) error {

	if d.Err != nil {
		return d.Err
	}

	if len(updates) == 0 {
		d.Err = errors.New("updates can't be empty")
		return d.Err
	}

	isStruct := false
	mType := reflect.TypeOf(updates[0])
	mValue := reflect.ValueOf(updates[0])
	mType, mValue = getElem(mType, mValue)
	if mType.Kind() == reflect.Struct && mValue.IsValid() {

		isStruct = true

		field := mValue.FieldByName("LastModified")
		if field.CanSet() {
			field.Set(reflect.ValueOf(time.Now()))
		}

		if d.uid != nil {
			field := mValue.FieldByName("LastModifier")
			if field.CanSet() {
				field.Set(reflect.ValueOf(d.uid))
			}
		}
	}

	var update bson.M

	if !isStruct {

		update = d.getM(updates...)

		if operator == "$inc" || operator == "$push" {
			m := bson.M{"lastmodified": time.Now()}
			if d.uid != nil {
				m["lastmodifier"] = d.uid
			}
			update = bson.M{"$set": m, operator: update}
		} else {
			if operator == "$set" || operator == "$update" {
				update["lastmodified"] = time.Now()
				if d.uid != nil {
					update["lastmodifier"] = d.uid
				}
			}

			if operator != "update" {
				update = bson.M{operator: update}
			}
		}
	}

	if d.db == nil {
		d.Connect()
		if d.Err != nil {
			return d.Err
		}
		defer d.Close()
	}

	_collectionName := getCollectionName(collectionName)
	c := d.db.C(_collectionName)

	var id bson.ObjectId
	if strId, ok := selector.(string); ok {
		if strId == "" {
			d.Err = errors.New("id can't be empty")
			return d.Err
		}
		id = bson.ObjectIdHex(strId)
	} else if oId, ok := selector.(bson.ObjectId); ok {
		if oId == "" {
			d.Err = errors.New("id can't be empty")
			return d.Err
		}
		id = oId
	} else if _, ok := selector.(bson.M); ok {

	} else if _, ok := selector.(map[string]interface{}); ok {

	} else {
		d.Err = errors.New("unrecognized selector for update")
		return d.Err
	}

	if isStruct {
		if id != "" {
			log4go.Debug(fmt.Sprintf("[%s]collection=%s,id=%s,struct=%s", operator, _collectionName, id, updates[0]))
			d.Err = c.UpdateId(id, updates[0])
		} else {
			log4go.Debug(fmt.Sprintf("[%s]collection=%s,selector=%s,struct=%s", operator, _collectionName, selector, updates[0]))
			_, d.Err = c.UpdateAll(selector, updates[0])
		}
	} else {
		if id != "" {
			log4go.Debug(fmt.Sprintf("id=%s", id))
			log4go.Debug(fmt.Sprintf("[%s]collection=%s,id=%s,update=%s", operator, _collectionName, id, update))
			d.Err = c.UpdateId(id, update)
		} else {
			log4go.Debug(fmt.Sprintf("[%s]collection=%s,selector=%s,struct=%s", operator, _collectionName, selector, update))
			_, d.Err = c.UpdateAll(selector, update)
		}
	}

	return d.Err
}