diff --git a/db/bobgen.yaml b/db/bobgen.yaml index eda0546d..14240cab 100644 --- a/db/bobgen.yaml +++ b/db/bobgen.yaml @@ -24,6 +24,7 @@ psql: - "fileupload" - "public" - "publicreport" + - "stadia" - "tile" shared_schema: "public" queries: diff --git a/db/dberrors/stadia.api_request.bob.go b/db/dberrors/stadia.api_request.bob.go new file mode 100644 index 00000000..d0aeef24 --- /dev/null +++ b/db/dberrors/stadia.api_request.bob.go @@ -0,0 +1,26 @@ +// Code generated by BobGen psql v0.42.5. DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package dberrors + +var StadiaAPIRequestErrors = &stadiaAPIRequestErrors{ + ErrUniqueApiRequestPkey: &UniqueConstraintError{ + schema: "stadia", + table: "api_request", + columns: []string{"id"}, + s: "api_request_pkey", + }, + + ErrUniqueApiRequestRequestKey: &UniqueConstraintError{ + schema: "stadia", + table: "api_request", + columns: []string{"request"}, + s: "api_request_request_key", + }, +} + +type stadiaAPIRequestErrors struct { + ErrUniqueApiRequestPkey *UniqueConstraintError + + ErrUniqueApiRequestRequestKey *UniqueConstraintError +} diff --git a/db/dbinfo/stadia.api_request.bob.go b/db/dbinfo/stadia.api_request.bob.go new file mode 100644 index 00000000..7af3aeef --- /dev/null +++ b/db/dbinfo/stadia.api_request.bob.go @@ -0,0 +1,152 @@ +// Code generated by BobGen psql v0.42.5. DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package dbinfo + +import "github.com/aarondl/opt/null" + +var StadiaAPIRequests = Table[ + stadiaAPIRequestColumns, + stadiaAPIRequestIndexes, + stadiaAPIRequestForeignKeys, + stadiaAPIRequestUniques, + stadiaAPIRequestChecks, +]{ + Schema: "stadia", + Name: "api_request", + Columns: stadiaAPIRequestColumns{ + ID: column{ + Name: "id", + DBType: "bigint", + Default: "nextval('stadia.api_request_id_seq'::regclass)", + Comment: "", + Nullable: false, + Generated: false, + AutoIncr: false, + }, + Request: column{ + Name: "request", + DBType: "text", + Default: "", + Comment: "", + Nullable: false, + Generated: false, + AutoIncr: false, + }, + Response: column{ + Name: "response", + DBType: "jsonb", + Default: "", + Comment: "", + Nullable: false, + Generated: false, + AutoIncr: false, + }, + CreatedAt: column{ + Name: "created_at", + DBType: "timestamp without time zone", + Default: "", + Comment: "", + Nullable: false, + Generated: false, + AutoIncr: false, + }, + }, + Indexes: stadiaAPIRequestIndexes{ + APIRequestPkey: index{ + Type: "btree", + Name: "api_request_pkey", + Columns: []indexColumn{ + { + Name: "id", + Desc: null.FromCond(false, true), + IsExpression: false, + }, + }, + Unique: true, + Comment: "", + NullsFirst: []bool{false}, + NullsDistinct: false, + Where: "", + Include: []string{}, + }, + APIRequestRequestKey: index{ + Type: "btree", + Name: "api_request_request_key", + Columns: []indexColumn{ + { + Name: "request", + Desc: null.FromCond(false, true), + IsExpression: false, + }, + }, + Unique: true, + Comment: "", + NullsFirst: []bool{false}, + NullsDistinct: false, + Where: "", + Include: []string{}, + }, + }, + PrimaryKey: &constraint{ + Name: "api_request_pkey", + Columns: []string{"id"}, + Comment: "", + }, + + Uniques: stadiaAPIRequestUniques{ + APIRequestRequestKey: constraint{ + Name: "api_request_request_key", + Columns: []string{"request"}, + Comment: "", + }, + }, + + Comment: "", +} + +type stadiaAPIRequestColumns struct { + ID column + Request column + Response column + CreatedAt column +} + +func (c stadiaAPIRequestColumns) AsSlice() []column { + return []column{ + c.ID, c.Request, c.Response, c.CreatedAt, + } +} + +type stadiaAPIRequestIndexes struct { + APIRequestPkey index + APIRequestRequestKey index +} + +func (i stadiaAPIRequestIndexes) AsSlice() []index { + return []index{ + i.APIRequestPkey, i.APIRequestRequestKey, + } +} + +type stadiaAPIRequestForeignKeys struct{} + +func (f stadiaAPIRequestForeignKeys) AsSlice() []foreignKey { + return []foreignKey{} +} + +type stadiaAPIRequestUniques struct { + APIRequestRequestKey constraint +} + +func (u stadiaAPIRequestUniques) AsSlice() []constraint { + return []constraint{ + u.APIRequestRequestKey, + } +} + +type stadiaAPIRequestChecks struct{} + +func (c stadiaAPIRequestChecks) AsSlice() []check { + return []check{} +} diff --git a/db/migrations/00126_stadia.sql b/db/migrations/00126_stadia.sql new file mode 100644 index 00000000..09fc3f0e --- /dev/null +++ b/db/migrations/00126_stadia.sql @@ -0,0 +1,12 @@ +-- +goose Up +CREATE SCHEMA stadia; +CREATE TABLE stadia.api_request ( + id BIGSERIAL, + request TEXT NOT NULL UNIQUE, -- hash or identifier + response JSONB NOT NULL, + created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL, + PRIMARY KEY(id) +); +-- +goose Down +DROP TABLE stadia.api_request; +DROP SCHEMA stadia; diff --git a/db/models/bob_where.bob.go b/db/models/bob_where.bob.go index b9755a25..bd41c6c1 100644 --- a/db/models/bob_where.bob.go +++ b/db/models/bob_where.bob.go @@ -120,6 +120,7 @@ func Where[Q psql.Filterable]() struct { Signals signalWhere[Q] Sites siteWhere[Q] SpatialRefSys spatialRefSyWhere[Q] + StadiaAPIRequests stadiaAPIRequestWhere[Q] TileCachedImages tileCachedImageWhere[Q] Users userWhere[Q] } { @@ -227,6 +228,7 @@ func Where[Q psql.Filterable]() struct { Signals signalWhere[Q] Sites siteWhere[Q] SpatialRefSys spatialRefSyWhere[Q] + StadiaAPIRequests stadiaAPIRequestWhere[Q] TileCachedImages tileCachedImageWhere[Q] Users userWhere[Q] }{ @@ -333,6 +335,7 @@ func Where[Q psql.Filterable]() struct { Signals: buildSignalWhere[Q](Signals.Columns), Sites: buildSiteWhere[Q](Sites.Columns), SpatialRefSys: buildSpatialRefSyWhere[Q](SpatialRefSys.Columns), + StadiaAPIRequests: buildStadiaAPIRequestWhere[Q](StadiaAPIRequests.Columns), TileCachedImages: buildTileCachedImageWhere[Q](TileCachedImages.Columns), Users: buildUserWhere[Q](Users.Columns), } diff --git a/db/models/stadia.api_request.bob.go b/db/models/stadia.api_request.bob.go new file mode 100644 index 00000000..9833d1bc --- /dev/null +++ b/db/models/stadia.api_request.bob.go @@ -0,0 +1,426 @@ +// Code generated by BobGen psql v0.42.5. DO NOT EDIT. +// This file is meant to be re-generated in place and/or deleted at any time. + +package models + +import ( + "context" + "encoding/json" + "io" + "time" + + "github.com/Gleipnir-Technology/bob" + "github.com/Gleipnir-Technology/bob/dialect/psql" + "github.com/Gleipnir-Technology/bob/dialect/psql/dialect" + "github.com/Gleipnir-Technology/bob/dialect/psql/dm" + "github.com/Gleipnir-Technology/bob/dialect/psql/sm" + "github.com/Gleipnir-Technology/bob/dialect/psql/um" + "github.com/Gleipnir-Technology/bob/expr" + "github.com/Gleipnir-Technology/bob/types" + "github.com/aarondl/opt/omit" +) + +// StadiaAPIRequest is an object representing the database table. +type StadiaAPIRequest struct { + ID int64 `db:"id,pk" ` + Request string `db:"request" ` + Response types.JSON[json.RawMessage] `db:"response" ` + CreatedAt time.Time `db:"created_at" ` +} + +// StadiaAPIRequestSlice is an alias for a slice of pointers to StadiaAPIRequest. +// This should almost always be used instead of []*StadiaAPIRequest. +type StadiaAPIRequestSlice []*StadiaAPIRequest + +// StadiaAPIRequests contains methods to work with the api_request table +var StadiaAPIRequests = psql.NewTablex[*StadiaAPIRequest, StadiaAPIRequestSlice, *StadiaAPIRequestSetter]("stadia", "api_request", buildStadiaAPIRequestColumns("stadia.api_request")) + +// StadiaAPIRequestsQuery is a query on the api_request table +type StadiaAPIRequestsQuery = *psql.ViewQuery[*StadiaAPIRequest, StadiaAPIRequestSlice] + +func buildStadiaAPIRequestColumns(alias string) stadiaAPIRequestColumns { + return stadiaAPIRequestColumns{ + ColumnsExpr: expr.NewColumnsExpr( + "id", "request", "response", "created_at", + ).WithParent("stadia.api_request"), + tableAlias: alias, + ID: psql.Quote(alias, "id"), + Request: psql.Quote(alias, "request"), + Response: psql.Quote(alias, "response"), + CreatedAt: psql.Quote(alias, "created_at"), + } +} + +type stadiaAPIRequestColumns struct { + expr.ColumnsExpr + tableAlias string + ID psql.Expression + Request psql.Expression + Response psql.Expression + CreatedAt psql.Expression +} + +func (c stadiaAPIRequestColumns) Alias() string { + return c.tableAlias +} + +func (stadiaAPIRequestColumns) AliasedAs(alias string) stadiaAPIRequestColumns { + return buildStadiaAPIRequestColumns(alias) +} + +// StadiaAPIRequestSetter is used for insert/upsert/update operations +// All values are optional, and do not have to be set +// Generated columns are not included +type StadiaAPIRequestSetter struct { + ID omit.Val[int64] `db:"id,pk" ` + Request omit.Val[string] `db:"request" ` + Response omit.Val[types.JSON[json.RawMessage]] `db:"response" ` + CreatedAt omit.Val[time.Time] `db:"created_at" ` +} + +func (s StadiaAPIRequestSetter) SetColumns() []string { + vals := make([]string, 0, 4) + if s.ID.IsValue() { + vals = append(vals, "id") + } + if s.Request.IsValue() { + vals = append(vals, "request") + } + if s.Response.IsValue() { + vals = append(vals, "response") + } + if s.CreatedAt.IsValue() { + vals = append(vals, "created_at") + } + return vals +} + +func (s StadiaAPIRequestSetter) Overwrite(t *StadiaAPIRequest) { + if s.ID.IsValue() { + t.ID = s.ID.MustGet() + } + if s.Request.IsValue() { + t.Request = s.Request.MustGet() + } + if s.Response.IsValue() { + t.Response = s.Response.MustGet() + } + if s.CreatedAt.IsValue() { + t.CreatedAt = s.CreatedAt.MustGet() + } +} + +func (s *StadiaAPIRequestSetter) Apply(q *dialect.InsertQuery) { + q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) { + return StadiaAPIRequests.BeforeInsertHooks.RunHooks(ctx, exec, s) + }) + + q.AppendValues(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) { + vals := make([]bob.Expression, 4) + if s.ID.IsValue() { + vals[0] = psql.Arg(s.ID.MustGet()) + } else { + vals[0] = psql.Raw("DEFAULT") + } + + if s.Request.IsValue() { + vals[1] = psql.Arg(s.Request.MustGet()) + } else { + vals[1] = psql.Raw("DEFAULT") + } + + if s.Response.IsValue() { + vals[2] = psql.Arg(s.Response.MustGet()) + } else { + vals[2] = psql.Raw("DEFAULT") + } + + if s.CreatedAt.IsValue() { + vals[3] = psql.Arg(s.CreatedAt.MustGet()) + } else { + vals[3] = psql.Raw("DEFAULT") + } + + return bob.ExpressSlice(ctx, w, d, start, vals, "", ", ", "") + })) +} + +func (s StadiaAPIRequestSetter) UpdateMod() bob.Mod[*dialect.UpdateQuery] { + return um.Set(s.Expressions()...) +} + +func (s StadiaAPIRequestSetter) Expressions(prefix ...string) []bob.Expression { + exprs := make([]bob.Expression, 0, 4) + + if s.ID.IsValue() { + exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{ + psql.Quote(append(prefix, "id")...), + psql.Arg(s.ID), + }}) + } + + if s.Request.IsValue() { + exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{ + psql.Quote(append(prefix, "request")...), + psql.Arg(s.Request), + }}) + } + + if s.Response.IsValue() { + exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{ + psql.Quote(append(prefix, "response")...), + psql.Arg(s.Response), + }}) + } + + if s.CreatedAt.IsValue() { + exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{ + psql.Quote(append(prefix, "created_at")...), + psql.Arg(s.CreatedAt), + }}) + } + + return exprs +} + +// FindStadiaAPIRequest retrieves a single record by primary key +// If cols is empty Find will return all columns. +func FindStadiaAPIRequest(ctx context.Context, exec bob.Executor, IDPK int64, cols ...string) (*StadiaAPIRequest, error) { + if len(cols) == 0 { + return StadiaAPIRequests.Query( + sm.Where(StadiaAPIRequests.Columns.ID.EQ(psql.Arg(IDPK))), + ).One(ctx, exec) + } + + return StadiaAPIRequests.Query( + sm.Where(StadiaAPIRequests.Columns.ID.EQ(psql.Arg(IDPK))), + sm.Columns(StadiaAPIRequests.Columns.Only(cols...)), + ).One(ctx, exec) +} + +// StadiaAPIRequestExists checks the presence of a single record by primary key +func StadiaAPIRequestExists(ctx context.Context, exec bob.Executor, IDPK int64) (bool, error) { + return StadiaAPIRequests.Query( + sm.Where(StadiaAPIRequests.Columns.ID.EQ(psql.Arg(IDPK))), + ).Exists(ctx, exec) +} + +// AfterQueryHook is called after StadiaAPIRequest is retrieved from the database +func (o *StadiaAPIRequest) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error { + var err error + + switch queryType { + case bob.QueryTypeSelect: + ctx, err = StadiaAPIRequests.AfterSelectHooks.RunHooks(ctx, exec, StadiaAPIRequestSlice{o}) + case bob.QueryTypeInsert: + ctx, err = StadiaAPIRequests.AfterInsertHooks.RunHooks(ctx, exec, StadiaAPIRequestSlice{o}) + case bob.QueryTypeUpdate: + ctx, err = StadiaAPIRequests.AfterUpdateHooks.RunHooks(ctx, exec, StadiaAPIRequestSlice{o}) + case bob.QueryTypeDelete: + ctx, err = StadiaAPIRequests.AfterDeleteHooks.RunHooks(ctx, exec, StadiaAPIRequestSlice{o}) + } + + return err +} + +// primaryKeyVals returns the primary key values of the StadiaAPIRequest +func (o *StadiaAPIRequest) primaryKeyVals() bob.Expression { + return psql.Arg(o.ID) +} + +func (o *StadiaAPIRequest) pkEQ() dialect.Expression { + return psql.Quote("stadia.api_request", "id").EQ(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) { + return o.primaryKeyVals().WriteSQL(ctx, w, d, start) + })) +} + +// Update uses an executor to update the StadiaAPIRequest +func (o *StadiaAPIRequest) Update(ctx context.Context, exec bob.Executor, s *StadiaAPIRequestSetter) error { + v, err := StadiaAPIRequests.Update(s.UpdateMod(), um.Where(o.pkEQ())).One(ctx, exec) + if err != nil { + return err + } + + *o = *v + + return nil +} + +// Delete deletes a single StadiaAPIRequest record with an executor +func (o *StadiaAPIRequest) Delete(ctx context.Context, exec bob.Executor) error { + _, err := StadiaAPIRequests.Delete(dm.Where(o.pkEQ())).Exec(ctx, exec) + return err +} + +// Reload refreshes the StadiaAPIRequest using the executor +func (o *StadiaAPIRequest) Reload(ctx context.Context, exec bob.Executor) error { + o2, err := StadiaAPIRequests.Query( + sm.Where(StadiaAPIRequests.Columns.ID.EQ(psql.Arg(o.ID))), + ).One(ctx, exec) + if err != nil { + return err + } + + *o = *o2 + + return nil +} + +// AfterQueryHook is called after StadiaAPIRequestSlice is retrieved from the database +func (o StadiaAPIRequestSlice) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error { + var err error + + switch queryType { + case bob.QueryTypeSelect: + ctx, err = StadiaAPIRequests.AfterSelectHooks.RunHooks(ctx, exec, o) + case bob.QueryTypeInsert: + ctx, err = StadiaAPIRequests.AfterInsertHooks.RunHooks(ctx, exec, o) + case bob.QueryTypeUpdate: + ctx, err = StadiaAPIRequests.AfterUpdateHooks.RunHooks(ctx, exec, o) + case bob.QueryTypeDelete: + ctx, err = StadiaAPIRequests.AfterDeleteHooks.RunHooks(ctx, exec, o) + } + + return err +} + +func (o StadiaAPIRequestSlice) pkIN() dialect.Expression { + if len(o) == 0 { + return psql.Raw("NULL") + } + + return psql.Quote("stadia.api_request", "id").In(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) { + pkPairs := make([]bob.Expression, len(o)) + for i, row := range o { + pkPairs[i] = row.primaryKeyVals() + } + return bob.ExpressSlice(ctx, w, d, start, pkPairs, "", ", ", "") + })) +} + +// copyMatchingRows finds models in the given slice that have the same primary key +// then it first copies the existing relationships from the old model to the new model +// and then replaces the old model in the slice with the new model +func (o StadiaAPIRequestSlice) copyMatchingRows(from ...*StadiaAPIRequest) { + for i, old := range o { + for _, new := range from { + if new.ID != old.ID { + continue + } + + o[i] = new + break + } + } +} + +// UpdateMod modifies an update query with "WHERE primary_key IN (o...)" +func (o StadiaAPIRequestSlice) UpdateMod() bob.Mod[*dialect.UpdateQuery] { + return bob.ModFunc[*dialect.UpdateQuery](func(q *dialect.UpdateQuery) { + q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) { + return StadiaAPIRequests.BeforeUpdateHooks.RunHooks(ctx, exec, o) + }) + + q.AppendLoader(bob.LoaderFunc(func(ctx context.Context, exec bob.Executor, retrieved any) error { + var err error + switch retrieved := retrieved.(type) { + case *StadiaAPIRequest: + o.copyMatchingRows(retrieved) + case []*StadiaAPIRequest: + o.copyMatchingRows(retrieved...) + case StadiaAPIRequestSlice: + o.copyMatchingRows(retrieved...) + default: + // If the retrieved value is not a StadiaAPIRequest or a slice of StadiaAPIRequest + // then run the AfterUpdateHooks on the slice + _, err = StadiaAPIRequests.AfterUpdateHooks.RunHooks(ctx, exec, o) + } + + return err + })) + + q.AppendWhere(o.pkIN()) + }) +} + +// DeleteMod modifies an delete query with "WHERE primary_key IN (o...)" +func (o StadiaAPIRequestSlice) DeleteMod() bob.Mod[*dialect.DeleteQuery] { + return bob.ModFunc[*dialect.DeleteQuery](func(q *dialect.DeleteQuery) { + q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) { + return StadiaAPIRequests.BeforeDeleteHooks.RunHooks(ctx, exec, o) + }) + + q.AppendLoader(bob.LoaderFunc(func(ctx context.Context, exec bob.Executor, retrieved any) error { + var err error + switch retrieved := retrieved.(type) { + case *StadiaAPIRequest: + o.copyMatchingRows(retrieved) + case []*StadiaAPIRequest: + o.copyMatchingRows(retrieved...) + case StadiaAPIRequestSlice: + o.copyMatchingRows(retrieved...) + default: + // If the retrieved value is not a StadiaAPIRequest or a slice of StadiaAPIRequest + // then run the AfterDeleteHooks on the slice + _, err = StadiaAPIRequests.AfterDeleteHooks.RunHooks(ctx, exec, o) + } + + return err + })) + + q.AppendWhere(o.pkIN()) + }) +} + +func (o StadiaAPIRequestSlice) UpdateAll(ctx context.Context, exec bob.Executor, vals StadiaAPIRequestSetter) error { + if len(o) == 0 { + return nil + } + + _, err := StadiaAPIRequests.Update(vals.UpdateMod(), o.UpdateMod()).All(ctx, exec) + return err +} + +func (o StadiaAPIRequestSlice) DeleteAll(ctx context.Context, exec bob.Executor) error { + if len(o) == 0 { + return nil + } + + _, err := StadiaAPIRequests.Delete(o.DeleteMod()).Exec(ctx, exec) + return err +} + +func (o StadiaAPIRequestSlice) ReloadAll(ctx context.Context, exec bob.Executor) error { + if len(o) == 0 { + return nil + } + + o2, err := StadiaAPIRequests.Query(sm.Where(o.pkIN())).All(ctx, exec) + if err != nil { + return err + } + + o.copyMatchingRows(o2...) + + return nil +} + +type stadiaAPIRequestWhere[Q psql.Filterable] struct { + ID psql.WhereMod[Q, int64] + Request psql.WhereMod[Q, string] + Response psql.WhereMod[Q, types.JSON[json.RawMessage]] + CreatedAt psql.WhereMod[Q, time.Time] +} + +func (stadiaAPIRequestWhere[Q]) AliasedAs(alias string) stadiaAPIRequestWhere[Q] { + return buildStadiaAPIRequestWhere[Q](buildStadiaAPIRequestColumns(alias)) +} + +func buildStadiaAPIRequestWhere[Q psql.Filterable](cols stadiaAPIRequestColumns) stadiaAPIRequestWhere[Q] { + return stadiaAPIRequestWhere[Q]{ + ID: psql.Where[Q, int64](cols.ID), + Request: psql.Where[Q, string](cols.Request), + Response: psql.Where[Q, types.JSON[json.RawMessage]](cols.Response), + CreatedAt: psql.Where[Q, time.Time](cols.CreatedAt), + } +} diff --git a/platform/geocode/autocomplete.go b/platform/geocode/autocomplete.go index 54440a1a..833ab874 100644 --- a/platform/geocode/autocomplete.go +++ b/platform/geocode/autocomplete.go @@ -23,7 +23,7 @@ func Autocomplete(ctx context.Context, org *models.Organization, address string) maybeAddServiceArea(&req, org) resp, err := client.GeocodeAutocomplete(ctx, req) if err != nil { - return nil, fmt.Errorf("client raw geocode failure on %s: %w", address, err) + return nil, fmt.Errorf("client geocode autocomplete failure on %s: %w", address, err) } result := make([]*AutocompleteResult, len(resp.Features)) for i, r := range resp.Features { diff --git a/platform/geocode/geocode.go b/platform/geocode/geocode.go index d8558f17..772d1392 100644 --- a/platform/geocode/geocode.go +++ b/platform/geocode/geocode.go @@ -2,6 +2,7 @@ package geocode import ( "context" + "encoding/json" "fmt" "strings" "time" @@ -10,13 +11,17 @@ import ( "github.com/Gleipnir-Technology/bob/dialect/psql" "github.com/Gleipnir-Technology/bob/dialect/psql/im" "github.com/Gleipnir-Technology/bob/dialect/psql/sm" + bobtypes "github.com/Gleipnir-Technology/bob/types" + "github.com/Gleipnir-Technology/nidus-sync/db" "github.com/Gleipnir-Technology/nidus-sync/db/models" "github.com/Gleipnir-Technology/nidus-sync/h3utils" "github.com/Gleipnir-Technology/nidus-sync/platform/types" "github.com/Gleipnir-Technology/nidus-sync/stadia" + "github.com/aarondl/opt/omit" "github.com/stephenafamo/scan" //"github.com/rs/zerolog/log" "github.com/uber/h3-go/v4" + "resty.dev/v3" ) type GeocodeResult struct { @@ -29,6 +34,22 @@ var client *stadia.StadiaMaps func InitializeStadia(key string) { client = stadia.NewStadiaMaps(key) + client.AddResponseMiddleware(restyMiddleware) +} +func restyMiddleware(rclient *resty.Client, response *resty.Response) error { + //log.Info().Msg("middleware") + ctx := context.Background() + var body bobtypes.JSON[json.RawMessage] + err := body.UnmarshalJSON(response.Bytes()) + if err != nil { + return fmt.Errorf("unmarshal json in middleware: %w", err) + } + models.StadiaAPIRequests.Insert(&models.StadiaAPIRequestSetter{ + CreatedAt: omit.From(time.Now()), + Request: omit.From(response.Request.URL), + Response: omit.From(body), + }).One(ctx, db.PGInstance.BobDB) + return nil } // Ensure the provided address exists. If it doesn't add it to the database. @@ -215,6 +236,7 @@ func toGeocodeResult(resp stadia.GeocodeResponse, address_msg string) (*GeocodeR Number: feature.Properties.HouseNumber, PostalCode: feature.Properties.PostalCode, Region: feature.Properties.Region, + Raw: feature.Properties.FormattedAddressLine, Street: feature.Properties.Street, Unit: "", } diff --git a/stadia/stadia.go b/stadia/stadia.go index 80f7d752..38e15d1c 100644 --- a/stadia/stadia.go +++ b/stadia/stadia.go @@ -32,6 +32,10 @@ func NewStadiaMaps(api_key string) *StadiaMaps { } } +func (s *StadiaMaps) AddResponseMiddleware(m resty.ResponseMiddleware) { + s.client.SetResponseBodyUnlimitedReads(true) + s.client.AddResponseMiddleware(m) +} func (s *StadiaMaps) Close() { s.client.Close() } diff --git a/ts/rmo/type.ts b/ts/rmo/type.ts deleted file mode 100644 index 35632c6e..00000000 --- a/ts/rmo/type.ts +++ /dev/null @@ -1,5 +0,0 @@ -export interface District { - name: string; - slug: string; - url_logo: string; -}