func SaveInfo(service *services.Service, information infoModel.Information) (*infoModel.Information, error) {
	log.Startedf(service.UserID, "SaveInfo", "UserID[%s]", information.CreatedBy)
	f := func(collection *mgo.Collection) error {

		if len(information.ID) > 0 {
			log.Trace(service.UserID, "SaveInfo", "MGO : db.information.update(%s)", mongo.ToString(information))
			return collection.Update(bson.M{"_id": information.ID}, &information)
		} else {
			log.Trace(service.UserID, "SaveInfo", "MGO : db.information.insert(%s)", mongo.ToString(information))
			return collection.Insert(&information)
		}

	}
	if err := service.DBAction(Config.Database, "information", f); err != nil {
		if err != mgo.ErrNotFound {
			log.CompletedError(err, service.UserID, "SaveInfo")
			return nil, err
		}
	}
	log.Completedf(service.UserID, "SaveInfo", "information%+v", &information)
	return &information, nil
}
func SaveMsg(service *services.Service, message msgModel.Message) (*msgModel.Message, error) {
	log.Startedf(service.UserID, "SaveMsg", "UserID[%s]", message.CreatedBy)
	f := func(collection *mgo.Collection) error {

		if len(message.ID) > 0 {
			log.Trace(service.UserID, "SaveMsg", "MGO : db.message.update(%s)", mongo.ToString(message))
			return collection.Update(bson.M{"_id": message.ID}, &message)
		} else {
			log.Trace(service.UserID, "SaveMsg", "MGO : db.message.insert(%s)", mongo.ToString(message))
			return collection.Insert(&message)
		}

	}
	if err := service.DBAction(Config.Database, "message", f); err != nil {
		if err != mgo.ErrNotFound {
			log.CompletedError(err, service.UserID, "SaveMsg")
			return nil, err
		}
	}
	log.Completedf(service.UserID, "SaveMsg", "message%+v", &message)
	return &message, nil
}
func UserLogup(service *services.Service, userInfo userModel.UserInfo) (*userModel.UserInfo, error) {
	log.Startedf(service.UserID, "UserLogup", "user[%s]", userInfo.UserName)
	f := func(collection *mgo.Collection) error {
		log.Trace(service.UserID, "UserLogup", "MGO : db.user_infos.insert(%s)", mongo.ToString(userInfo))
		return collection.Insert(&userInfo)
	}
	if err := service.DBAction(Config.Database, "user_infos", f); err != nil {
		if err != mgo.ErrNotFound {
			log.CompletedError(err, service.UserID, "UserLogup")
			return nil, err
		}
	}
	log.Completedf(service.UserID, "UserLogup", "userInfo%+v", &userInfo)
	return &userInfo, nil
}
func FindUserById(service *services.Service, userID string) (*userModel.UserInfo, error) {
	log.Startedf(service.UserID, "FindUser", "userID[%s]", userID)
	var userInfo userModel.UserInfo
	f := func(collection *mgo.Collection) error {
		queryMap := bson.M{"_id": userID}

		log.Trace(service.UserID, "FindUser", "MGO : db.user_infos.find(%s).limit(1)", mongo.ToString(queryMap))
		return collection.Find(queryMap).One(&userInfo)
	}

	if err := service.DBAction(Config.Database, "user_infos", f); err != nil {
		if err != mgo.ErrNotFound {
			log.CompletedError(err, service.UserID, "FindUser")
			return nil, err
		}
	}

	log.Completedf(service.UserID, "FindUser", "userInfo%+v", &userInfo)
	return &userInfo, nil
}
func FindMsg(service *services.Service, userID string) (*msgModel.Message, error) {
	log.Startedf(service.UserID, "FindMsg", "userID[%s]", userID)

	var message msgModel.Message
	f := func(collection *mgo.Collection) error {
		queryMap := bson.M{"user_id": userID}

		log.Trace(service.UserID, "FindMsg", "MGO : db.message.find(%s).limit(1)", mongo.ToString(queryMap))
		return collection.Find(queryMap).One(&message)
	}

	if err := service.DBAction(Config.Database, "message", f); err != nil {
		if err != mgo.ErrNotFound {
			log.CompletedError(err, service.UserID, "FindMsg")
			return nil, err
		}
	}

	log.Completedf(service.UserID, "FindMsg", "message%+v", &message)
	return &message, nil
}
func FindInfo(service *services.Service, userID string) (*infoModel.Information, error) {
	log.Startedf(service.UserID, "FindInfo", "userID[%s]", userID)

	var information infoModel.Information
	f := func(collection *mgo.Collection) error {
		queryMap := bson.M{"user_id": userID}

		log.Trace(service.UserID, "FindInfo", "MGO : db.information.find(%s).limit(1)", mongo.ToString(queryMap))
		return collection.Find(queryMap).One(&information)
	}

	if err := service.DBAction(Config.Database, "information", f); err != nil {
		if err != mgo.ErrNotFound {
			log.CompletedError(err, service.UserID, "FindInfo")
			return nil, err
		}
	}

	log.Completedf(service.UserID, "FindInfo", "information%+v", &information)
	return &information, nil
}
func UserLogin(service *services.Service, firstPara string, userPwd string) (*userModel.UserInfo, error) {
	log.Startedf(service.UserID, "UserLogin", "user[%s]", firstPara)
	var userInfo userModel.UserInfo
	f := func(collection *mgo.Collection) error {
		queryMap := bson.M{
			"$or": []bson.M{
				bson.M{"user_name": firstPara},
				bson.M{"user_email": firstPara},
				bson.M{"user_mobile": firstPara},
			},
			"user_pwd": userPwd,
		}
		log.Trace(service.UserID, "UserLogin", "MGO : db.user_infos.find(%s).limit(1)", mongo.ToString(queryMap))
		return collection.Find(queryMap).One(&userInfo)
	}
	if err := service.DBAction(Config.Database, "user_infos", f); err != nil {
		if err != mgo.ErrNotFound {
			log.CompletedError(err, service.UserID, "UserLogin")
			return nil, err
		}
	}
	log.Completedf(service.UserID, "UserLogin", "userInfo%+v", &userInfo)
	return &userInfo, nil
}