Gleipnir/nidus-sync
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Properly record and display pool reports

Browse source
This commit is contained in:
Eli Ribble 2026-02-05 21:43:29 +00:00
parent 47c3f7320c
commit 9328e7a2f8
No known key found for this signature in database
15 changed files with 895 additions and 446 deletions
Download patch file Download diff file Expand all files Collapse all files

104
db/dbinfo/publicreport.pool.bob.go
View file

@ -197,7 +197,7 @@ var PublicreportPools = Table[
},
MapZoom: column{
Name: "map_zoom",
DBType: "double precision",
DBType: "real",
Default: "",
Comment: "",
Nullable: false,
@ -267,15 +267,6 @@ var PublicreportPools = Table[
Generated: false,
AutoIncr: false,
},
Subscribe: column{
Name: "subscribe",
DBType: "boolean",
Default: "",
Comment: "",
Nullable: false,
Generated: false,
AutoIncr: false,
},
Status: column{
Name: "status",
DBType: "publicreport.reportstatustype",
@ -294,6 +285,33 @@ var PublicreportPools = Table[
Generated: false,
AutoIncr: false,
},
HasBackyardPermission: column{
Name: "has_backyard_permission",
DBType: "boolean",
Default: "",
Comment: "",
Nullable: false,
Generated: false,
AutoIncr: false,
},
IsReporterConfidential: column{
Name: "is_reporter_confidential",
DBType: "boolean",
Default: "",
Comment: "",
Nullable: false,
Generated: false,
AutoIncr: false,
},
IsReporterOwner: column{
Name: "is_reporter_owner",
DBType: "boolean",
Default: "",
Comment: "",
Nullable: false,
Generated: false,
AutoIncr: false,
},
},
Indexes: publicreportPoolIndexes{
PoolPkey: index{
@ -359,42 +377,44 @@ var PublicreportPools = Table[
}
type publicreportPoolColumns struct {
ID column
AccessComments column
AccessGate column
AccessFence column
AccessLocked column
AccessDog column
AccessOther column
Address column
AddressCountry column
AddressPostCode column
AddressPlace column
AddressStreet column
AddressRegion column
Comments column
Created column
H3cell column
HasAdult column
HasLarvae column
HasPupae column
Location column
MapZoom column
OwnerEmail column
OwnerName column
OwnerPhone column
PublicID column
ReporterEmail column
ReporterName column
ReporterPhone column
Subscribe column
Status column
OrganizationID column
ID column
AccessComments column
AccessGate column
AccessFence column
AccessLocked column
AccessDog column
AccessOther column
Address column
AddressCountry column
AddressPostCode column
AddressPlace column
AddressStreet column
AddressRegion column
Comments column
Created column
H3cell column
HasAdult column
HasLarvae column
HasPupae column
Location column
MapZoom column
OwnerEmail column
OwnerName column
OwnerPhone column
PublicID column
ReporterEmail column
ReporterName column
ReporterPhone column
Status column
OrganizationID column
HasBackyardPermission column
IsReporterConfidential column
IsReporterOwner column
}
func (c publicreportPoolColumns) AsSlice() []column {
return []column{
c.ID, c.AccessComments, c.AccessGate, c.AccessFence, c.AccessLocked, c.AccessDog, c.AccessOther, c.Address, c.AddressCountry, c.AddressPostCode, c.AddressPlace, c.AddressStreet, c.AddressRegion, c.Comments, c.Created, c.H3cell, c.HasAdult, c.HasLarvae, c.HasPupae, c.Location, c.MapZoom, c.OwnerEmail, c.OwnerName, c.OwnerPhone, c.PublicID, c.ReporterEmail, c.ReporterName, c.ReporterPhone, c.Subscribe, c.Status, c.OrganizationID,
c.ID, c.AccessComments, c.AccessGate, c.AccessFence, c.AccessLocked, c.AccessDog, c.AccessOther, c.Address, c.AddressCountry, c.AddressPostCode, c.AddressPlace, c.AddressStreet, c.AddressRegion, c.Comments, c.Created, c.H3cell, c.HasAdult, c.HasLarvae, c.HasPupae, c.Location, c.MapZoom, c.OwnerEmail, c.OwnerName, c.OwnerPhone, c.PublicID, c.ReporterEmail, c.ReporterName, c.ReporterPhone, c.Status, c.OrganizationID, c.HasBackyardPermission, c.IsReporterConfidential, c.IsReporterOwner,
}
}

6
db/factory/bobfactory_main.bob.go
View file

@ -3050,7 +3050,7 @@ func (f *Factory) FromExistingPublicreportPool(m *models.PublicreportPool) *Publ
o.HasLarvae = func() bool { return m.HasLarvae }
o.HasPupae = func() bool { return m.HasPupae }
o.Location = func() null.Val[string] { return m.Location }
o.MapZoom = func() float64 { return m.MapZoom }
o.MapZoom = func() float32 { return m.MapZoom }
o.OwnerEmail = func() string { return m.OwnerEmail }
o.OwnerName = func() string { return m.OwnerName }
o.OwnerPhone = func() string { return m.OwnerPhone }
@ -3058,9 +3058,11 @@ func (f *Factory) FromExistingPublicreportPool(m *models.PublicreportPool) *Publ
o.ReporterEmail = func() string { return m.ReporterEmail }
o.ReporterName = func() string { return m.ReporterName }
o.ReporterPhone = func() string { return m.ReporterPhone }
o.Subscribe = func() bool { return m.Subscribe }
o.Status = func() enums.PublicreportReportstatustype { return m.Status }
o.OrganizationID = func() null.Val[int32] { return m.OrganizationID }
o.HasBackyardPermission = func() bool { return m.HasBackyardPermission }
o.IsReporterConfidential = func() bool { return m.IsReporterConfidential }
o.IsReporterOwner = func() bool { return m.IsReporterOwner }
ctx := context.Background()
if m.R.Organization != nil {

248
db/factory/publicreport.pool.bob.go
View file

@ -38,37 +38,39 @@ func (mods PublicreportPoolModSlice) Apply(ctx context.Context, n *PublicreportP
// PublicreportPoolTemplate is an object representing the database table.
// all columns are optional and should be set by mods
type PublicreportPoolTemplate struct {
ID func() int32
AccessComments func() string
AccessGate func() bool
AccessFence func() bool
AccessLocked func() bool
AccessDog func() bool
AccessOther func() bool
Address func() string
AddressCountry func() string
AddressPostCode func() string
AddressPlace func() string
AddressStreet func() string
AddressRegion func() string
Comments func() string
Created func() time.Time
H3cell func() null.Val[string]
HasAdult func() bool
HasLarvae func() bool
HasPupae func() bool
Location func() null.Val[string]
MapZoom func() float64
OwnerEmail func() string
OwnerName func() string
OwnerPhone func() string
PublicID func() string
ReporterEmail func() string
ReporterName func() string
ReporterPhone func() string
Subscribe func() bool
Status func() enums.PublicreportReportstatustype
OrganizationID func() null.Val[int32]
ID func() int32
AccessComments func() string
AccessGate func() bool
AccessFence func() bool
AccessLocked func() bool
AccessDog func() bool
AccessOther func() bool
Address func() string
AddressCountry func() string
AddressPostCode func() string
AddressPlace func() string
AddressStreet func() string
AddressRegion func() string
Comments func() string
Created func() time.Time
H3cell func() null.Val[string]
HasAdult func() bool
HasLarvae func() bool
HasPupae func() bool
Location func() null.Val[string]
MapZoom func() float32
OwnerEmail func() string
OwnerName func() string
OwnerPhone func() string
PublicID func() string
ReporterEmail func() string
ReporterName func() string
ReporterPhone func() string
Status func() enums.PublicreportReportstatustype
OrganizationID func() null.Val[int32]
HasBackyardPermission func() bool
IsReporterConfidential func() bool
IsReporterOwner func() bool
r publicreportPoolR
f *Factory
@ -236,10 +238,6 @@ func (o PublicreportPoolTemplate) BuildSetter() *models.PublicreportPoolSetter {
val := o.ReporterPhone()
m.ReporterPhone = omit.From(val)
}
if o.Subscribe != nil {
val := o.Subscribe()
m.Subscribe = omit.From(val)
}
if o.Status != nil {
val := o.Status()
m.Status = omit.From(val)
@ -248,6 +246,18 @@ func (o PublicreportPoolTemplate) BuildSetter() *models.PublicreportPoolSetter {
val := o.OrganizationID()
m.OrganizationID = omitnull.FromNull(val)
}
if o.HasBackyardPermission != nil {
val := o.HasBackyardPermission()
m.HasBackyardPermission = omit.From(val)
}
if o.IsReporterConfidential != nil {
val := o.IsReporterConfidential()
m.IsReporterConfidential = omit.From(val)
}
if o.IsReporterOwner != nil {
val := o.IsReporterOwner()
m.IsReporterOwner = omit.From(val)
}
return m
}
@ -354,15 +364,21 @@ func (o PublicreportPoolTemplate) Build() *models.PublicreportPool {
if o.ReporterPhone != nil {
m.ReporterPhone = o.ReporterPhone()
}
if o.Subscribe != nil {
m.Subscribe = o.Subscribe()
}
if o.Status != nil {
m.Status = o.Status()
}
if o.OrganizationID != nil {
m.OrganizationID = o.OrganizationID()
}
if o.HasBackyardPermission != nil {
m.HasBackyardPermission = o.HasBackyardPermission()
}
if o.IsReporterConfidential != nil {
m.IsReporterConfidential = o.IsReporterConfidential()
}
if o.IsReporterOwner != nil {
m.IsReporterOwner = o.IsReporterOwner()
}
o.setModelRels(m)
@ -452,7 +468,7 @@ func ensureCreatablePublicreportPool(m *models.PublicreportPoolSetter) {
m.HasPupae = omit.From(val)
}
if !(m.MapZoom.IsValue()) {
val := random_float64(nil)
val := random_float32(nil)
m.MapZoom = omit.From(val)
}
if !(m.OwnerEmail.IsValue()) {
@ -483,14 +499,22 @@ func ensureCreatablePublicreportPool(m *models.PublicreportPoolSetter) {
val := random_string(nil)
m.ReporterPhone = omit.From(val)
}
if !(m.Subscribe.IsValue()) {
val := random_bool(nil)
m.Subscribe = omit.From(val)
}
if !(m.Status.IsValue()) {
val := random_enums_PublicreportReportstatustype(nil)
m.Status = omit.From(val)
}
if !(m.HasBackyardPermission.IsValue()) {
val := random_bool(nil)
m.HasBackyardPermission = omit.From(val)
}
if !(m.IsReporterConfidential.IsValue()) {
val := random_bool(nil)
m.IsReporterConfidential = omit.From(val)
}
if !(m.IsReporterOwner.IsValue()) {
val := random_bool(nil)
m.IsReporterOwner = omit.From(val)
}
}
// insertOptRels creates and inserts any optional the relationships on *models.PublicreportPool
@ -658,9 +682,11 @@ func (m publicreportPoolMods) RandomizeAllColumns(f *faker.Faker) PublicreportPo
PublicreportPoolMods.RandomReporterEmail(f),
PublicreportPoolMods.RandomReporterName(f),
PublicreportPoolMods.RandomReporterPhone(f),
PublicreportPoolMods.RandomSubscribe(f),
PublicreportPoolMods.RandomStatus(f),
PublicreportPoolMods.RandomOrganizationID(f),
PublicreportPoolMods.RandomHasBackyardPermission(f),
PublicreportPoolMods.RandomIsReporterConfidential(f),
PublicreportPoolMods.RandomIsReporterOwner(f),
}
}
@ -1329,14 +1355,14 @@ func (m publicreportPoolMods) RandomLocationNotNull(f *faker.Faker) Publicreport
}
// Set the model columns to this value
func (m publicreportPoolMods) MapZoom(val float64) PublicreportPoolMod {
func (m publicreportPoolMods) MapZoom(val float32) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.MapZoom = func() float64 { return val }
o.MapZoom = func() float32 { return val }
})
}
// Set the Column from the function
func (m publicreportPoolMods) MapZoomFunc(f func() float64) PublicreportPoolMod {
func (m publicreportPoolMods) MapZoomFunc(f func() float32) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.MapZoom = f
})
@ -1353,8 +1379,8 @@ func (m publicreportPoolMods) UnsetMapZoom() PublicreportPoolMod {
// if faker is nil, a default faker is used
func (m publicreportPoolMods) RandomMapZoom(f *faker.Faker) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.MapZoom = func() float64 {
return random_float64(f)
o.MapZoom = func() float32 {
return random_float32(f)
}
})
}
@ -1576,37 +1602,6 @@ func (m publicreportPoolMods) RandomReporterPhone(f *faker.Faker) PublicreportPo
})
}
// Set the model columns to this value
func (m publicreportPoolMods) Subscribe(val bool) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.Subscribe = func() bool { return val }
})
}
// Set the Column from the function
func (m publicreportPoolMods) SubscribeFunc(f func() bool) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.Subscribe = f
})
}
// Clear any values for the column
func (m publicreportPoolMods) UnsetSubscribe() PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.Subscribe = nil
})
}
// Generates a random value for the column using the given faker
// if faker is nil, a default faker is used
func (m publicreportPoolMods) RandomSubscribe(f *faker.Faker) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.Subscribe = func() bool {
return random_bool(f)
}
})
}
// Set the model columns to this value
func (m publicreportPoolMods) Status(val enums.PublicreportReportstatustype) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
@ -1691,6 +1686,99 @@ func (m publicreportPoolMods) RandomOrganizationIDNotNull(f *faker.Faker) Public
})
}
// Set the model columns to this value
func (m publicreportPoolMods) HasBackyardPermission(val bool) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.HasBackyardPermission = func() bool { return val }
})
}
// Set the Column from the function
func (m publicreportPoolMods) HasBackyardPermissionFunc(f func() bool) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.HasBackyardPermission = f
})
}
// Clear any values for the column
func (m publicreportPoolMods) UnsetHasBackyardPermission() PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.HasBackyardPermission = nil
})
}
// Generates a random value for the column using the given faker
// if faker is nil, a default faker is used
func (m publicreportPoolMods) RandomHasBackyardPermission(f *faker.Faker) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.HasBackyardPermission = func() bool {
return random_bool(f)
}
})
}
// Set the model columns to this value
func (m publicreportPoolMods) IsReporterConfidential(val bool) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.IsReporterConfidential = func() bool { return val }
})
}
// Set the Column from the function
func (m publicreportPoolMods) IsReporterConfidentialFunc(f func() bool) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.IsReporterConfidential = f
})
}
// Clear any values for the column
func (m publicreportPoolMods) UnsetIsReporterConfidential() PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.IsReporterConfidential = nil
})
}
// Generates a random value for the column using the given faker
// if faker is nil, a default faker is used
func (m publicreportPoolMods) RandomIsReporterConfidential(f *faker.Faker) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.IsReporterConfidential = func() bool {
return random_bool(f)
}
})
}
// Set the model columns to this value
func (m publicreportPoolMods) IsReporterOwner(val bool) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.IsReporterOwner = func() bool { return val }
})
}
// Set the Column from the function
func (m publicreportPoolMods) IsReporterOwnerFunc(f func() bool) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.IsReporterOwner = f
})
}
// Clear any values for the column
func (m publicreportPoolMods) UnsetIsReporterOwner() PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.IsReporterOwner = nil
})
}
// Generates a random value for the column using the given faker
// if faker is nil, a default faker is used
func (m publicreportPoolMods) RandomIsReporterOwner(f *faker.Faker) PublicreportPoolMod {
return PublicreportPoolModFunc(func(_ context.Context, o *PublicreportPoolTemplate) {
o.IsReporterOwner = func() bool {
return random_bool(f)
}
})
}
func (m publicreportPoolMods) WithParentsCascading() PublicreportPoolMod {
return PublicreportPoolModFunc(func(ctx context.Context, o *PublicreportPoolTemplate) {
if isDone, _ := publicreportPoolWithParentsCascadingCtx.Value(ctx); isDone {

24
db/migrations/00054_water_more_inputs.sql Normal file
View file

@ -0,0 +1,24 @@
-- +goose Up
ALTER TABLE publicreport.pool ADD COLUMN has_backyard_permission BOOLEAN;
ALTER TABLE publicreport.pool ADD COLUMN is_reporter_confidential BOOLEAN;
ALTER TABLE publicreport.pool ADD COLUMN is_reporter_owner BOOLEAN;
UPDATE publicreport.pool SET has_backyard_permission=false;
UPDATE publicreport.pool SET is_reporter_confidential=false;
UPDATE publicreport.pool SET is_reporter_owner=false;
ALTER TABLE publicreport.pool ALTER COLUMN has_backyard_permission SET NOT NULL;
ALTER TABLE publicreport.pool ALTER COLUMN is_reporter_confidential SET NOT NULL;
ALTER TABLE publicreport.pool ALTER COLUMN is_reporter_owner SET NOT NULL;
ALTER TABLE publicreport.pool ALTER COLUMN map_zoom TYPE REAL;
ALTER TABLE publicreport.pool DROP COLUMN subscribe;
-- +goose Down
ALTER TABLE publicreport.pool ADD COLUMN subscribe BOOLEAN;
ALTER TABLE publicreport.pool ALTER COLUMN map_zoom TYPE FLOAT;
ALTER TABLE publicreport.pool DROP COLUMN has_backyard_permission;
ALTER TABLE publicreport.pool DROP COLUMN is_reporter_confidential;
ALTER TABLE publicreport.pool DROP COLUMN is_reporter_owner;

472
db/models/publicreport.pool.bob.go
View file

@ -29,37 +29,39 @@ import (
// PublicreportPool is an object representing the database table.
type PublicreportPool struct {
ID int32 `db:"id,pk" `
AccessComments string `db:"access_comments" `
AccessGate bool `db:"access_gate" `
AccessFence bool `db:"access_fence" `
AccessLocked bool `db:"access_locked" `
AccessDog bool `db:"access_dog" `
AccessOther bool `db:"access_other" `
Address string `db:"address" `
AddressCountry string `db:"address_country" `
AddressPostCode string `db:"address_post_code" `
AddressPlace string `db:"address_place" `
AddressStreet string `db:"address_street" `
AddressRegion string `db:"address_region" `
Comments string `db:"comments" `
Created time.Time `db:"created" `
H3cell null.Val[string] `db:"h3cell" `
HasAdult bool `db:"has_adult" `
HasLarvae bool `db:"has_larvae" `
HasPupae bool `db:"has_pupae" `
Location null.Val[string] `db:"location" `
MapZoom float64 `db:"map_zoom" `
OwnerEmail string `db:"owner_email" `
OwnerName string `db:"owner_name" `
OwnerPhone string `db:"owner_phone" `
PublicID string `db:"public_id" `
ReporterEmail string `db:"reporter_email" `
ReporterName string `db:"reporter_name" `
ReporterPhone string `db:"reporter_phone" `
Subscribe bool `db:"subscribe" `
Status enums.PublicreportReportstatustype `db:"status" `
OrganizationID null.Val[int32] `db:"organization_id" `
ID int32 `db:"id,pk" `
AccessComments string `db:"access_comments" `
AccessGate bool `db:"access_gate" `
AccessFence bool `db:"access_fence" `
AccessLocked bool `db:"access_locked" `
AccessDog bool `db:"access_dog" `
AccessOther bool `db:"access_other" `
Address string `db:"address" `
AddressCountry string `db:"address_country" `
AddressPostCode string `db:"address_post_code" `
AddressPlace string `db:"address_place" `
AddressStreet string `db:"address_street" `
AddressRegion string `db:"address_region" `
Comments string `db:"comments" `
Created time.Time `db:"created" `
H3cell null.Val[string] `db:"h3cell" `
HasAdult bool `db:"has_adult" `
HasLarvae bool `db:"has_larvae" `
HasPupae bool `db:"has_pupae" `
Location null.Val[string] `db:"location" `
MapZoom float32 `db:"map_zoom" `
OwnerEmail string `db:"owner_email" `
OwnerName string `db:"owner_name" `
OwnerPhone string `db:"owner_phone" `
PublicID string `db:"public_id" `
ReporterEmail string `db:"reporter_email" `
ReporterName string `db:"reporter_name" `
ReporterPhone string `db:"reporter_phone" `
Status enums.PublicreportReportstatustype `db:"status" `
OrganizationID null.Val[int32] `db:"organization_id" `
HasBackyardPermission bool `db:"has_backyard_permission" `
IsReporterConfidential bool `db:"is_reporter_confidential" `
IsReporterOwner bool `db:"is_reporter_owner" `
R publicreportPoolR `db:"-" `
@ -85,77 +87,81 @@ type publicreportPoolR struct {
func buildPublicreportPoolColumns(alias string) publicreportPoolColumns {
return publicreportPoolColumns{
ColumnsExpr: expr.NewColumnsExpr(
"id", "access_comments", "access_gate", "access_fence", "access_locked", "access_dog", "access_other", "address", "address_country", "address_post_code", "address_place", "address_street", "address_region", "comments", "created", "h3cell", "has_adult", "has_larvae", "has_pupae", "location", "map_zoom", "owner_email", "owner_name", "owner_phone", "public_id", "reporter_email", "reporter_name", "reporter_phone", "subscribe", "status", "organization_id",
"id", "access_comments", "access_gate", "access_fence", "access_locked", "access_dog", "access_other", "address", "address_country", "address_post_code", "address_place", "address_street", "address_region", "comments", "created", "h3cell", "has_adult", "has_larvae", "has_pupae", "location", "map_zoom", "owner_email", "owner_name", "owner_phone", "public_id", "reporter_email", "reporter_name", "reporter_phone", "status", "organization_id", "has_backyard_permission", "is_reporter_confidential", "is_reporter_owner",
).WithParent("publicreport.pool"),
tableAlias: alias,
ID: psql.Quote(alias, "id"),
AccessComments: psql.Quote(alias, "access_comments"),
AccessGate: psql.Quote(alias, "access_gate"),
AccessFence: psql.Quote(alias, "access_fence"),
AccessLocked: psql.Quote(alias, "access_locked"),
AccessDog: psql.Quote(alias, "access_dog"),
AccessOther: psql.Quote(alias, "access_other"),
Address: psql.Quote(alias, "address"),
AddressCountry: psql.Quote(alias, "address_country"),
AddressPostCode: psql.Quote(alias, "address_post_code"),
AddressPlace: psql.Quote(alias, "address_place"),
AddressStreet: psql.Quote(alias, "address_street"),
AddressRegion: psql.Quote(alias, "address_region"),
Comments: psql.Quote(alias, "comments"),
Created: psql.Quote(alias, "created"),
H3cell: psql.Quote(alias, "h3cell"),
HasAdult: psql.Quote(alias, "has_adult"),
HasLarvae: psql.Quote(alias, "has_larvae"),
HasPupae: psql.Quote(alias, "has_pupae"),
Location: psql.Quote(alias, "location"),
MapZoom: psql.Quote(alias, "map_zoom"),
OwnerEmail: psql.Quote(alias, "owner_email"),
OwnerName: psql.Quote(alias, "owner_name"),
OwnerPhone: psql.Quote(alias, "owner_phone"),
PublicID: psql.Quote(alias, "public_id"),
ReporterEmail: psql.Quote(alias, "reporter_email"),
ReporterName: psql.Quote(alias, "reporter_name"),
ReporterPhone: psql.Quote(alias, "reporter_phone"),
Subscribe: psql.Quote(alias, "subscribe"),
Status: psql.Quote(alias, "status"),
OrganizationID: psql.Quote(alias, "organization_id"),
tableAlias: alias,
ID: psql.Quote(alias, "id"),
AccessComments: psql.Quote(alias, "access_comments"),
AccessGate: psql.Quote(alias, "access_gate"),
AccessFence: psql.Quote(alias, "access_fence"),
AccessLocked: psql.Quote(alias, "access_locked"),
AccessDog: psql.Quote(alias, "access_dog"),
AccessOther: psql.Quote(alias, "access_other"),
Address: psql.Quote(alias, "address"),
AddressCountry: psql.Quote(alias, "address_country"),
AddressPostCode: psql.Quote(alias, "address_post_code"),
AddressPlace: psql.Quote(alias, "address_place"),
AddressStreet: psql.Quote(alias, "address_street"),
AddressRegion: psql.Quote(alias, "address_region"),
Comments: psql.Quote(alias, "comments"),
Created: psql.Quote(alias, "created"),
H3cell: psql.Quote(alias, "h3cell"),
HasAdult: psql.Quote(alias, "has_adult"),
HasLarvae: psql.Quote(alias, "has_larvae"),
HasPupae: psql.Quote(alias, "has_pupae"),
Location: psql.Quote(alias, "location"),
MapZoom: psql.Quote(alias, "map_zoom"),
OwnerEmail: psql.Quote(alias, "owner_email"),
OwnerName: psql.Quote(alias, "owner_name"),
OwnerPhone: psql.Quote(alias, "owner_phone"),
PublicID: psql.Quote(alias, "public_id"),
ReporterEmail: psql.Quote(alias, "reporter_email"),
ReporterName: psql.Quote(alias, "reporter_name"),
ReporterPhone: psql.Quote(alias, "reporter_phone"),
Status: psql.Quote(alias, "status"),
OrganizationID: psql.Quote(alias, "organization_id"),
HasBackyardPermission: psql.Quote(alias, "has_backyard_permission"),
IsReporterConfidential: psql.Quote(alias, "is_reporter_confidential"),
IsReporterOwner: psql.Quote(alias, "is_reporter_owner"),
}
}
type publicreportPoolColumns struct {
expr.ColumnsExpr
tableAlias string
ID psql.Expression
AccessComments psql.Expression
AccessGate psql.Expression
AccessFence psql.Expression
AccessLocked psql.Expression
AccessDog psql.Expression
AccessOther psql.Expression
Address psql.Expression
AddressCountry psql.Expression
AddressPostCode psql.Expression
AddressPlace psql.Expression
AddressStreet psql.Expression
AddressRegion psql.Expression
Comments psql.Expression
Created psql.Expression
H3cell psql.Expression
HasAdult psql.Expression
HasLarvae psql.Expression
HasPupae psql.Expression
Location psql.Expression
MapZoom psql.Expression
OwnerEmail psql.Expression
OwnerName psql.Expression
OwnerPhone psql.Expression
PublicID psql.Expression
ReporterEmail psql.Expression
ReporterName psql.Expression
ReporterPhone psql.Expression
Subscribe psql.Expression
Status psql.Expression
OrganizationID psql.Expression
tableAlias string
ID psql.Expression
AccessComments psql.Expression
AccessGate psql.Expression
AccessFence psql.Expression
AccessLocked psql.Expression
AccessDog psql.Expression
AccessOther psql.Expression
Address psql.Expression
AddressCountry psql.Expression
AddressPostCode psql.Expression
AddressPlace psql.Expression
AddressStreet psql.Expression
AddressRegion psql.Expression
Comments psql.Expression
Created psql.Expression
H3cell psql.Expression
HasAdult psql.Expression
HasLarvae psql.Expression
HasPupae psql.Expression
Location psql.Expression
MapZoom psql.Expression
OwnerEmail psql.Expression
OwnerName psql.Expression
OwnerPhone psql.Expression
PublicID psql.Expression
ReporterEmail psql.Expression
ReporterName psql.Expression
ReporterPhone psql.Expression
Status psql.Expression
OrganizationID psql.Expression
HasBackyardPermission psql.Expression
IsReporterConfidential psql.Expression
IsReporterOwner psql.Expression
}
func (c publicreportPoolColumns) Alias() string {
@ -170,41 +176,43 @@ func (publicreportPoolColumns) AliasedAs(alias string) publicreportPoolColumns {
// All values are optional, and do not have to be set
// Generated columns are not included
type PublicreportPoolSetter struct {
ID omit.Val[int32] `db:"id,pk" `
AccessComments omit.Val[string] `db:"access_comments" `
AccessGate omit.Val[bool] `db:"access_gate" `
AccessFence omit.Val[bool] `db:"access_fence" `
AccessLocked omit.Val[bool] `db:"access_locked" `
AccessDog omit.Val[bool] `db:"access_dog" `
AccessOther omit.Val[bool] `db:"access_other" `
Address omit.Val[string] `db:"address" `
AddressCountry omit.Val[string] `db:"address_country" `
AddressPostCode omit.Val[string] `db:"address_post_code" `
AddressPlace omit.Val[string] `db:"address_place" `
AddressStreet omit.Val[string] `db:"address_street" `
AddressRegion omit.Val[string] `db:"address_region" `
Comments omit.Val[string] `db:"comments" `
Created omit.Val[time.Time] `db:"created" `
H3cell omitnull.Val[string] `db:"h3cell" `
HasAdult omit.Val[bool] `db:"has_adult" `
HasLarvae omit.Val[bool] `db:"has_larvae" `
HasPupae omit.Val[bool] `db:"has_pupae" `
Location omitnull.Val[string] `db:"location" `
MapZoom omit.Val[float64] `db:"map_zoom" `
OwnerEmail omit.Val[string] `db:"owner_email" `
OwnerName omit.Val[string] `db:"owner_name" `
OwnerPhone omit.Val[string] `db:"owner_phone" `
PublicID omit.Val[string] `db:"public_id" `
ReporterEmail omit.Val[string] `db:"reporter_email" `
ReporterName omit.Val[string] `db:"reporter_name" `
ReporterPhone omit.Val[string] `db:"reporter_phone" `
Subscribe omit.Val[bool] `db:"subscribe" `
Status omit.Val[enums.PublicreportReportstatustype] `db:"status" `
OrganizationID omitnull.Val[int32] `db:"organization_id" `
ID omit.Val[int32] `db:"id,pk" `
AccessComments omit.Val[string] `db:"access_comments" `
AccessGate omit.Val[bool] `db:"access_gate" `
AccessFence omit.Val[bool] `db:"access_fence" `
AccessLocked omit.Val[bool] `db:"access_locked" `
AccessDog omit.Val[bool] `db:"access_dog" `
AccessOther omit.Val[bool] `db:"access_other" `
Address omit.Val[string] `db:"address" `
AddressCountry omit.Val[string] `db:"address_country" `
AddressPostCode omit.Val[string] `db:"address_post_code" `
AddressPlace omit.Val[string] `db:"address_place" `
AddressStreet omit.Val[string] `db:"address_street" `
AddressRegion omit.Val[string] `db:"address_region" `
Comments omit.Val[string] `db:"comments" `
Created omit.Val[time.Time] `db:"created" `
H3cell omitnull.Val[string] `db:"h3cell" `
HasAdult omit.Val[bool] `db:"has_adult" `
HasLarvae omit.Val[bool] `db:"has_larvae" `
HasPupae omit.Val[bool] `db:"has_pupae" `
Location omitnull.Val[string] `db:"location" `
MapZoom omit.Val[float32] `db:"map_zoom" `
OwnerEmail omit.Val[string] `db:"owner_email" `
OwnerName omit.Val[string] `db:"owner_name" `
OwnerPhone omit.Val[string] `db:"owner_phone" `
PublicID omit.Val[string] `db:"public_id" `
ReporterEmail omit.Val[string] `db:"reporter_email" `
ReporterName omit.Val[string] `db:"reporter_name" `
ReporterPhone omit.Val[string] `db:"reporter_phone" `
Status omit.Val[enums.PublicreportReportstatustype] `db:"status" `
OrganizationID omitnull.Val[int32] `db:"organization_id" `
HasBackyardPermission omit.Val[bool] `db:"has_backyard_permission" `
IsReporterConfidential omit.Val[bool] `db:"is_reporter_confidential" `
IsReporterOwner omit.Val[bool] `db:"is_reporter_owner" `
}
func (s PublicreportPoolSetter) SetColumns() []string {
vals := make([]string, 0, 31)
vals := make([]string, 0, 33)
if s.ID.IsValue() {
vals = append(vals, "id")
}
@ -289,15 +297,21 @@ func (s PublicreportPoolSetter) SetColumns() []string {
if s.ReporterPhone.IsValue() {
vals = append(vals, "reporter_phone")
}
if s.Subscribe.IsValue() {
vals = append(vals, "subscribe")
}
if s.Status.IsValue() {
vals = append(vals, "status")
}
if !s.OrganizationID.IsUnset() {
vals = append(vals, "organization_id")
}
if s.HasBackyardPermission.IsValue() {
vals = append(vals, "has_backyard_permission")
}
if s.IsReporterConfidential.IsValue() {
vals = append(vals, "is_reporter_confidential")
}
if s.IsReporterOwner.IsValue() {
vals = append(vals, "is_reporter_owner")
}
return vals
}
@ -386,15 +400,21 @@ func (s PublicreportPoolSetter) Overwrite(t *PublicreportPool) {
if s.ReporterPhone.IsValue() {
t.ReporterPhone = s.ReporterPhone.MustGet()
}
if s.Subscribe.IsValue() {
t.Subscribe = s.Subscribe.MustGet()
}
if s.Status.IsValue() {
t.Status = s.Status.MustGet()
}
if !s.OrganizationID.IsUnset() {
t.OrganizationID = s.OrganizationID.MustGetNull()
}
if s.HasBackyardPermission.IsValue() {
t.HasBackyardPermission = s.HasBackyardPermission.MustGet()
}
if s.IsReporterConfidential.IsValue() {
t.IsReporterConfidential = s.IsReporterConfidential.MustGet()
}
if s.IsReporterOwner.IsValue() {
t.IsReporterOwner = s.IsReporterOwner.MustGet()
}
}
func (s *PublicreportPoolSetter) Apply(q *dialect.InsertQuery) {
@ -403,7 +423,7 @@ func (s *PublicreportPoolSetter) Apply(q *dialect.InsertQuery) {
})
q.AppendValues(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
vals := make([]bob.Expression, 31)
vals := make([]bob.Expression, 33)
if s.ID.IsValue() {
vals[0] = psql.Arg(s.ID.MustGet())
} else {
@ -572,24 +592,36 @@ func (s *PublicreportPoolSetter) Apply(q *dialect.InsertQuery) {
vals[27] = psql.Raw("DEFAULT")
}
if s.Subscribe.IsValue() {
vals[28] = psql.Arg(s.Subscribe.MustGet())
if s.Status.IsValue() {
vals[28] = psql.Arg(s.Status.MustGet())
} else {
vals[28] = psql.Raw("DEFAULT")
}
if s.Status.IsValue() {
vals[29] = psql.Arg(s.Status.MustGet())
if !s.OrganizationID.IsUnset() {
vals[29] = psql.Arg(s.OrganizationID.MustGetNull())
} else {
vals[29] = psql.Raw("DEFAULT")
}
if !s.OrganizationID.IsUnset() {
vals[30] = psql.Arg(s.OrganizationID.MustGetNull())
if s.HasBackyardPermission.IsValue() {
vals[30] = psql.Arg(s.HasBackyardPermission.MustGet())
} else {
vals[30] = psql.Raw("DEFAULT")
}
if s.IsReporterConfidential.IsValue() {
vals[31] = psql.Arg(s.IsReporterConfidential.MustGet())
} else {
vals[31] = psql.Raw("DEFAULT")
}
if s.IsReporterOwner.IsValue() {
vals[32] = psql.Arg(s.IsReporterOwner.MustGet())
} else {
vals[32] = psql.Raw("DEFAULT")
}
return bob.ExpressSlice(ctx, w, d, start, vals, "", ", ", "")
}))
}
@ -599,7 +631,7 @@ func (s PublicreportPoolSetter) UpdateMod() bob.Mod[*dialect.UpdateQuery] {
}
func (s PublicreportPoolSetter) Expressions(prefix ...string) []bob.Expression {
exprs := make([]bob.Expression, 0, 31)
exprs := make([]bob.Expression, 0, 33)
if s.ID.IsValue() {
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
@ -797,13 +829,6 @@ func (s PublicreportPoolSetter) Expressions(prefix ...string) []bob.Expression {
}})
}
if s.Subscribe.IsValue() {
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
psql.Quote(append(prefix, "subscribe")...),
psql.Arg(s.Subscribe),
}})
}
if s.Status.IsValue() {
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
psql.Quote(append(prefix, "status")...),
@ -818,6 +843,27 @@ func (s PublicreportPoolSetter) Expressions(prefix ...string) []bob.Expression {
}})
}
if s.HasBackyardPermission.IsValue() {
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
psql.Quote(append(prefix, "has_backyard_permission")...),
psql.Arg(s.HasBackyardPermission),
}})
}
if s.IsReporterConfidential.IsValue() {
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
psql.Quote(append(prefix, "is_reporter_confidential")...),
psql.Arg(s.IsReporterConfidential),
}})
}
if s.IsReporterOwner.IsValue() {
exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
psql.Quote(append(prefix, "is_reporter_owner")...),
psql.Arg(s.IsReporterOwner),
}})
}
return exprs
}
@ -1211,37 +1257,39 @@ func (publicreportPool0 *PublicreportPool) AttachImages(ctx context.Context, exe
}
type publicreportPoolWhere[Q psql.Filterable] struct {
ID psql.WhereMod[Q, int32]
AccessComments psql.WhereMod[Q, string]
AccessGate psql.WhereMod[Q, bool]
AccessFence psql.WhereMod[Q, bool]
AccessLocked psql.WhereMod[Q, bool]
AccessDog psql.WhereMod[Q, bool]
AccessOther psql.WhereMod[Q, bool]
Address psql.WhereMod[Q, string]
AddressCountry psql.WhereMod[Q, string]
AddressPostCode psql.WhereMod[Q, string]
AddressPlace psql.WhereMod[Q, string]
AddressStreet psql.WhereMod[Q, string]
AddressRegion psql.WhereMod[Q, string]
Comments psql.WhereMod[Q, string]
Created psql.WhereMod[Q, time.Time]
H3cell psql.WhereNullMod[Q, string]
HasAdult psql.WhereMod[Q, bool]
HasLarvae psql.WhereMod[Q, bool]
HasPupae psql.WhereMod[Q, bool]
Location psql.WhereNullMod[Q, string]
MapZoom psql.WhereMod[Q, float64]
OwnerEmail psql.WhereMod[Q, string]
OwnerName psql.WhereMod[Q, string]
OwnerPhone psql.WhereMod[Q, string]
PublicID psql.WhereMod[Q, string]
ReporterEmail psql.WhereMod[Q, string]
ReporterName psql.WhereMod[Q, string]
ReporterPhone psql.WhereMod[Q, string]
Subscribe psql.WhereMod[Q, bool]
Status psql.WhereMod[Q, enums.PublicreportReportstatustype]
OrganizationID psql.WhereNullMod[Q, int32]
ID psql.WhereMod[Q, int32]
AccessComments psql.WhereMod[Q, string]
AccessGate psql.WhereMod[Q, bool]
AccessFence psql.WhereMod[Q, bool]
AccessLocked psql.WhereMod[Q, bool]
AccessDog psql.WhereMod[Q, bool]
AccessOther psql.WhereMod[Q, bool]
Address psql.WhereMod[Q, string]
AddressCountry psql.WhereMod[Q, string]
AddressPostCode psql.WhereMod[Q, string]
AddressPlace psql.WhereMod[Q, string]
AddressStreet psql.WhereMod[Q, string]
AddressRegion psql.WhereMod[Q, string]
Comments psql.WhereMod[Q, string]
Created psql.WhereMod[Q, time.Time]
H3cell psql.WhereNullMod[Q, string]
HasAdult psql.WhereMod[Q, bool]
HasLarvae psql.WhereMod[Q, bool]
HasPupae psql.WhereMod[Q, bool]
Location psql.WhereNullMod[Q, string]
MapZoom psql.WhereMod[Q, float32]
OwnerEmail psql.WhereMod[Q, string]
OwnerName psql.WhereMod[Q, string]
OwnerPhone psql.WhereMod[Q, string]
PublicID psql.WhereMod[Q, string]
ReporterEmail psql.WhereMod[Q, string]
ReporterName psql.WhereMod[Q, string]
ReporterPhone psql.WhereMod[Q, string]
Status psql.WhereMod[Q, enums.PublicreportReportstatustype]
OrganizationID psql.WhereNullMod[Q, int32]
HasBackyardPermission psql.WhereMod[Q, bool]
IsReporterConfidential psql.WhereMod[Q, bool]
IsReporterOwner psql.WhereMod[Q, bool]
}
func (publicreportPoolWhere[Q]) AliasedAs(alias string) publicreportPoolWhere[Q] {
@ -1250,37 +1298,39 @@ func (publicreportPoolWhere[Q]) AliasedAs(alias string) publicreportPoolWhere[Q]
func buildPublicreportPoolWhere[Q psql.Filterable](cols publicreportPoolColumns) publicreportPoolWhere[Q] {
return publicreportPoolWhere[Q]{
ID: psql.Where[Q, int32](cols.ID),
AccessComments: psql.Where[Q, string](cols.AccessComments),
AccessGate: psql.Where[Q, bool](cols.AccessGate),
AccessFence: psql.Where[Q, bool](cols.AccessFence),
AccessLocked: psql.Where[Q, bool](cols.AccessLocked),
AccessDog: psql.Where[Q, bool](cols.AccessDog),
AccessOther: psql.Where[Q, bool](cols.AccessOther),
Address: psql.Where[Q, string](cols.Address),
AddressCountry: psql.Where[Q, string](cols.AddressCountry),
AddressPostCode: psql.Where[Q, string](cols.AddressPostCode),
AddressPlace: psql.Where[Q, string](cols.AddressPlace),
AddressStreet: psql.Where[Q, string](cols.AddressStreet),
AddressRegion: psql.Where[Q, string](cols.AddressRegion),
Comments: psql.Where[Q, string](cols.Comments),
Created: psql.Where[Q, time.Time](cols.Created),
H3cell: psql.WhereNull[Q, string](cols.H3cell),
HasAdult: psql.Where[Q, bool](cols.HasAdult),
HasLarvae: psql.Where[Q, bool](cols.HasLarvae),
HasPupae: psql.Where[Q, bool](cols.HasPupae),
Location: psql.WhereNull[Q, string](cols.Location),
MapZoom: psql.Where[Q, float64](cols.MapZoom),
OwnerEmail: psql.Where[Q, string](cols.OwnerEmail),
OwnerName: psql.Where[Q, string](cols.OwnerName),
OwnerPhone: psql.Where[Q, string](cols.OwnerPhone),
PublicID: psql.Where[Q, string](cols.PublicID),
ReporterEmail: psql.Where[Q, string](cols.ReporterEmail),
ReporterName: psql.Where[Q, string](cols.ReporterName),
ReporterPhone: psql.Where[Q, string](cols.ReporterPhone),
Subscribe: psql.Where[Q, bool](cols.Subscribe),
Status: psql.Where[Q, enums.PublicreportReportstatustype](cols.Status),
OrganizationID: psql.WhereNull[Q, int32](cols.OrganizationID),
ID: psql.Where[Q, int32](cols.ID),
AccessComments: psql.Where[Q, string](cols.AccessComments),
AccessGate: psql.Where[Q, bool](cols.AccessGate),
AccessFence: psql.Where[Q, bool](cols.AccessFence),
AccessLocked: psql.Where[Q, bool](cols.AccessLocked),
AccessDog: psql.Where[Q, bool](cols.AccessDog),
AccessOther: psql.Where[Q, bool](cols.AccessOther),
Address: psql.Where[Q, string](cols.Address),
AddressCountry: psql.Where[Q, string](cols.AddressCountry),
AddressPostCode: psql.Where[Q, string](cols.AddressPostCode),
AddressPlace: psql.Where[Q, string](cols.AddressPlace),
AddressStreet: psql.Where[Q, string](cols.AddressStreet),
AddressRegion: psql.Where[Q, string](cols.AddressRegion),
Comments: psql.Where[Q, string](cols.Comments),
Created: psql.Where[Q, time.Time](cols.Created),
H3cell: psql.WhereNull[Q, string](cols.H3cell),
HasAdult: psql.Where[Q, bool](cols.HasAdult),
HasLarvae: psql.Where[Q, bool](cols.HasLarvae),
HasPupae: psql.Where[Q, bool](cols.HasPupae),
Location: psql.WhereNull[Q, string](cols.Location),
MapZoom: psql.Where[Q, float32](cols.MapZoom),
OwnerEmail: psql.Where[Q, string](cols.OwnerEmail),
OwnerName: psql.Where[Q, string](cols.OwnerName),
OwnerPhone: psql.Where[Q, string](cols.OwnerPhone),
PublicID: psql.Where[Q, string](cols.PublicID),
ReporterEmail: psql.Where[Q, string](cols.ReporterEmail),
ReporterName: psql.Where[Q, string](cols.ReporterName),
ReporterPhone: psql.Where[Q, string](cols.ReporterPhone),
Status: psql.Where[Q, enums.PublicreportReportstatustype](cols.Status),
OrganizationID: psql.WhereNull[Q, int32](cols.OrganizationID),
HasBackyardPermission: psql.Where[Q, bool](cols.HasBackyardPermission),
IsReporterConfidential: psql.Where[Q, bool](cols.IsReporterConfidential),
IsReporterOwner: psql.Where[Q, bool](cols.IsReporterOwner),
}
}

2
db/sql/publicreport_image_with_json_by_nuisance_id.sql
View file

@ -4,7 +4,7 @@ SELECT
"publicreport.image"."content_type" AS "content_type",
"publicreport.image"."created" AS "created",
"publicreport.image"."location" AS "location",
ST_AsGeoJSON("publicreport.image"."location") AS "location_json",
COALESCE(ST_AsGeoJSON("publicreport.image"."location"), '{}') AS "location_json",
"publicreport.image"."resolution_x" AS "resolution_x",
"publicreport.image"."resolution_y" AS "resolution_y",
"publicreport.image"."storage_uuid" AS "storage_uuid",

112
db/sql/publicreport_image_with_json_by_pool_id.bob.go Normal file
View file

@ -0,0 +1,112 @@
// 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 sql
import (
"context"
_ "embed"
"io"
"iter"
"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/orm"
"github.com/aarondl/opt/null"
"github.com/google/uuid"
"github.com/stephenafamo/scan"
)
//go:embed publicreport_image_with_json_by_pool_id.bob.sql
var formattedQueries_publicreport_image_with_json_by_pool_id string
var publicreportImageWithJSONByPoolIDSQL = formattedQueries_publicreport_image_with_json_by_pool_id[171:975]
type PublicreportImageWithJSONByPoolIDQuery = orm.ModQuery[*dialect.SelectQuery, publicreportImageWithJSONByPoolID, PublicreportImageWithJSONByPoolIDRow, []PublicreportImageWithJSONByPoolIDRow, publicreportImageWithJSONByPoolIDTransformer]
func PublicreportImageWithJSONByPoolID(PoolID int32) *PublicreportImageWithJSONByPoolIDQuery {
var expressionTypArgs publicreportImageWithJSONByPoolID
expressionTypArgs.PoolID = psql.Arg(PoolID)
return &PublicreportImageWithJSONByPoolIDQuery{
Query: orm.Query[publicreportImageWithJSONByPoolID, PublicreportImageWithJSONByPoolIDRow, []PublicreportImageWithJSONByPoolIDRow, publicreportImageWithJSONByPoolIDTransformer]{
ExecQuery: orm.ExecQuery[publicreportImageWithJSONByPoolID]{
BaseQuery: bob.BaseQuery[publicreportImageWithJSONByPoolID]{
Expression: expressionTypArgs,
Dialect: dialect.Dialect,
QueryType: bob.QueryTypeSelect,
},
},
Scanner: func(context.Context, []string) (func(*scan.Row) (any, error), func(any) (PublicreportImageWithJSONByPoolIDRow, error)) {
return func(row *scan.Row) (any, error) {
var t PublicreportImageWithJSONByPoolIDRow
row.ScheduleScanByIndex(0, &t.ID)
row.ScheduleScanByIndex(1, &t.ContentType)
row.ScheduleScanByIndex(2, &t.Created)
row.ScheduleScanByIndex(3, &t.Location)
row.ScheduleScanByIndex(4, &t.LocationJSON)
row.ScheduleScanByIndex(5, &t.ResolutionX)
row.ScheduleScanByIndex(6, &t.ResolutionY)
row.ScheduleScanByIndex(7, &t.StorageUUID)
row.ScheduleScanByIndex(8, &t.StorageSize)
row.ScheduleScanByIndex(9, &t.UploadedFilename)
return &t, nil
}, func(v any) (PublicreportImageWithJSONByPoolIDRow, error) {
return *(v.(*PublicreportImageWithJSONByPoolIDRow)), nil
}
},
},
Mod: bob.ModFunc[*dialect.SelectQuery](func(q *dialect.SelectQuery) {
q.AppendSelect(expressionTypArgs.subExpr(9, 565))
q.SetTable(expressionTypArgs.subExpr(571, 755))
q.AppendWhere(expressionTypArgs.subExpr(763, 803))
}),
}
}
type PublicreportImageWithJSONByPoolIDRow = struct {
ID int32 `db:"id"`
ContentType string `db:"content_type"`
Created time.Time `db:"created"`
Location null.Val[string] `db:"location"`
LocationJSON string `db:"location_json"`
ResolutionX int32 `db:"resolution_x"`
ResolutionY int32 `db:"resolution_y"`
StorageUUID uuid.UUID `db:"storage_uuid"`
StorageSize int64 `db:"storage_size"`
UploadedFilename string `db:"uploaded_filename"`
}
type publicreportImageWithJSONByPoolIDTransformer = bob.SliceTransformer[PublicreportImageWithJSONByPoolIDRow, []PublicreportImageWithJSONByPoolIDRow]
type publicreportImageWithJSONByPoolID struct {
PoolID bob.Expression
}
func (o publicreportImageWithJSONByPoolID) args() iter.Seq[orm.ArgWithPosition] {
return func(yield func(arg orm.ArgWithPosition) bool) {
if !yield(orm.ArgWithPosition{
Name: "poolID",
Start: 801,
Stop: 803,
Expression: o.PoolID,
}) {
return
}
}
}
func (o publicreportImageWithJSONByPoolID) raw(from, to int) string {
return publicreportImageWithJSONByPoolIDSQL[from:to]
}
func (o publicreportImageWithJSONByPoolID) subExpr(from, to int) bob.Expression {
return orm.ArgsToExpression(publicreportImageWithJSONByPoolIDSQL, from, to, o.args())
}
func (o publicreportImageWithJSONByPoolID) WriteSQL(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
return o.subExpr(0, len(publicreportImageWithJSONByPoolIDSQL)).WriteSQL(ctx, w, d, start)
}

18
db/sql/publicreport_image_with_json_by_pool_id.bob.sql Normal file
View file

@ -0,0 +1,18 @@
-- 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.
-- PublicreportImageWithJSONByPoolID
SELECT
"publicreport.image"."id" AS "id",
"publicreport.image"."content_type" AS "content_type",
"publicreport.image"."created" AS "created",
"publicreport.image"."location" AS "location",
COALESCE(ST_AsGeoJSON("publicreport.image"."location"), '{}') AS "location_json",
"publicreport.image"."resolution_x" AS "resolution_x",
"publicreport.image"."resolution_y" AS "resolution_y",
"publicreport.image"."storage_uuid" AS "storage_uuid",
"publicreport.image"."storage_size" AS "storage_size",
"publicreport.image"."uploaded_filename" AS "uploaded_filename"
FROM "publicreport"."image" AS "publicreport.image"
INNER JOIN "publicreport"."pool_image" AS "publicreport.pool_image" ON ("publicreport.image"."id" = "publicreport.pool_image"."image_id")
WHERE ("publicreport.pool_image"."pool_id" = $1);

15
db/sql/publicreport_image_with_json_by_pool_id.sql Normal file
View file

@ -0,0 +1,15 @@
-- PublicreportImageWithJSONByPoolID
SELECT
"publicreport.image"."id" AS "id",
"publicreport.image"."content_type" AS "content_type",
"publicreport.image"."created" AS "created",
"publicreport.image"."location" AS "location",
COALESCE(ST_AsGeoJSON("publicreport.image"."location"), '{}') AS "location_json",
"publicreport.image"."resolution_x" AS "resolution_x",
"publicreport.image"."resolution_y" AS "resolution_y",
"publicreport.image"."storage_uuid" AS "storage_uuid",
"publicreport.image"."storage_size" AS "storage_size",
"publicreport.image"."uploaded_filename" AS "uploaded_filename"
FROM "publicreport"."image" AS "publicreport.image"
INNER JOIN "publicreport"."pool_image" AS "publicreport.pool_image" ON ("publicreport.image"."id" = "publicreport.pool_image"."image_id")
WHERE ("publicreport.pool_image"."pool_id" = $1)

60
rmo/image-upload.go
View file

@ -40,7 +40,7 @@ type ExifCollection struct {
type ImageUpload struct {
Bounds image.Rectangle
ContentType string
Exif ExifCollection
Exif *ExifCollection
Format string
UploadFilesize int
@ -48,7 +48,7 @@ type ImageUpload struct {
UUID uuid.UUID
}
func extractExif(content_type string, file_bytes []byte) (result ExifCollection, err error) {
func extractExif(content_type string, file_bytes []byte) (result *ExifCollection, err error) {
/*
Using "github.com/evanoberholster/imagemeta"
meta, err := imagemeta.Decode(bytes.NewReader(file_bytes))
@ -64,7 +64,10 @@ func extractExif(content_type string, file_bytes []byte) (result ExifCollection,
exif, err := exif.Decode(bytes.NewReader(file_bytes))
if err != nil {
return result, fmt.Errorf("Failed to decode image meta: %w", err)
if err.Error() == "exif: failed to find exif intro marker" {
return nil, nil
}
return nil, fmt.Errorf("Failed to decode image meta: %w", err)
}
lat, lng, _ := exif.LatLong()
result.GPS = &GPS{
@ -86,11 +89,8 @@ func extractImageUpload(headers *multipart.FileHeader) (upload ImageUpload, err
exif, err := extractExif(content_type, file_bytes)
if err != nil {
//return upload, fmt.Errorf("Failed to extract EXIF data: %w", err)
log.Warn().Err(err).Msg("Failed to extract EXIF data")
return upload, fmt.Errorf("Failed to extract EXIF data: %w", err)
}
log.Debug().Float64("lat", exif.GPS.Latitude).Float64("lng", exif.GPS.Longitude).Msg("extracted GPS from exif")
i, format, err := image.Decode(bytes.NewReader(file_bytes))
if err != nil {
return upload, fmt.Errorf("Failed to decode image file: %w", err)
@ -150,30 +150,34 @@ func saveImageUploads(ctx context.Context, tx bob.Tx, uploads []ImageUpload) (mo
}
// TODO: figure out how to do this via the setter...?
if u.Exif.GPS != nil {
_, err = psql.Update(
um.Table("publicreport.image"),
um.SetCol("location").To(fmt.Sprintf("ST_GeometryFromText('Point(%f %f)')", u.Exif.GPS.Longitude, u.Exif.GPS.Latitude)),
um.Where(psql.Quote("id").EQ(psql.Arg(image.ID))),
).Exec(ctx, tx)
}
exif_setters := make([]*models.PublicreportImageExifSetter, 0)
for k, v := range u.Exif.Tags {
exif_setters = append(exif_setters, &models.PublicreportImageExifSetter{
ImageID: omit.From(image.ID),
Name: omit.From(k),
Value: omit.From(v),
})
}
if len(exif_setters) > 0 {
_, err = models.PublicreportImageExifs.Insert(bob.ToMods(exif_setters...)).Exec(ctx, tx)
if err != nil {
return images, fmt.Errorf("Failed to create photo exif records: %w", err)
if u.Exif != nil {
if u.Exif.GPS != nil {
_, err = psql.Update(
um.Table("publicreport.image"),
um.SetCol("location").To(fmt.Sprintf("ST_GeometryFromText('Point(%f %f)')", u.Exif.GPS.Longitude, u.Exif.GPS.Latitude)),
um.Where(psql.Quote("id").EQ(psql.Arg(image.ID))),
).Exec(ctx, tx)
}
exif_setters := make([]*models.PublicreportImageExifSetter, 0)
for k, v := range u.Exif.Tags {
exif_setters = append(exif_setters, &models.PublicreportImageExifSetter{
ImageID: omit.From(image.ID),
Name: omit.From(k),
Value: omit.From(v),
})
}
if len(exif_setters) > 0 {
_, err = models.PublicreportImageExifs.Insert(bob.ToMods(exif_setters...)).Exec(ctx, tx)
if err != nil {
return images, fmt.Errorf("Failed to create photo exif records: %w", err)
}
}
log.Info().Int32("id", image.ID).Int("tags", len(u.Exif.Tags)).Msg("Saved an uploaded file to the database")
} else {
log.Info().Int32("id", image.ID).Int("tags", 0).Msg("Saved an uploaded file without EXIF data")
}
images = append(images, image)
log.Info().Int32("id", image.ID).Int("tags", len(u.Exif.Tags)).Msg("Saved an uploaded file to the database")
}
return images, nil
}

87
rmo/nuisance.go
View file

@ -4,7 +4,6 @@ import (
"fmt"
"net/http"
"slices"
"strconv"
"time"
"github.com/Gleipnir-Technology/bob"
@ -20,6 +19,7 @@ import (
"github.com/aarondl/opt/omit"
"github.com/aarondl/opt/omitnull"
"github.com/rs/zerolog/log"
"github.com/uber/h3-go/v4"
)
type ContentNuisance struct {
@ -97,11 +97,6 @@ func postNuisance(w http.ResponseWriter, r *http.Request) {
address_region := r.PostFormValue("address-region")
address_street := r.PostFormValue("address-street")
duration_str := postFormValueOrNone(r, "duration")
lat := r.FormValue("latitude")
lng := r.FormValue("longitude")
latlng_accuracy_type_str := r.PostFormValue("latlng-accuracy-type")
latlng_accuracy_value_str := r.PostFormValue("latlng-accuracy-value")
map_zoom_str := r.PostFormValue("map-zoom")
source_stagnant := boolFromForm(r, "source-stagnant")
source_container := boolFromForm(r, "source-container")
source_description := r.PostFormValue("source-description")
@ -118,20 +113,14 @@ func postNuisance(w http.ResponseWriter, r *http.Request) {
is_location_garden := false
is_location_pool := false
is_location_other := false
latlng_accuracy_value := float32(0.0)
map_zoom := float32(0.0)
latlng, err := parseLatLng(r)
err = duration.Scan(duration_str)
if err != nil {
log.Warn().Err(err).Str("duration_str", duration_str).Msg("Failed to interpret 'duration'")
}
latlng_accuracy_type := enums.PublicreportAccuracytypeNone
err = latlng_accuracy_type.Scan(latlng_accuracy_type_str)
if err != nil {
log.Warn().Err(err).Str("latlng_accuracy_type_str", latlng_accuracy_type_str).Msg("Failed to parse accuracy type")
}
log.Debug().Strs("source_locations", source_locations).Msg("parsing")
if slices.Contains(source_locations, "backyard") {
is_location_backyard = true
@ -148,31 +137,7 @@ func postNuisance(w http.ResponseWriter, r *http.Request) {
if slices.Contains(source_locations, "pool-area") {
is_location_pool = true
}
log.Debug().Bool("is_location_backyard", is_location_backyard).Bool("is_location_frontyard", is_location_frontyard).Bool("is_location_garden", is_location_garden).Bool("is_location_other", is_location_other).Bool("is_location_pool", is_location_pool).Msg("parsed")
var temp float64
temp, err = strconv.ParseFloat(latlng_accuracy_value_str, 32)
if err != nil {
log.Warn().Err(err).Str("latlng_accuracy_value_str", latlng_accuracy_value_str).Msg("Failed to parse latlng_accuracy_value")
} else {
latlng_accuracy_value = float32(temp)
}
latitude, err := strconv.ParseFloat(lat, 64)
if err != nil {
log.Warn().Err(err).Str("lat", lat).Msg("Failed to parse lat")
}
longitude, err := strconv.ParseFloat(lng, 64)
if err != nil {
log.Warn().Err(err).Str("lng", lng).Msg("Failed to parse lng")
}
temp, err = strconv.ParseFloat(map_zoom_str, 32)
if err != nil {
log.Warn().Err(err).Str("map_zoom_str", map_zoom_str).Msg("Failed to parse map_zoom_str")
} else {
map_zoom = float32(temp)
}
//log.Debug().Bool("is_location_backyard", is_location_backyard).Bool("is_location_frontyard", is_location_frontyard).Bool("is_location_garden", is_location_garden).Bool("is_location_other", is_location_other).Bool("is_location_pool", is_location_pool).Msg("parsed")
public_id, err := report.GenerateReportID()
if err != nil {
@ -198,13 +163,17 @@ func postNuisance(w http.ResponseWriter, r *http.Request) {
respondError(w, "Failed to save image uploads", err, http.StatusInternalServerError)
return
}
organization_id, err := matchDistrict(ctx, longitude, latitude, uploads)
if err != nil {
log.Warn().Err(err).Msg("Failed to match district")
}
c, err := h3utils.GetCell(longitude, latitude, 15)
if err != nil {
respondError(w, "Failedt o get h3 cell", err, http.StatusInternalServerError)
var organization_id *int32
var h3cell h3.Cell
if latlng.Latitude != nil && latlng.Longitude != nil {
organization_id, err = matchDistrict(ctx, *latlng.Longitude, *latlng.Latitude, uploads)
if err != nil {
log.Warn().Err(err).Msg("Failed to match district")
}
h3cell, err = h3utils.GetCell(*latlng.Longitude, *latlng.Latitude, 15)
if err != nil {
respondError(w, "Failedt o get h3 cell", err, http.StatusInternalServerError)
}
}
setter := models.PublicreportNuisanceSetter{
@ -217,17 +186,17 @@ func postNuisance(w http.ResponseWriter, r *http.Request) {
AddressStreet: omit.From(address_street),
Created: omit.From(time.Now()),
Duration: omit.From(duration),
H3cell: omitnull.From(c.String()),
H3cell: omitnull.From(h3cell.String()),
IsLocationBackyard: omit.From(is_location_backyard),
IsLocationFrontyard: omit.From(is_location_frontyard),
IsLocationGarden: omit.From(is_location_garden),
IsLocationOther: omit.From(is_location_other),
IsLocationPool: omit.From(is_location_pool),
LatlngAccuracyType: omit.From(latlng_accuracy_type),
LatlngAccuracyValue: omit.From(latlng_accuracy_value),
LatlngAccuracyType: omit.From(latlng.AccuracyType),
LatlngAccuracyValue: omit.From(latlng.AccuracyValue),
//Location: omitnull.From(fmt.Sprintf("ST_GeometryFromText(Point(%s %s))", longitude, latitude)),
Location: omitnull.FromPtr[string](nil),
MapZoom: omit.From(map_zoom),
MapZoom: omit.From(latlng.MapZoom),
OrganizationID: omitnull.FromPtr(organization_id),
PublicID: omit.From(public_id),
ReporterEmail: omitnull.FromPtr[string](nil),
@ -248,14 +217,16 @@ func postNuisance(w http.ResponseWriter, r *http.Request) {
respondError(w, "Failed to create database record", err, http.StatusInternalServerError)
return
}
_, err = psql.Update(
um.Table("publicreport.nuisance"),
um.SetCol("location").To(fmt.Sprintf("ST_GeometryFromText('Point(%f %f)')", longitude, latitude)),
um.Where(psql.Quote("id").EQ(psql.Arg(nuisance.ID))),
).Exec(ctx, txn)
if err != nil {
respondError(w, "Failed to insert publicreport", err, http.StatusInternalServerError)
return
if latlng.Latitude != nil && latlng.Longitude != nil {
_, err = psql.Update(
um.Table("publicreport.nuisance"),
um.SetCol("location").To(fmt.Sprintf("ST_GeometryFromText('Point(%f %f)')", *latlng.Longitude, *latlng.Latitude)),
um.Where(psql.Quote("id").EQ(psql.Arg(nuisance.ID))),
).Exec(ctx, txn)
if err != nil {
respondError(w, "Failed to insert publicreport", err, http.StatusInternalServerError)
return
}
}
log.Info().Str("public_id", public_id).Int32("id", nuisance.ID).Msg("Created nuisance report")
if len(images) > 0 {

70
rmo/report.go
View file

@ -2,11 +2,14 @@ package rmo
import (
"encoding/json"
"fmt"
"net/http"
"strconv"
"strings"
//"github.com/Gleipnir-Technology/nidus-sync/config"
"github.com/Gleipnir-Technology/nidus-sync/db"
"github.com/Gleipnir-Technology/nidus-sync/db/enums"
"github.com/Gleipnir-Technology/nidus-sync/db/sql"
//"github.com/go-chi/chi/v5"
//"github.com/rs/zerolog/log"
@ -63,3 +66,70 @@ func getReportSuggestion(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Write(jsonBody)
}
type LatLngForm struct {
Latitude *float64
Longitude *float64
MapZoom float32
AccuracyValue float32
AccuracyType enums.PublicreportAccuracytype
}
func parseLatLng(r *http.Request) (LatLngForm, error) {
result := LatLngForm{
AccuracyType: enums.PublicreportAccuracytypeNone,
AccuracyValue: 0.0,
Latitude: nil,
Longitude: nil,
MapZoom: 0.0,
}
latitude_str := r.FormValue("latitude")
longitude_str := r.FormValue("longitude")
latlng_accuracy_type_str := r.PostFormValue("latlng-accuracy-type")
latlng_accuracy_value_str := r.PostFormValue("latlng-accuracy-value")
map_zoom_str := r.PostFormValue("map-zoom")
var err error
if latlng_accuracy_type_str != "" {
err := result.AccuracyType.Scan(latlng_accuracy_type_str)
if err != nil {
return result, fmt.Errorf("Failed to parse accuracy type '%s': %w", latlng_accuracy_type_str, err)
}
}
if latlng_accuracy_value_str != "" {
var t float64
t, err = strconv.ParseFloat(latlng_accuracy_value_str, 32)
if err != nil {
return result, fmt.Errorf("Failed to parse latlng_accuracy_value '%s': %w", latlng_accuracy_value_str, err)
}
result.AccuracyValue = float32(t)
}
if latitude_str != "" {
var t float64
t, err = strconv.ParseFloat(latitude_str, 64)
if err != nil {
return result, fmt.Errorf("Failed to parse latitude '%s': %w", latitude_str, err)
}
result.Latitude = &t
}
if longitude_str != "" {
var t float64
t, err := strconv.ParseFloat(longitude_str, 64)
if err != nil {
return result, fmt.Errorf("Failed to parse longitude '%s': %w", longitude_str, err)
}
result.Longitude = &t
}
if map_zoom_str != "" {
var t float64
t, err = strconv.ParseFloat(map_zoom_str, 32)
if err != nil {
return result, fmt.Errorf("Failed to parse map_zoom_str '%s': %w", map_zoom_str, err)
} else {
result.MapZoom = float32(t)
}
}
return result, nil
}

77
rmo/status.go
View file

@ -17,7 +17,7 @@ import (
"github.com/Gleipnir-Technology/nidus-sync/db/sql"
"github.com/Gleipnir-Technology/nidus-sync/html"
"github.com/go-chi/chi/v5"
"github.com/rs/zerolog/log"
//"github.com/rs/zerolog/log"
"github.com/stephenafamo/scan"
/*
"github.com/Gleipnir-Technology/nidus-sync/db"
@ -203,8 +203,79 @@ func contentFromNuisance(ctx context.Context, report_id string) (result ContentS
return result, err
}
func contentFromPool(ctx context.Context, report_id string) (result ContentStatusByID, err error) {
pool, err := models.PublicreportPools.Query(
models.SelectWhere.PublicreportPools.PublicID.EQ(report_id),
).One(ctx, db.PGInstance.BobDB)
if err != nil {
return result, fmt.Errorf("Failed to query pool %s: %w", report_id, err)
}
images, err := sql.PublicreportImageWithJSONByPoolID(pool.ID).All(ctx, db.PGInstance.BobDB)
if err != nil {
return result, fmt.Errorf("Failed to get images %s: %w", report_id, err)
}
result.Report.ID = report_id
result.Report.Address = pool.Address
result.Report.Created = pool.Created
result.Report.ImageCount = len(images)
result.Report.Status = strings.Title(pool.Status.String())
result.Report.Type = "Mosquito Nuisance"
result.Report.Details = []DetailEntry{
DetailEntry{
Name: "Has a gate that affects access?",
Value: strconv.FormatBool(pool.AccessGate),
},
DetailEntry{
Name: "Has dog that affects access?",
Value: strconv.FormatBool(pool.AccessDog),
},
DetailEntry{
Name: "Has a fence that affects access?",
Value: strconv.FormatBool(pool.AccessFence),
},
DetailEntry{
Name: "Has a locked entrace that affects access?",
Value: strconv.FormatBool(pool.AccessLocked),
},
DetailEntry{
Name: "Reporter observed larvae (wigglers)?",
Value: strconv.FormatBool(pool.HasLarvae),
},
DetailEntry{
Name: "Reporter observed pupae (tumblers)?",
Value: strconv.FormatBool(pool.HasPupae),
},
DetailEntry{
Name: "Reporter observed adult mosquitoes?",
Value: strconv.FormatBool(pool.HasAdult),
},
}
result.Timeline = []TimelineEntry{
TimelineEntry{
At: pool.Created,
Detail: "Initial report was submitted",
Title: "Created",
},
}
type LocationGeoJSON struct {
Location string
}
location, err := bob.One(ctx, db.PGInstance.BobDB, psql.Select(
sm.Columns(
psql.F("ST_AsGeoJSON", "location"),
),
sm.From("publicreport.pool"),
sm.Where(psql.Quote("public_id").EQ(psql.Arg(report_id))),
), scan.SingleColumnMapper[string])
if err != nil {
return result, fmt.Errorf("Failed to query pool %s: %w", report_id, err)
}
result.Report.Location = location
return result, err
}
func contentFromQuick(ctx context.Context, report_id string) (result ContentStatusByID, err error) {
quick, err := models.PublicreportQuicks.Query(
models.SelectWhere.PublicreportQuicks.PublicID.EQ(report_id),
@ -254,6 +325,10 @@ func getStatusByID(w http.ResponseWriter, r *http.Request) {
case "pool":
content, err = contentFromPool(ctx, report_id)
}
if err != nil {
respondError(w, "Failed to generate report content", err, http.StatusInternalServerError)
return
}
content.MapboxToken = config.MapboxToken
content.URL = makeContentURL(nil)
html.RenderOrError(

2
rmo/template/status-by-id.html
View file

@ -98,7 +98,7 @@ document.addEventListener("DOMContentLoaded", onLoad);
</div>
{{range .Report.Details}}
<div class="row">
<div class="col-md-3">
<div class="col-md-4">
<strong>{{.Name}}</strong>
</div>
<div class="col-md-6">

44
rmo/water.go
View file

@ -3,7 +3,6 @@ package rmo
import (
"fmt"
"net/http"
"strconv"
"time"
"github.com/Gleipnir-Technology/bob"
@ -62,11 +61,12 @@ func postWater(w http.ResponseWriter, r *http.Request) {
respondError(w, "Failed to parse form", err, http.StatusBadRequest)
return
}
access_comments := r.FormValue("access-comments")
access_gate := boolFromForm(r, "access-gate")
access_fence := boolFromForm(r, "access-fence")
access_locked := boolFromForm(r, "access-locked")
access_dog := boolFromForm(r, "access-dog")
access_fence := boolFromForm(r, "access-fence")
access_gate := boolFromForm(r, "access-gate")
access_locked := boolFromForm(r, "access-locked")
access_other := boolFromForm(r, "access-other")
address := r.FormValue("address")
address_country := r.FormValue("address-country")
@ -76,20 +76,18 @@ func postWater(w http.ResponseWriter, r *http.Request) {
address_street := r.FormValue("address-street")
comments := r.FormValue("comments")
has_adult := boolFromForm(r, "has-adult")
has_backyard_permission := boolFromForm(r, "backyard-permission")
has_larvae := boolFromForm(r, "has-larvae")
has_pupae := boolFromForm(r, "has-pupae")
map_zoom_str := r.FormValue("map-zoom")
is_reporter_confidential := boolFromForm(r, "reporter-confidential")
is_reporter_owner := boolFromForm(r, "property-ownership")
owner_email := r.FormValue("owner-email")
owner_name := r.FormValue("owner-name")
owner_phone := r.FormValue("owner-phone")
reporter_email := r.FormValue("reporter-email")
reporter_name := r.FormValue("reporter-name")
reporter_phone := r.FormValue("reporter-phone")
subscribe := boolFromForm(r, "subscribe")
map_zoom, err := strconv.ParseFloat(map_zoom_str, 32)
latlng, err := parseLatLng(r)
if err != nil {
respondError(w, "Failed to parse zoom level", err, http.StatusBadRequest)
respondError(w, "Failed to parse lat lng for pool report", err, http.StatusInternalServerError)
return
}
public_id, err := report.GenerateReportID()
@ -108,10 +106,10 @@ func postWater(w http.ResponseWriter, r *http.Request) {
setter := models.PublicreportPoolSetter{
AccessComments: omit.From(access_comments),
AccessGate: omit.From(access_gate),
AccessFence: omit.From(access_fence),
AccessLocked: omit.From(access_locked),
AccessDog: omit.From(access_dog),
AccessFence: omit.From(access_fence),
AccessGate: omit.From(access_gate),
AccessLocked: omit.From(access_locked),
AccessOther: omit.From(access_other),
Address: omit.From(address),
AddressCountry: omit.From(address_country),
@ -122,20 +120,22 @@ func postWater(w http.ResponseWriter, r *http.Request) {
Comments: omit.From(comments),
Created: omit.From(time.Now()),
//H3cell: add later
HasAdult: omit.From(has_adult),
HasLarvae: omit.From(has_larvae),
HasPupae: omit.From(has_pupae),
HasAdult: omit.From(has_adult),
HasBackyardPermission: omit.From(has_backyard_permission),
HasLarvae: omit.From(has_larvae),
HasPupae: omit.From(has_pupae),
IsReporterConfidential: omit.From(is_reporter_confidential),
IsReporterOwner: omit.From(is_reporter_owner),
//Location: add later
MapZoom: omit.From(map_zoom),
MapZoom: omit.From(latlng.MapZoom),
OwnerEmail: omit.From(owner_email),
OwnerName: omit.From(owner_name),
OwnerPhone: omit.From(owner_phone),
PublicID: omit.From(public_id),
ReporterEmail: omit.From(reporter_email),
ReporterName: omit.From(reporter_name),
ReporterPhone: omit.From(reporter_phone),
ReporterEmail: omit.From(""),
ReporterName: omit.From(""),
ReporterPhone: omit.From(""),
Status: omit.From(enums.PublicreportReportstatustypeReported),
Subscribe: omit.From(subscribe),
}
pool, err := models.PublicreportPools.Insert(&setter).One(ctx, tx)
if err != nil {