func GetTmUserByName(username string, db *sqlx.DB) (TmUser, error) {
ret := []TmUser{}
// this works in pq - $1
// err := db.GlobalDB.Get(&ret, "select * from tm_user where username=$1", username)
// if err != nil {
// log.Println(err)
// }
// this works in mysql - ?
// err := db.GlobalDB.Get(&ret, "select * from tm_user where username=?", username)
// if err != nil {
// log.Println(err)
// }
// this works in both
arg := TmUser{Username: null.StringFrom(username)}
nstmt, err := db.PrepareNamed(`select * from tm_user where username=:username`)
if err != nil {
log.Println(err)
return TmUser{}, err
}
defer nstmt.Close()
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return TmUser{}, err
}
if len(ret) != 1 {
err = errors.New("Username " + username + " is not unique!")
return TmUser{}, err
}
return ret[0], err
}
func newRepository(db *sqlx.DB) (*repository, error) {
r := repository{db: db}
stmts := map[string]**sqlx.NamedStmt{
findMood: &r.findMood,
setMood: &r.setMood,
deleteMood: &r.deleteMood,
insertConvo: &r.insertConvo,
getConvo: &r.getConvo,
deleteConvo: &r.deleteConvo,
findConvoLines: &r.findConvoLines,
insertLine: &r.insertLine,
getLine: &r.getLine,
deleteLine: &r.deleteLine,
fmt.Sprintf(listConvos, ">", "ASC"): &r.listConvosAsc,
fmt.Sprintf(listConvos, "<", "DESC"): &r.listConvosDesc,
fmt.Sprintf(listMoods, ">", "ASC"): &r.listMoodsAsc,
fmt.Sprintf(listMoods, "<", "DESC"): &r.listMoodsDesc,
}
for sqlStr, stmt := range stmts {
prepped, err := db.PrepareNamed(sqlStr)
*stmt = prepped
if err != nil {
return nil, errors.Annotatef(err, "preparing statement %s", sqlStr)
}
r.closers = append(r.closers, prepped)
}
return &r, nil
}
func (r Rock) Create(db *sqlx.DB, m *rock.Model) error {
stmt, err := db.PrepareNamed(`INSERT INTO rocks (latitude, longitude) VALUES (:latitude, :longitude) RETURNING *`)
if err != nil {
log.Fatal(err)
}
err = stmt.Get(m, m)
return err
}
// @Title getGooseDbVersionById
// @Description retrieves the goose_db_version information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} GooseDbVersion
// @Resource /api/2.0
// @Router /api/2.0/goose_db_version/{id} [get]
func getGooseDbVersionById(id int, db *sqlx.DB) (interface{}, error) {
ret := []GooseDbVersion{}
arg := GooseDbVersion{Id: int64(id)}
nstmt, err := db.PrepareNamed(`select * from goose_db_version where id=:id`)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// \todo add port (Servers PK is a compound key, host_name and port
func getCSConfigRemap(serverName string, db *sqlx.DB) ([]CsconfigRemap, error) {
ret := []CsconfigRemap{}
arg := api.Servers{HostName: serverName}
nstmt, err := db.PrepareNamed(`select * from csconfig_remap where host_name=:host_name`)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
func getCSConfigParams(profile int64, db *sqlx.DB) ([]CsconfigParam, error) {
ret := []CsconfigParam{}
arg := CsconfigParam{Profile: profile}
nstmt, err := db.PrepareNamed(`select * from csconfig_params where profile=:profile`)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
func getCSConfigRemap(serverId int64, db *sqlx.DB) ([]CsconfigRemap, error) {
ret := []CsconfigRemap{}
arg := api.Server{Id: serverId}
nstmt, err := db.PrepareNamed(`select * from csconfig_remap where server_id=:id`)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getTypeById
// @Description retrieves the type information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Type
// @Resource /api/2.0
// @Router /api/2.0/type/{id} [get]
func getTypeById(id int, db *sqlx.DB) (interface{}, error) {
ret := []Type{}
arg := Type{}
arg.Id = int64(id)
queryStr := "select *, concat('" + API_PATH + "type/', id) as self "
queryStr += " from type where id=:id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
func GetServerByName(serverName string, db *sqlx.DB) (Server, error) {
ret := []Server{}
arg := Server{HostName: serverName}
nstmt, err := db.PrepareNamed(`select * from server where host_name=:host_name`)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
}
if len(ret) != 1 {
err = errors.New("Host name " + serverName + " is not unique!")
}
nstmt.Close()
return ret[0], err
}
// @Title getFederationResolversById
// @Description retrieves the federation_resolvers information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} FederationResolvers
// @Resource /api/2.0
// @Router /api/2.0/federation_resolvers/{id} [get]
func getFederationResolver(id int64, db *sqlx.DB) (interface{}, error) {
ret := []FederationResolvers{}
arg := FederationResolvers{}
arg.Id = id
queryStr := "select *, concat('" + API_PATH + "federation_resolvers/', id) as self"
queryStr += " from federation_resolvers WHERE id=:id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getLogById
// @Description retrieves the log information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Log
// @Resource /api/2.0
// @Router /api/2.0/log/{id} [get]
func getLog(id int64, db *sqlx.DB) (interface{}, error) {
ret := []Log{}
arg := Log{}
arg.Id = id
queryStr := "select *, concat('" + API_PATH + "log/', id) as self"
queryStr += " from log WHERE id=:id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
func (h *Hub) Delete(db *sqlx.DB) error {
nstmt, err := db.PrepareNamed(`DELETE FROM hubs
WHERE slug = (:slug)
RETURNING *;
`)
if err != nil {
return err
}
defer nstmt.Close()
err = nstmt.QueryRow(h).StructScan(h)
// TODO?: Handle possible error cases? Eg...
// hub record_not_found error would have already been caught in Get Method above.
return err
}
// @Title getRolesById
// @Description retrieves the roles information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Roles
// @Resource /api/2.0
// @Router /api/2.0/roles/{id} [get]
func getRole(name string, db *sqlx.DB) (interface{}, error) {
ret := []Roles{}
arg := Roles{}
arg.Name = name
queryStr := "select *, concat('" + API_PATH + "roles/', name) as self"
queryStr += " from roles WHERE name=:name"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getDeliveryservicesUsersById
// @Description retrieves the deliveryservices_users information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} DeliveryservicesUsers
// @Resource /api/2.0
// @Router /api/2.0/deliveryservices_users/{id} [get]
func getDeliveryservicesUser(deliveryservice string, username string, db *sqlx.DB) (interface{}, error) {
ret := []DeliveryservicesUsers{}
arg := DeliveryservicesUsers{}
arg.Deliveryservice = deliveryservice
arg.Username = username
queryStr := "select *, concat('" + API_PATH + "deliveryservices_users', '/deliveryservice/', deliveryservice, '/username/', username) as self"
queryStr += " from deliveryservices_users WHERE deliveryservice=:deliveryservice AND username=:username"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getFederationUsersById
// @Description retrieves the federation_users information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} FederationUsers
// @Resource /api/2.0
// @Router /api/2.0/federation_users/{id} [get]
func getFederationUser(federationId int64, username string, db *sqlx.DB) (interface{}, error) {
ret := []FederationUsers{}
arg := FederationUsers{}
arg.FederationId = federationId
arg.Username = username
queryStr := "select *, concat('" + API_PATH + "federation_users', '/federation_id/', federation_id, '/username/', username) as self"
queryStr += " from federation_users WHERE federation_id=:federation_id AND username=:username"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getProfilesParametersById
// @Description retrieves the profiles_parameters information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} ProfilesParameters
// @Resource /api/2.0
// @Router /api/2.0/profiles_parameters/{id} [get]
func getProfilesParameter(profile string, parameterId int64, db *sqlx.DB) (interface{}, error) {
ret := []ProfilesParameters{}
arg := ProfilesParameters{}
arg.Profile = profile
arg.ParameterId = parameterId
queryStr := "select *, concat('" + API_PATH + "profiles_parameters', '/profile/', profile, '/parameter_id/', parameter_id) as self"
queryStr += " from profiles_parameters WHERE profile=:profile AND parameter_id=:parameter_id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getAsnsById
// @Description retrieves the asns information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Asns
// @Resource /api/2.0
// @Router /api/2.0/asns/{id} [get]
func getAsn(asn int64, db *sqlx.DB) (interface{}, error) {
ret := []Asns{}
arg := Asns{}
arg.Asn = asn
queryStr := "select *, concat('" + API_PATH + "asns/', asn) as self"
queryStr += ", concat('" + API_PATH + "cachegroups/', cachegroups) as cachegroups_name_ref"
queryStr += " from asns WHERE asn=:asn"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getExtensionsById
// @Description retrieves the extensions information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Extensions
// @Resource /api/2.0
// @Router /api/2.0/extensions/{id} [get]
func getExtension(name string, db *sqlx.DB) (interface{}, error) {
ret := []Extensions{}
arg := Extensions{}
arg.Name = name
queryStr := "select *, concat('" + API_PATH + "extensions/', name) as self"
queryStr += ", concat('" + API_PATH + "extensions_types/', type) as extensions_types_name_ref"
queryStr += " from extensions WHERE name=:name"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getDeliveryservicesRegexesById
// @Description retrieves the deliveryservices_regexes information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} DeliveryservicesRegexes
// @Resource /api/2.0
// @Router /api/2.0/deliveryservices_regexes/{id} [get]
func getDeliveryservicesRegex(deliveryservice string, regexId int64, db *sqlx.DB) (interface{}, error) {
ret := []DeliveryservicesRegexes{}
arg := DeliveryservicesRegexes{}
arg.Deliveryservice = deliveryservice
arg.RegexId = regexId
queryStr := "select *, concat('" + API_PATH + "deliveryservices_regexes', '/deliveryservice/', deliveryservice, '/regex_id/', regex_id) as self"
queryStr += " from deliveryservices_regexes WHERE deliveryservice=:deliveryservice AND regex_id=:regex_id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getRegexesById
// @Description retrieves the regexes information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Regexes
// @Resource /api/2.0
// @Router /api/2.0/regexes/{id} [get]
func getRegex(id int64, db *sqlx.DB) (interface{}, error) {
ret := []Regexes{}
arg := Regexes{}
arg.Id = id
queryStr := "select *, concat('" + API_PATH + "regexes/', id) as self"
queryStr += ", concat('" + API_PATH + "regexes_types/', type) as regexes_types_name_ref"
queryStr += " from regexes WHERE id=:id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getFederationsFederationResolversById
// @Description retrieves the federations_federation_resolvers information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} FederationsFederationResolvers
// @Resource /api/2.0
// @Router /api/2.0/federations_federation_resolvers/{id} [get]
func getFederationsFederationResolver(federationId int64, federationResolver int64, db *sqlx.DB) (interface{}, error) {
ret := []FederationsFederationResolvers{}
arg := FederationsFederationResolvers{}
arg.FederationId = federationId
arg.FederationResolver = federationResolver
queryStr := "select *, concat('" + API_PATH + "federations_federation_resolvers', '/federation_id/', federation_id, '/federation_resolver/', federation_resolver) as self"
queryStr += " from federations_federation_resolvers WHERE federation_id=:federation_id AND federation_resolver=:federation_resolver"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getAsnById
// @Description retrieves the asn information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Asn
// @Resource /api/2.0
// @Router /api/2.0/asn/{id} [get]
func getAsnById(id int, db *sqlx.DB) (interface{}, error) {
ret := []Asn{}
arg := Asn{}
arg.Id = int64(id)
queryStr := "select *, concat('" + API_PATH + "asn/', id) as self "
queryStr += ", concat('" + API_PATH + "cachegroup/', cachegroup) as cachegroup_id_ref"
queryStr += " from asn where id=:id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getFederationsDeliveryservicesById
// @Description retrieves the federations_deliveryservices information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} FederationsDeliveryservices
// @Resource /api/2.0
// @Router /api/2.0/federations_deliveryservices/{id} [get]
func getFederationsDeliveryservice(federationId int64, deliveryservice string, db *sqlx.DB) (interface{}, error) {
ret := []FederationsDeliveryservices{}
arg := FederationsDeliveryservices{}
arg.FederationId = federationId
arg.Deliveryservice = deliveryservice
queryStr := "select *, concat('" + API_PATH + "federations_deliveryservices', '/federation_id/', federation_id, '/deliveryservice/', deliveryservice) as self"
queryStr += " from federations_deliveryservices WHERE federation_id=:federation_id AND deliveryservice=:deliveryservice"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getRegionById
// @Description retrieves the region information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Region
// @Resource /api/2.0
// @Router /api/2.0/region/{id} [get]
func getRegionById(id int, db *sqlx.DB) (interface{}, error) {
ret := []Region{}
arg := Region{}
arg.Id = int64(id)
queryStr := "select *, concat('" + API_PATH + "region/', id) as self "
queryStr += ", concat('" + API_PATH + "division/', division) as division_id_ref"
queryStr += " from region where id=:id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getServercheckById
// @Description retrieves the servercheck information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Servercheck
// @Resource /api/2.0
// @Router /api/2.0/servercheck/{id} [get]
func getServercheckById(id int, db *sqlx.DB) (interface{}, error) {
ret := []Servercheck{}
arg := Servercheck{}
arg.Id = int64(id)
queryStr := "select *, concat('" + API_PATH + "servercheck/', id) as self "
queryStr += ", concat('" + API_PATH + "server/', server) as server_id_ref"
queryStr += " from servercheck where id=:id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getFederationResolverById
// @Description retrieves the federation_resolver information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} FederationResolver
// @Resource /api/2.0
// @Router /api/2.0/federation_resolver/{id} [get]
func getFederationResolverById(id int, db *sqlx.DB) (interface{}, error) {
ret := []FederationResolver{}
arg := FederationResolver{}
arg.Id = int64(id)
queryStr := "select *, concat('" + API_PATH + "federation_resolver/', id) as self "
queryStr += ", concat('" + API_PATH + "type/', type) as type_id_ref"
queryStr += " from federation_resolver where id=:id"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getUsersById
// @Description retrieves the users information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Users
// @Resource /api/2.0
// @Router /api/2.0/users/{id} [get]
func GetUser(username string, db *sqlx.DB) (interface{}, error) {
ret := []Users{}
arg := Users{}
arg.Username = username
queryStr := "select *, concat('" + API_PATH + "users/', username) as self"
queryStr += ", concat('" + API_PATH + "roles/', role) as roles_name_ref"
queryStr += " from users WHERE username=:username"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getCachegroupsById
// @Description retrieves the cachegroups information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} Cachegroups
// @Resource /api/2.0
// @Router /api/2.0/cachegroups/{id} [get]
func getCachegroup(name string, db *sqlx.DB) (interface{}, error) {
ret := []Cachegroups{}
arg := Cachegroups{}
arg.Name = name
queryStr := "select *, concat('" + API_PATH + "cachegroups/', name) as self"
queryStr += ", concat('" + API_PATH + "cachegroups/', parent_cachegroup) as cachegroups_name_ref"
queryStr += ", concat('" + API_PATH + "cachegroups_types/', type) as cachegroups_types_name_ref"
queryStr += " from cachegroups WHERE name=:name"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getFederationDeliveryserviceById
// @Description retrieves the federation_deliveryservice information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} FederationDeliveryservice
// @Resource /api/2.0
// @Router /api/2.0/federation_deliveryservice/{id} [get]
func getFederationDeliveryserviceById(id int, db *sqlx.DB) (interface{}, error) {
ret := []FederationDeliveryservice{}
arg := FederationDeliveryservice{}
arg.Links.FederationLink.ID = int64(id)
queryStr := "select *, concat('" + API_PATH + "federation_deliveryservice/', id) as self "
queryStr += ", concat('" + API_PATH + "federation/', federation) as federation_id_ref"
queryStr += ", concat('" + API_PATH + "deliveryservice/', deliveryservice) as deliveryservice_id_ref"
queryStr += " from federation_deliveryservice where Links.FederationLink.ID=:Links.FederationLink.ID"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}
// @Title getDeliveryserviceServerById
// @Description retrieves the deliveryservice_server information for a certain id
// @Accept application/json
// @Param id path int false "The row id"
// @Success 200 {array} DeliveryserviceServer
// @Resource /api/2.0
// @Router /api/2.0/deliveryservice_server/{id} [get]
func getDeliveryserviceServerById(id int, db *sqlx.DB) (interface{}, error) {
ret := []DeliveryserviceServer{}
arg := DeliveryserviceServer{}
arg.Links.DeliveryserviceLink.ID = int64(id)
queryStr := "select *, concat('" + API_PATH + "deliveryservice_server/', id) as self "
queryStr += ", concat('" + API_PATH + "deliveryservice/', deliveryservice) as deliveryservice_id_ref"
queryStr += ", concat('" + API_PATH + "server/', server) as server_id_ref"
queryStr += " from deliveryservice_server where Links.DeliveryserviceLink.ID=:Links.DeliveryserviceLink.ID"
nstmt, err := db.PrepareNamed(queryStr)
err = nstmt.Select(&ret, arg)
if err != nil {
log.Println(err)
return nil, err
}
nstmt.Close()
return ret, nil
}