func main() {
tracelog.Start(tracelog.LevelTrace)
// Init mongo
tracelog.Started("main", "Initializing Mongo")
err := mongo.Startup(helper.MainGoRoutine)
if err != nil {
tracelog.CompletedError(err, helper.MainGoRoutine, "initApp")
os.Exit(1)
}
// Load message strings
localize.Init("en-US")
SessionConfig, err := session.GetSessionConfig("session")
tracelog.Trace("main", "SessionConfig", "Session : On[%v]", SessionConfig.On)
tracelog.Trace("main", "SessionConfig", "Session : On[%v]", SessionConfig.Provider)
tracelog.Trace("main", "SessionConfig", "Session : On[%v]", SessionConfig.SavePath)
beego.SessionOn = SessionConfig.On
beego.SessionProvider = SessionConfig.Provider
beego.SessionSavePath = SessionConfig.SavePath
beego.Run()
tracelog.Completed(helper.MainGoRoutine, "Website Shutdown")
tracelog.Stop()
}
func DealersAroundZipCode(zipCode string, radius int32, make string, newCars bool) (EdmundsDealerResponse, error) {
queryStr, err := DealerServiceQueryString(zipCode, radius, make, newCars)
if err != nil {
return EdmundsDealerResponse{}, err
}
tracelog.Trace("Query String", "DealersAroundZipCode", queryStr)
resp, err := http.Get(queryStr)
if err != nil {
return EdmundsDealerResponse{}, err
}
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return EdmundsDealerResponse{}, err
}
resp.Body.Close()
tracelog.Trace("Response Returned", "DealersAroundZipCode", "%s", data)
response := &EdmundsDealerResponse{}
err = json.Unmarshal(data, response)
if err != nil {
return EdmundsDealerResponse{}, err
}
return *response, err
}
func HomeHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
vars := mux.Vars(r)
lat, latErr := strconv.ParseFloat(vars["lat"], 32)
if latErr != nil {
ReturnErrorToClient(w, latErr, "Invalid latitude value. Expecting a floating point number")
return
}
lng, lngErr := strconv.ParseFloat(vars["lng"], 32)
if lngErr != nil {
ReturnErrorToClient(w, lngErr, "Invalid longitude value. Expecting a floating point number")
return
}
tracelog.Trace("Lat Value", "main", "Lat is %f", lat)
tracelog.Trace("Lng Value", "main", "Lng is %f", lng)
postalCode, postaCodeErr := ReverseGeocodeToPostalCode(lat, lng)
if postaCodeErr != nil {
ReturnErrorToClient(w, postaCodeErr, "Error determining zip code from given coordinates")
return
}
tracelog.Trace("Postal Code Value", "main", "Postal Code is %s", postalCode)
var response = GeocodeResponse{postalCode}
w.WriteHeader(http.StatusOK)
var err error
if err = json.NewEncoder(w).Encode(response); err != nil {
tracelog.Error(err, "An error occurred while encoding json response", "NearbyHandler")
panic(err)
}
}
func HomeHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
vars := mux.Vars(r)
brand := vars["brand"]
postalCode := vars["postalCode"]
tracelog.Trace("Brand Value", "main", "Brand is %s", brand)
tracelog.Trace("Postal Code", "main", "PostalCode is %s", postalCode)
// now call the Edmunds API
dealers, dealerErr := DealersAroundZipCode(postalCode, 100, brand, true)
if dealerErr != nil {
ReturnErrorToClient(w, dealerErr, "Error calling dealer service with zip code "+postalCode)
tracelog.Error(dealerErr, "DealersAroundZipCode failed", "HomeHandler")
return
}
w.WriteHeader(http.StatusOK)
var err error
if err = json.NewEncoder(w).Encode(dealers); err != nil {
tracelog.Error(err, "JSON encoding failed", "HomeHandler")
panic(err)
}
}
func HomeHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
vars := mux.Vars(r)
lat := vars["lat"]
lng := vars["lng"]
distance := vars["distance"]
tracelog.Trace("Latitude", "main", "Lat is %s", lat)
tracelog.Trace("Longitude", "main", "Lng is %s", lng)
tracelog.Trace("Distance", "main", "Distance is %s", distance)
// call the GasFeed API
stations, stationErr := NearbyGasStations(lat, lng, distance)
if stationErr != nil {
ReturnErrorToClient(w, stationErr, "Error calling gas station pricing service with lat "+lat+" lng "+lng+" and distance "+distance)
tracelog.Error(stationErr, "NearbyGasStations failed", "HomeHandler")
return
}
w.WriteHeader(http.StatusOK)
var err error
if err = json.NewEncoder(w).Encode(stations); err != nil {
tracelog.Error(err, "JSON encoding failed", "HomeHandler")
panic(err)
}
}
func NearbyGasStations(lat string, lng string, distance string) (GasPriceResponse, error) {
queryStr, err := NearbyGasStationQueryString(lat, lng, distance)
if err != nil {
return GasPriceResponse{}, err
}
tracelog.Trace("Query String", "NearbyGasStations", queryStr)
resp, err := http.Get(queryStr)
if err != nil {
return GasPriceResponse{}, err
}
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return GasPriceResponse{}, err
}
resp.Body.Close()
response := &GasPriceResponse{}
err = json.Unmarshal(data, response)
if err != nil {
return GasPriceResponse{}, err
}
return *response, err
}
// TestInvalidStation is a sample to run an endpoint test that returns
// an empty result set
func TestInvalidStation(t *testing.T) {
r, _ := http.NewRequest("GET", "/buoy/station/000000", nil)
w := httptest.NewRecorder()
beego.BeeApp.Handlers.ServeHTTP(w, r)
log.Trace("testing", "TestStation", "Code[%d]\n%s", w.Code, w.Body.String())
var response struct {
StationID string `json:"station_id"`
Name string `json:"name"`
LocDesc string `json:"location_desc"`
Condition struct {
Type string `json:"type"`
Coordinates []float64 `json:"coordinates"`
} `json:"condition"`
Location struct {
WindSpeed float64 `json:"wind_speed_milehour"`
WindDirection int `json:"wind_direction_degnorth"`
WindGust float64 `json:"gust_wind_speed_milehour"`
} `json:"location"`
}
json.Unmarshal(w.Body.Bytes(), &response)
Convey("Subject: Test Station Endpoint\n", t, func() {
Convey("Status Code Should Be 200", func() {
So(w.Code, ShouldEqual, 200)
})
Convey("The Result Should Not Be Empty", func() {
So(w.Body.Len(), ShouldBeGreaterThan, 0)
})
Convey("The Result Should Be Empty For Station 00000", func() {
So(response.StationID, ShouldBeBlank)
})
})
}
// FindStation retrieves the specified station
func FindStation(service *services.Service, stationId string) (buoyStation *buoyModels.BuoyStation, err error) {
defer helper.CatchPanic(&err, service.UserId, "FindStation")
tracelog.Started(service.UserId, "FindStation")
queryMap := bson.M{"station_id": stationId}
buoyStation = &buoyModels.BuoyStation{}
err = service.DBAction(Config.Database, "buoy_stations",
func(collection *mgo.Collection) error {
tracelog.Trace(service.UserId, "FindStation", "Query : %s", mongo.ToString(queryMap))
return collection.Find(queryMap).One(buoyStation)
})
if err != nil {
if strings.Contains(err.Error(), "not found") == false {
tracelog.CompletedError(err, service.UserId, "FindStation")
return buoyStation, err
}
err = nil
}
tracelog.Completed(service.UserId, "FindStation")
return buoyStation, err
}
func FindUserByName(service *services.Service, userName string) (*userModel.UserInfo, error) {
log.Startedf(service.UserID, "FindUserByName", "userName[%s]", userName)
var userInfo userModel.UserInfo
f := func(collection *mgo.Collection) error {
queryMap := bson.M{
"$or": []bson.M{
bson.M{"user_name": userName},
bson.M{"user_email": userName},
bson.M{"user_mobile": userName},
},
}
log.Trace(service.UserID, "FindUserByName", "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, "FindUserByName")
return nil, err
}
}
log.Completedf(service.UserID, "FindUserByName", "userInfo%+v", &userInfo)
return &userInfo, nil
}
func (controller *UserController) UserLogin() {
var params struct {
UserName string `form:"user_name" valid:"Required; MinSize(4)" error:"invalid_user_name"`
UserPwd string `form:"user_pwd" valid:"Required; MinSize(6)" error:"invalid_user_pwd"`
}
if controller.ParseAndValidate(¶ms) == false {
return
}
userInfo, err := userService.UserLogin(&controller.Service, params.UserName, params.UserPwd)
if err != nil {
log.CompletedErrorf(err, controller.UserID, "UserController.UserLogin", "UserName[%s]", params.UserName)
controller.ServeError(err)
return
}
// set session
if len(userInfo.ID) > 0 {
log.Trace("UserController", "UserLogin", "userID[%s]", userInfo.ID.Hex())
controller.SetSession("UserID", userInfo.ID.Hex())
}
controller.Data["json"] = userInfo
controller.ServeJson()
}
func ReverseGeocodeToPostalCode(lat float64, lng float64) (string, error) {
queryStr, err := googleReverseGeocodeQueryStr(lat, lng)
if err != nil {
return "", err
}
resp, err := http.Get(queryStr)
if err != nil {
return "", err
}
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return "", err
}
resp.Body.Close()
response := &GoogleReverseGeocodeResponse{}
err = json.Unmarshal(data, response)
if err != nil {
return "", err
}
tracelog.Trace("response", "from google", string(data))
if len(response.Results) == 0 {
tracelog.Trace("Response from Google", "length of results", "is zero")
return "", googleZeroResultsError
}
for _, result := range response.Results {
for _, addressComp := range result.AddressComponents {
for _, aType := range addressComp.Types {
tracelog.Trace("loop", "aType", aType)
if aType == "postal_code" {
tracelog.Trace("loop", "shortname", addressComp.ShortName)
return addressComp.ShortName, nil
}
}
}
}
tracelog.Trace("Response from Google", "address components", "didnt' find postal code")
return "", googleZeroResultsError
}
// Startup brings the manager to a running state.
func Startup(sessionID string) error {
// If the system has already been started ignore the call.
if singleton.sessions != nil {
return nil
}
log.Started(sessionID, "Startup")
// Pull in the configuration.
var config mongoConfiguration
if err := envconfig.Process("mgo", &config); err != nil {
log.CompletedError(err, sessionID, "Startup")
return err
}
// Create the Mongo Manager.
singleton = mongoManager{
sessions: make(map[string]mongoSession),
}
// Log the mongodb connection straps.
log.Trace(sessionID, "Startup", "MongoDB : Hosts[%s]", config.Hosts)
log.Trace(sessionID, "Startup", "MongoDB : Database[%s]", config.Database)
log.Trace(sessionID, "Startup", "MongoDB : Username[%s]", config.UserName)
hosts := strings.Split(config.Hosts, ",")
// Create the strong session.
if err := CreateSession(sessionID, "strong", MasterSession, hosts, config.Database, config.UserName, config.Password); err != nil {
log.CompletedError(err, sessionID, "Startup")
return err
}
// Create the monotonic session.
if err := CreateSession(sessionID, "monotonic", MonotonicSession, hosts, config.Database, config.UserName, config.Password); err != nil {
log.CompletedError(err, sessionID, "Startup")
return err
}
log.Completed(sessionID, "Startup")
return 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 SaveSettings(service *services.Service, settings settingsModel.WinSettings) (*settingsModel.WinSettings, error) {
log.Startedf(service.UserID, "SaveSettings", "UserID[%s]", settings.UserID)
f := func(collection *mgo.Collection) error {
if len(settings.ID) > 0 {
log.Trace(service.UserID, "SaveSettings", "MGO : db.win_settings.update(%s)", mongo.ToString(settings))
return collection.Update(bson.M{"_id": settings.ID}, &settings)
} else {
log.Trace(service.UserID, "SaveSettings", "MGO : db.win_settings.insert(%s)", mongo.ToString(settings))
return collection.Insert(&settings)
}
}
if err := service.DBAction(Config.Database, "win_settings", f); err != nil {
if err != mgo.ErrNotFound {
log.CompletedError(err, service.UserID, "SaveSettings")
return nil, err
}
}
log.Completedf(service.UserID, "SaveSettings", "settings%+v", &settings)
return &settings, nil
}
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
}
// Handles a transaction
func HandleTransaction(b []byte) {
tracelog.Trace(TAG, "HandleTransaction", "Converting JSON to Transaction...")
t := TransactionFromJSON(b)
tracelog.Info(TAG, "HandleTransaction", t.String())
msg := messages.TransactionMessage{Hash: t.Hash}
jsonData, err := json.Marshal(msg)
if err != nil {
tracelog.Error(err, "Error trying to marshal", "HandleTransaction")
}
publish(string(jsonData))
}
// Startup brings the manager to a running state
func Startup(sessionId string) (err error) {
defer helper.CatchPanic(&err, sessionId, "Startup")
// If the system has already been started ignore the call
if singleton != nil {
return err
}
tracelog.Started(sessionId, "Startup")
// Pull in the configuration
config := mongoConfiguration{}
err = envconfig.Process("mgo", &config)
if err != nil {
tracelog.CompletedError(err, sessionId, "Startup")
return err
}
// Create the Mongo Manager
singleton = &mongoManager{
sessions: map[string]*mongoSession{},
}
// Log the mongodb connection straps
tracelog.Trace(sessionId, "Startup", "MongoDB : Hosts[%s]", config.Hosts)
tracelog.Trace(sessionId, "Startup", "MongoDB : Database[%s]", config.Database)
tracelog.Trace(sessionId, "Startup", "MongoDB : Username[%s]", config.UserName)
hosts := strings.Split(config.Hosts, ",")
// Create the strong and monotonic sessions
err = CreateSession(sessionId, "strong", MASTER_SESSION, hosts, config.Database, config.UserName, config.Password)
err = CreateSession(sessionId, "monotonic", MONOTONIC_SESSION, hosts, config.Database, config.UserName, config.Password)
tracelog.Completed(sessionId, "Startup")
return err
}
// Prepare is called before controllers are called.
func Prepare() *services.Service {
var service services.Service
// TODO: Add Test User To Environment
service.UserID = "testing"
err := service.Prepare()
if err != nil {
log.Error(err, service.UserID, "Prepare")
return nil
}
log.Trace(service.UserID, "Before", "UserID[%s]", service.UserID)
return &service
}
func NearbyHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
vars := mux.Vars(r)
var placeType = vars["type"]
// TODO: may want to validate type
lat, latErr := strconv.ParseFloat(vars["lat"], 32)
if latErr != nil {
ReturnErrorToClient(w, latErr, "Invalid latitude value. Expecting a floating point number")
return
}
lng, lngErr := strconv.ParseFloat(vars["lng"], 32)
if lngErr != nil {
ReturnErrorToClient(w, lngErr, "Invalid longitude value. Expecting a floating point number")
return
}
tracelog.Trace("Type Value", "main", "Type is %s", placeType)
tracelog.Trace("Lat Value", "main", "Lat is %f", lat)
tracelog.Trace("Lng Value", "main", "Lng is %f", lng)
response, nearbyErr := NearbySearch(placeType, lat, lng)
if nearbyErr != nil {
ReturnErrorToClient(w, nearbyErr, "Nearby Search returned an error")
return
}
w.WriteHeader(http.StatusOK)
var err error
if err = json.NewEncoder(w).Encode(response); err != nil {
tracelog.Error(err, "An error occurred while encoding json response", "NearbyHandler")
panic(err)
}
}
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
}
// Prepare is called prior to the baseController method.
func (baseController *BaseController) Prepare() {
UserID := baseController.GetSession("UserID")
if UserID == nil {
UserID = "Unknown"
}
baseController.UserID = UserID.(string)
if err := baseController.Service.Prepare(); err != nil {
log.Errorf(err, baseController.UserID, "BaseController.Prepare", baseController.Ctx.Request.URL.Path)
baseController.ServeError(err)
return
}
log.Trace(baseController.UserID, "BaseController.Prepare", "UserID[%s] Path[%s]", baseController.UserID, baseController.Ctx.Request.URL.Path)
}
func SaveFile(service *services.Service, fileInfo fileModels.FileInfo) (*fileModels.FileInfo, error) {
log.Startedf(service.UserID, "SaveFile", "FileHash[%s]", fileInfo.FileHash)
f := func(collection *mgo.Collection) error {
log.Trace(service.UserID, "SaveFile", "MGO : db.file_infos.insert(%s)", mongo.ToString(fileInfo))
return collection.Insert(&fileInfo)
}
if err := service.DBAction(Config.Database, "file_infos", f); err != nil {
if err != mgo.ErrNotFound {
log.CompletedError(err, service.UserID, "SaveFile")
return nil, err
}
}
log.Completedf(service.UserID, "SaveFile", "fileInfo%+v", &fileInfo)
return &fileInfo, nil
}
// Prepare is called prior to the baseController method.
func (baseController *BaseController) Prepare() {
baseController.UserID = baseController.GetString("userID")
if baseController.UserID == "" {
baseController.UserID = baseController.GetString(":userID")
}
if baseController.UserID == "" {
baseController.UserID = "Unknow"
}
if err := baseController.Service.Prepare(); err != nil {
log.Errorf(err, baseController.UserID, "BaseController.Prepare", baseController.Ctx.Request.URL.Path)
baseController.ServeError(err)
return
}
log.Trace(baseController.UserID, "BaseController.Prepare", "UserID[%s] Path[%s]", baseController.UserID, baseController.Ctx.Request.URL.Path)
}
// Prepare is called prior to the baseController method
func (baseController *BaseController) Prepare() {
baseController.UserId = baseController.GetString("userId")
if baseController.UserId == "" {
baseController.UserId = baseController.GetString(":userId")
}
if baseController.UserId == "" {
baseController.UserId = "Unknown"
}
err := baseController.Service.Prepare()
if err != nil {
tracelog.Errorf(err, baseController.UserId, "BaseController.Prepare", baseController.Ctx.Request.URL.Path)
baseController.ServeError(err)
return
}
tracelog.Trace(baseController.UserId, "BaseController.Prepare", "UserId[%s] Path[%s]", baseController.UserId, baseController.Ctx.Request.URL.Path)
}
func googleReverseGeocodeQueryStr(lat float64, lng float64) (string, error) {
var queryStr = bytes.NewBufferString(googleGeocodeURL + "?")
_, err := queryStr.WriteString(fmt.Sprintf("latlng=%f,%f", lat, lng))
if err != nil {
return "", err
}
if GoogleAPIKey != "" {
_, err := queryStr.WriteString(fmt.Sprintf("&key=%s", GoogleAPIKey))
if err != nil {
return "", err
}
}
tracelog.Trace("Query String", "googleReverseGeocodeQueryStr", queryStr.String())
return queryStr.String(), err
}
func googlePlacesQueryStr(placeType string, lat float64, lng float64) (string, error) {
var queryStr = bytes.NewBufferString(googlePlacesURL + "?")
_, err := queryStr.WriteString(fmt.Sprintf("location=%f,%f&rankby=distance&types=%s", lat, lng, placeType))
if err != nil {
return "", err
}
if GoogleAPIKey != "" {
_, err := queryStr.WriteString(fmt.Sprintf("&key=%s", GoogleAPIKey))
if err != nil {
return "", err
}
}
tracelog.Trace("Query String", "googlePlacesQueryStr", queryStr.String())
return queryStr.String(), err
}
// Starts the main server.
func RunServer() {
origin := "http://localhost/"
url := "wss://ws.blockchain.info:443/inv"
// Connect
tracelog.Info(TAG, "RunServer", "Connecting to %s...\n", url)
ws, err := websocket.Dial(url, "", origin)
if err != nil {
log.Fatal(err)
}
tracelog.Info(TAG, "RunServer", "Connected!")
// Subscribe
subscriptionMessage := "{\"op\":\"unconfirmed_sub\"}"
subscriptionBytes := []byte(subscriptionMessage)
tracelog.Info(TAG, "Subscribing with %s...\n", subscriptionMessage)
if _, err := ws.Write(subscriptionBytes); err != nil {
log.Fatal(err)
}
tracelog.Info(TAG, "RunServer", "Subscribed!")
jsonData := make([]byte, 0)
// Forever
for {
n := -1
buffer := make([]byte, 1024)
// Read
tracelog.Trace(TAG, "RunServer", "Reading from socket...")
if n, err = ws.Read(buffer); err != nil {
log.Fatal(err)
}
jsonData = append(jsonData, buffer[:n]...)
if IsValidJson(jsonData) {
// Process
go HandleTransaction(jsonData)
// Restart
jsonData = make([]byte, 0)
}
}
}
// FindRegion retrieves the stations for the specified region
func FindRegion(service *services.Service, region string) ([]buoyModels.BuoyStation, error) {
log.Startedf(service.UserID, "FindRegion", "region[%s]", region)
var buoyStations []buoyModels.BuoyStation
f := func(collection *mgo.Collection) error {
queryMap := bson.M{"region": region}
log.Trace(service.UserID, "FindRegion", "Query : db.buoy_stations.find(%s)", mongo.ToString(queryMap))
return collection.Find(queryMap).All(&buoyStations)
}
if err := service.DBAction(Config.Database, "buoy_stations", f); err != nil {
log.CompletedError(err, service.UserID, "FindRegion")
return nil, err
}
log.Completedf(service.UserID, "FindRegion", "buoyStations%+v", buoyStations)
return buoyStations, nil
}
// FindStation retrieves the specified station
func FindStation(service *services.Service, stationID string) (*buoyModels.BuoyStation, error) {
log.Startedf(service.UserID, "FindStation", "stationID[%s]", stationID)
var buoyStation buoyModels.BuoyStation
//DBCall 方法
f := func(collection *mgo.Collection) error {
queryMap := bson.M{"station_id": stationID}
log.Trace(service.UserID, "FindStation", "MGO : db.buoy_stations.find(%s).limit(1)", mongo.ToString(queryMap))
return collection.Find(queryMap).One(&buoyStation)
}
if err := service.DBAction(Config.Database, "buoy_stations", f); err != nil {
if err != mgo.ErrNotFound {
log.CompletedError(err, service.UserID, "FindStation")
return nil, err
}
}
log.Completedf(service.UserID, "FindStation", "buoyStation%+v", &buoyStation)
return &buoyStation, 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
}