From 970cd568dc102242de9d3417fe73ea8b771a7088 Mon Sep 17 00:00:00 2001 From: Eli Ribble Date: Sat, 9 May 2026 01:54:12 +0000 Subject: [PATCH] Add generated jet tables and models These will change with schema changes --- db/gen/nidus-sync/arcgis/enum/fieldtype.go | 42 ++++ .../arcgis/enum/mappingdestinationaddress.go | 24 +++ .../arcgis/enum/mappingdestinationparcel.go | 18 ++ db/gen/nidus-sync/arcgis/model/account.go | 19 ++ .../arcgis/model/address_mapping.go | 16 ++ db/gen/nidus-sync/arcgis/model/fieldtype.go | 97 +++++++++ db/gen/nidus-sync/arcgis/model/layer.go | 18 ++ db/gen/nidus-sync/arcgis/model/layer_field.go | 15 ++ .../arcgis/model/mappingdestinationaddress.go | 61 ++++++ .../arcgis/model/mappingdestinationparcel.go | 49 +++++ db/gen/nidus-sync/arcgis/model/oauth_token.go | 27 +++ .../nidus-sync/arcgis/model/parcel_mapping.go | 16 ++ .../arcgis/model/service_feature.go | 20 ++ db/gen/nidus-sync/arcgis/model/service_map.go | 16 ++ db/gen/nidus-sync/arcgis/model/user_.go | 29 +++ .../nidus-sync/arcgis/model/user_privilege.go | 13 ++ db/gen/nidus-sync/arcgis/table/account.go | 99 +++++++++ .../arcgis/table/address_mapping.go | 90 ++++++++ db/gen/nidus-sync/arcgis/table/layer.go | 84 ++++++++ db/gen/nidus-sync/arcgis/table/layer_field.go | 87 ++++++++ db/gen/nidus-sync/arcgis/table/oauth_token.go | 111 ++++++++++ .../nidus-sync/arcgis/table/parcel_mapping.go | 90 ++++++++ .../arcgis/table/service_feature.go | 90 ++++++++ db/gen/nidus-sync/arcgis/table/service_map.go | 90 ++++++++ .../arcgis/table/table_use_schema.go | 23 +++ db/gen/nidus-sync/arcgis/table/user_.go | 117 +++++++++++ .../nidus-sync/arcgis/table/user_privilege.go | 81 ++++++++ .../public/enum/arcgislicensetype.go | 42 ++++ .../nidus-sync/public/enum/audiodatatype.go | 20 ++ .../public/enum/communicationlogentry.go | 28 +++ .../public/enum/communicationstatus.go | 30 +++ .../public/enum/communicationstatustype.go | 30 +++ .../public/enum/h3aggregationtype.go | 20 ++ db/gen/nidus-sync/public/enum/hashtype.go | 16 ++ .../nidus-sync/public/enum/imagedatatype.go | 18 ++ db/gen/nidus-sync/public/enum/jobtype.go | 30 +++ db/gen/nidus-sync/public/enum/leadtype.go | 22 ++ .../nidus-sync/public/enum/mosquitospecies.go | 24 +++ .../public/enum/notificationtype.go | 16 ++ .../public/enum/poolconditiontype.go | 26 +++ .../public/enum/reviewtaskresolutiontype.go | 18 ++ db/gen/nidus-sync/public/enum/signaltype.go | 28 +++ db/gen/nidus-sync/public/enum/userrole.go | 18 ++ db/gen/nidus-sync/public/model/address.go | 28 +++ .../public/model/arcgislicensetype.go | 97 +++++++++ .../nidus-sync/public/model/audiodatatype.go | 53 +++++ .../nidus-sync/public/model/communication.go | 24 +++ .../public/model/communication_log_entry.go | 20 ++ .../public/model/communicationlogentry.go | 69 +++++++ .../public/model/communicationstatus.go | 73 +++++++ .../public/model/communicationstatustype.go | 73 +++++++ .../public/model/compliance_report_request.go | 20 ++ .../model/compliance_report_request_mailer.go | 14 ++ .../model/district_subscription_email.go | 13 ++ .../model/district_subscription_phone.go | 13 ++ db/gen/nidus-sync/public/model/feature.go | 22 ++ .../nidus-sync/public/model/feature_pool.go | 19 ++ .../public/model/fieldseeker_sync.go | 21 ++ .../public/model/geography_columns.go | 18 ++ .../public/model/geometry_columns.go | 18 ++ .../public/model/goose_db_version.go | 19 ++ .../nidus-sync/public/model/h3_aggregation.go | 22 ++ .../public/model/h3aggregationtype.go | 53 +++++ db/gen/nidus-sync/public/model/hashtype.go | 45 ++++ .../nidus-sync/public/model/imagedatatype.go | 49 +++++ db/gen/nidus-sync/public/model/job.go | 20 ++ db/gen/nidus-sync/public/model/jobtype.go | 73 +++++++ db/gen/nidus-sync/public/model/lead.go | 21 ++ db/gen/nidus-sync/public/model/leadtype.go | 57 ++++++ .../public/model/log_impersonation.go | 20 ++ .../public/model/mosquitospecies.go | 61 ++++++ db/gen/nidus-sync/public/model/note_audio.go | 27 +++ .../public/model/note_audio_breadcrumb.go | 22 ++ .../public/model/note_audio_data.go | 20 ++ db/gen/nidus-sync/public/model/note_image.go | 24 +++ .../public/model/note_image_breadcrumb.go | 22 ++ .../public/model/note_image_data.go | 20 ++ .../nidus-sync/public/model/notification.go | 22 ++ .../public/model/notificationtype.go | 45 ++++ .../nidus-sync/public/model/organization.go | 51 +++++ db/gen/nidus-sync/public/model/parcel.go | 19 ++ .../public/model/poolconditiontype.go | 65 ++++++ .../nidus-sync/public/model/raster_columns.go | 32 +++ .../public/model/raster_overviews.go | 20 ++ db/gen/nidus-sync/public/model/report_text.go | 14 ++ db/gen/nidus-sync/public/model/resident.go | 22 ++ db/gen/nidus-sync/public/model/review_task.go | 22 ++ .../public/model/review_task_pool.go | 20 ++ .../public/model/reviewtaskresolutiontype.go | 49 +++++ db/gen/nidus-sync/public/model/sessions.go | 18 ++ db/gen/nidus-sync/public/model/signal.go | 28 +++ db/gen/nidus-sync/public/model/signaltype.go | 69 +++++++ db/gen/nidus-sync/public/model/site.go | 28 +++ .../public/model/spatial_ref_sys.go | 16 ++ db/gen/nidus-sync/public/model/user_.go | 33 +++ db/gen/nidus-sync/public/model/userrole.go | 49 +++++ db/gen/nidus-sync/public/table/address.go | 111 ++++++++++ .../nidus-sync/public/table/communication.go | 102 ++++++++++ .../public/table/communication_log_entry.go | 90 ++++++++ .../public/table/compliance_report_request.go | 90 ++++++++ .../table/compliance_report_request_mailer.go | 84 ++++++++ .../table/district_subscription_email.go | 81 ++++++++ .../table/district_subscription_phone.go | 81 ++++++++ db/gen/nidus-sync/public/table/feature.go | 93 +++++++++ .../nidus-sync/public/table/feature_pool.go | 87 ++++++++ .../public/table/fieldseeker_sync.go | 93 +++++++++ .../public/table/goose_db_version.go | 87 ++++++++ .../nidus-sync/public/table/h3_aggregation.go | 96 +++++++++ db/gen/nidus-sync/public/table/job.go | 88 ++++++++ db/gen/nidus-sync/public/table/lead.go | 93 +++++++++ .../public/table/log_impersonation.go | 90 ++++++++ db/gen/nidus-sync/public/table/note_audio.go | 108 ++++++++++ .../public/table/note_audio_breadcrumb.go | 93 +++++++++ .../public/table/note_audio_data.go | 87 ++++++++ db/gen/nidus-sync/public/table/note_image.go | 99 +++++++++ .../public/table/note_image_breadcrumb.go | 93 +++++++++ .../public/table/note_image_data.go | 87 ++++++++ .../nidus-sync/public/table/notification.go | 96 +++++++++ .../nidus-sync/public/table/organization.go | 180 ++++++++++++++++ db/gen/nidus-sync/public/table/parcel.go | 87 ++++++++ db/gen/nidus-sync/public/table/report_text.go | 84 ++++++++ db/gen/nidus-sync/public/table/resident.go | 96 +++++++++ db/gen/nidus-sync/public/table/review_task.go | 96 +++++++++ .../public/table/review_task_pool.go | 90 ++++++++ db/gen/nidus-sync/public/table/sessions.go | 84 ++++++++ db/gen/nidus-sync/public/table/signal.go | 111 ++++++++++ db/gen/nidus-sync/public/table/site.go | 114 +++++++++++ .../public/table/spatial_ref_sys.go | 90 ++++++++ .../public/table/table_use_schema.go | 46 +++++ db/gen/nidus-sync/public/table/user_.go | 126 ++++++++++++ .../public/view/geography_columns.go | 96 +++++++++ .../public/view/geometry_columns.go | 96 +++++++++ .../nidus-sync/public/view/raster_columns.go | 126 ++++++++++++ .../public/view/raster_overviews.go | 102 ++++++++++ .../nidus-sync/public/view/view_use_schema.go | 17 ++ .../publicreport/enum/accuracytype.go | 33 +++ .../publicreport/enum/nuisancedurationtype.go | 28 +++ .../publicreport/enum/permissionaccess.go | 22 ++ .../publicreport/enum/poolsourceduration.go | 26 +++ .../publicreport/enum/reportlogtype.go | 28 +++ .../publicreport/enum/reportstatustype.go | 24 +++ .../publicreport/enum/reporttype.go | 20 ++ .../publicreport/model/accuracytype.go | 78 +++++++ .../nidus-sync/publicreport/model/client.go | 19 ++ .../publicreport/model/compliance.go | 25 +++ db/gen/nidus-sync/publicreport/model/image.go | 26 +++ .../publicreport/model/image_exif.go | 14 ++ .../publicreport/model/notify_email.go | 19 ++ .../model/notify_email_nuisance_old.go | 19 ++ .../model/notify_email_water_old.go | 19 ++ .../publicreport/model/notify_phone.go | 19 ++ .../model/notify_phone_nuisance_old.go | 19 ++ .../model/notify_phone_water_old.go | 19 ++ .../nidus-sync/publicreport/model/nuisance.go | 27 +++ .../publicreport/model/nuisance_image_old.go | 13 ++ .../publicreport/model/nuisance_old.go | 55 +++++ .../model/nuisancedurationtype.go | 69 +++++++ .../model/organization_report_count.go | 22 ++ .../publicreport/model/permissionaccess.go | 57 ++++++ .../publicreport/model/poolsourceduration.go | 65 ++++++ .../nidus-sync/publicreport/model/report.go | 39 ++++ .../publicreport/model/report_image.go | 13 ++ .../publicreport/model/report_log.go | 22 ++ .../publicreport/model/reportlogtype.go | 69 +++++++ .../publicreport/model/reportstatustype.go | 61 ++++++ .../publicreport/model/reporttype.go | 53 +++++ .../publicreport/model/subscribe_email.go | 19 ++ .../publicreport/model/subscribe_phone.go | 19 ++ db/gen/nidus-sync/publicreport/model/water.go | 29 +++ .../publicreport/model/water_image_old.go | 13 ++ .../publicreport/model/water_old.go | 54 +++++ .../nidus-sync/publicreport/table/client.go | 84 ++++++++ .../publicreport/table/compliance.go | 105 ++++++++++ db/gen/nidus-sync/publicreport/table/image.go | 102 ++++++++++ .../publicreport/table/image_exif.go | 84 ++++++++ .../publicreport/table/notify_email.go | 87 ++++++++ .../table/notify_email_nuisance_old.go | 87 ++++++++ .../table/notify_email_water_old.go | 87 ++++++++ .../publicreport/table/notify_phone.go | 87 ++++++++ .../table/notify_phone_nuisance_old.go | 87 ++++++++ .../table/notify_phone_water_old.go | 87 ++++++++ .../nidus-sync/publicreport/table/nuisance.go | 123 +++++++++++ .../publicreport/table/nuisance_image_old.go | 81 ++++++++ .../publicreport/table/nuisance_old.go | 192 ++++++++++++++++++ .../nidus-sync/publicreport/table/report.go | 141 +++++++++++++ .../publicreport/table/report_image.go | 81 ++++++++ .../publicreport/table/report_log.go | 96 +++++++++ .../publicreport/table/subscribe_email.go | 87 ++++++++ .../publicreport/table/subscribe_phone.go | 87 ++++++++ .../publicreport/table/table_use_schema.go | 34 ++++ db/gen/nidus-sync/publicreport/table/water.go | 129 ++++++++++++ .../publicreport/table/water_image_old.go | 81 ++++++++ .../publicreport/table/water_old.go | 189 +++++++++++++++++ .../view/organization_report_count.go | 108 ++++++++++ .../publicreport/view/view_use_schema.go | 14 ++ db/gen/nidus-sync/stadia/model/api_request.go | 19 ++ db/gen/nidus-sync/stadia/table/api_request.go | 87 ++++++++ .../stadia/table/table_use_schema.go | 14 ++ 198 files changed, 10906 insertions(+) create mode 100644 db/gen/nidus-sync/arcgis/enum/fieldtype.go create mode 100644 db/gen/nidus-sync/arcgis/enum/mappingdestinationaddress.go create mode 100644 db/gen/nidus-sync/arcgis/enum/mappingdestinationparcel.go create mode 100644 db/gen/nidus-sync/arcgis/model/account.go create mode 100644 db/gen/nidus-sync/arcgis/model/address_mapping.go create mode 100644 db/gen/nidus-sync/arcgis/model/fieldtype.go create mode 100644 db/gen/nidus-sync/arcgis/model/layer.go create mode 100644 db/gen/nidus-sync/arcgis/model/layer_field.go create mode 100644 db/gen/nidus-sync/arcgis/model/mappingdestinationaddress.go create mode 100644 db/gen/nidus-sync/arcgis/model/mappingdestinationparcel.go create mode 100644 db/gen/nidus-sync/arcgis/model/oauth_token.go create mode 100644 db/gen/nidus-sync/arcgis/model/parcel_mapping.go create mode 100644 db/gen/nidus-sync/arcgis/model/service_feature.go create mode 100644 db/gen/nidus-sync/arcgis/model/service_map.go create mode 100644 db/gen/nidus-sync/arcgis/model/user_.go create mode 100644 db/gen/nidus-sync/arcgis/model/user_privilege.go create mode 100644 db/gen/nidus-sync/arcgis/table/account.go create mode 100644 db/gen/nidus-sync/arcgis/table/address_mapping.go create mode 100644 db/gen/nidus-sync/arcgis/table/layer.go create mode 100644 db/gen/nidus-sync/arcgis/table/layer_field.go create mode 100644 db/gen/nidus-sync/arcgis/table/oauth_token.go create mode 100644 db/gen/nidus-sync/arcgis/table/parcel_mapping.go create mode 100644 db/gen/nidus-sync/arcgis/table/service_feature.go create mode 100644 db/gen/nidus-sync/arcgis/table/service_map.go create mode 100644 db/gen/nidus-sync/arcgis/table/table_use_schema.go create mode 100644 db/gen/nidus-sync/arcgis/table/user_.go create mode 100644 db/gen/nidus-sync/arcgis/table/user_privilege.go create mode 100644 db/gen/nidus-sync/public/enum/arcgislicensetype.go create mode 100644 db/gen/nidus-sync/public/enum/audiodatatype.go create mode 100644 db/gen/nidus-sync/public/enum/communicationlogentry.go create mode 100644 db/gen/nidus-sync/public/enum/communicationstatus.go create mode 100644 db/gen/nidus-sync/public/enum/communicationstatustype.go create mode 100644 db/gen/nidus-sync/public/enum/h3aggregationtype.go create mode 100644 db/gen/nidus-sync/public/enum/hashtype.go create mode 100644 db/gen/nidus-sync/public/enum/imagedatatype.go create mode 100644 db/gen/nidus-sync/public/enum/jobtype.go create mode 100644 db/gen/nidus-sync/public/enum/leadtype.go create mode 100644 db/gen/nidus-sync/public/enum/mosquitospecies.go create mode 100644 db/gen/nidus-sync/public/enum/notificationtype.go create mode 100644 db/gen/nidus-sync/public/enum/poolconditiontype.go create mode 100644 db/gen/nidus-sync/public/enum/reviewtaskresolutiontype.go create mode 100644 db/gen/nidus-sync/public/enum/signaltype.go create mode 100644 db/gen/nidus-sync/public/enum/userrole.go create mode 100644 db/gen/nidus-sync/public/model/address.go create mode 100644 db/gen/nidus-sync/public/model/arcgislicensetype.go create mode 100644 db/gen/nidus-sync/public/model/audiodatatype.go create mode 100644 db/gen/nidus-sync/public/model/communication.go create mode 100644 db/gen/nidus-sync/public/model/communication_log_entry.go create mode 100644 db/gen/nidus-sync/public/model/communicationlogentry.go create mode 100644 db/gen/nidus-sync/public/model/communicationstatus.go create mode 100644 db/gen/nidus-sync/public/model/communicationstatustype.go create mode 100644 db/gen/nidus-sync/public/model/compliance_report_request.go create mode 100644 db/gen/nidus-sync/public/model/compliance_report_request_mailer.go create mode 100644 db/gen/nidus-sync/public/model/district_subscription_email.go create mode 100644 db/gen/nidus-sync/public/model/district_subscription_phone.go create mode 100644 db/gen/nidus-sync/public/model/feature.go create mode 100644 db/gen/nidus-sync/public/model/feature_pool.go create mode 100644 db/gen/nidus-sync/public/model/fieldseeker_sync.go create mode 100644 db/gen/nidus-sync/public/model/geography_columns.go create mode 100644 db/gen/nidus-sync/public/model/geometry_columns.go create mode 100644 db/gen/nidus-sync/public/model/goose_db_version.go create mode 100644 db/gen/nidus-sync/public/model/h3_aggregation.go create mode 100644 db/gen/nidus-sync/public/model/h3aggregationtype.go create mode 100644 db/gen/nidus-sync/public/model/hashtype.go create mode 100644 db/gen/nidus-sync/public/model/imagedatatype.go create mode 100644 db/gen/nidus-sync/public/model/job.go create mode 100644 db/gen/nidus-sync/public/model/jobtype.go create mode 100644 db/gen/nidus-sync/public/model/lead.go create mode 100644 db/gen/nidus-sync/public/model/leadtype.go create mode 100644 db/gen/nidus-sync/public/model/log_impersonation.go create mode 100644 db/gen/nidus-sync/public/model/mosquitospecies.go create mode 100644 db/gen/nidus-sync/public/model/note_audio.go create mode 100644 db/gen/nidus-sync/public/model/note_audio_breadcrumb.go create mode 100644 db/gen/nidus-sync/public/model/note_audio_data.go create mode 100644 db/gen/nidus-sync/public/model/note_image.go create mode 100644 db/gen/nidus-sync/public/model/note_image_breadcrumb.go create mode 100644 db/gen/nidus-sync/public/model/note_image_data.go create mode 100644 db/gen/nidus-sync/public/model/notification.go create mode 100644 db/gen/nidus-sync/public/model/notificationtype.go create mode 100644 db/gen/nidus-sync/public/model/organization.go create mode 100644 db/gen/nidus-sync/public/model/parcel.go create mode 100644 db/gen/nidus-sync/public/model/poolconditiontype.go create mode 100644 db/gen/nidus-sync/public/model/raster_columns.go create mode 100644 db/gen/nidus-sync/public/model/raster_overviews.go create mode 100644 db/gen/nidus-sync/public/model/report_text.go create mode 100644 db/gen/nidus-sync/public/model/resident.go create mode 100644 db/gen/nidus-sync/public/model/review_task.go create mode 100644 db/gen/nidus-sync/public/model/review_task_pool.go create mode 100644 db/gen/nidus-sync/public/model/reviewtaskresolutiontype.go create mode 100644 db/gen/nidus-sync/public/model/sessions.go create mode 100644 db/gen/nidus-sync/public/model/signal.go create mode 100644 db/gen/nidus-sync/public/model/signaltype.go create mode 100644 db/gen/nidus-sync/public/model/site.go create mode 100644 db/gen/nidus-sync/public/model/spatial_ref_sys.go create mode 100644 db/gen/nidus-sync/public/model/user_.go create mode 100644 db/gen/nidus-sync/public/model/userrole.go create mode 100644 db/gen/nidus-sync/public/table/address.go create mode 100644 db/gen/nidus-sync/public/table/communication.go create mode 100644 db/gen/nidus-sync/public/table/communication_log_entry.go create mode 100644 db/gen/nidus-sync/public/table/compliance_report_request.go create mode 100644 db/gen/nidus-sync/public/table/compliance_report_request_mailer.go create mode 100644 db/gen/nidus-sync/public/table/district_subscription_email.go create mode 100644 db/gen/nidus-sync/public/table/district_subscription_phone.go create mode 100644 db/gen/nidus-sync/public/table/feature.go create mode 100644 db/gen/nidus-sync/public/table/feature_pool.go create mode 100644 db/gen/nidus-sync/public/table/fieldseeker_sync.go create mode 100644 db/gen/nidus-sync/public/table/goose_db_version.go create mode 100644 db/gen/nidus-sync/public/table/h3_aggregation.go create mode 100644 db/gen/nidus-sync/public/table/job.go create mode 100644 db/gen/nidus-sync/public/table/lead.go create mode 100644 db/gen/nidus-sync/public/table/log_impersonation.go create mode 100644 db/gen/nidus-sync/public/table/note_audio.go create mode 100644 db/gen/nidus-sync/public/table/note_audio_breadcrumb.go create mode 100644 db/gen/nidus-sync/public/table/note_audio_data.go create mode 100644 db/gen/nidus-sync/public/table/note_image.go create mode 100644 db/gen/nidus-sync/public/table/note_image_breadcrumb.go create mode 100644 db/gen/nidus-sync/public/table/note_image_data.go create mode 100644 db/gen/nidus-sync/public/table/notification.go create mode 100644 db/gen/nidus-sync/public/table/organization.go create mode 100644 db/gen/nidus-sync/public/table/parcel.go create mode 100644 db/gen/nidus-sync/public/table/report_text.go create mode 100644 db/gen/nidus-sync/public/table/resident.go create mode 100644 db/gen/nidus-sync/public/table/review_task.go create mode 100644 db/gen/nidus-sync/public/table/review_task_pool.go create mode 100644 db/gen/nidus-sync/public/table/sessions.go create mode 100644 db/gen/nidus-sync/public/table/signal.go create mode 100644 db/gen/nidus-sync/public/table/site.go create mode 100644 db/gen/nidus-sync/public/table/spatial_ref_sys.go create mode 100644 db/gen/nidus-sync/public/table/table_use_schema.go create mode 100644 db/gen/nidus-sync/public/table/user_.go create mode 100644 db/gen/nidus-sync/public/view/geography_columns.go create mode 100644 db/gen/nidus-sync/public/view/geometry_columns.go create mode 100644 db/gen/nidus-sync/public/view/raster_columns.go create mode 100644 db/gen/nidus-sync/public/view/raster_overviews.go create mode 100644 db/gen/nidus-sync/public/view/view_use_schema.go create mode 100644 db/gen/nidus-sync/publicreport/enum/accuracytype.go create mode 100644 db/gen/nidus-sync/publicreport/enum/nuisancedurationtype.go create mode 100644 db/gen/nidus-sync/publicreport/enum/permissionaccess.go create mode 100644 db/gen/nidus-sync/publicreport/enum/poolsourceduration.go create mode 100644 db/gen/nidus-sync/publicreport/enum/reportlogtype.go create mode 100644 db/gen/nidus-sync/publicreport/enum/reportstatustype.go create mode 100644 db/gen/nidus-sync/publicreport/enum/reporttype.go create mode 100644 db/gen/nidus-sync/publicreport/model/accuracytype.go create mode 100644 db/gen/nidus-sync/publicreport/model/client.go create mode 100644 db/gen/nidus-sync/publicreport/model/compliance.go create mode 100644 db/gen/nidus-sync/publicreport/model/image.go create mode 100644 db/gen/nidus-sync/publicreport/model/image_exif.go create mode 100644 db/gen/nidus-sync/publicreport/model/notify_email.go create mode 100644 db/gen/nidus-sync/publicreport/model/notify_email_nuisance_old.go create mode 100644 db/gen/nidus-sync/publicreport/model/notify_email_water_old.go create mode 100644 db/gen/nidus-sync/publicreport/model/notify_phone.go create mode 100644 db/gen/nidus-sync/publicreport/model/notify_phone_nuisance_old.go create mode 100644 db/gen/nidus-sync/publicreport/model/notify_phone_water_old.go create mode 100644 db/gen/nidus-sync/publicreport/model/nuisance.go create mode 100644 db/gen/nidus-sync/publicreport/model/nuisance_image_old.go create mode 100644 db/gen/nidus-sync/publicreport/model/nuisance_old.go create mode 100644 db/gen/nidus-sync/publicreport/model/nuisancedurationtype.go create mode 100644 db/gen/nidus-sync/publicreport/model/organization_report_count.go create mode 100644 db/gen/nidus-sync/publicreport/model/permissionaccess.go create mode 100644 db/gen/nidus-sync/publicreport/model/poolsourceduration.go create mode 100644 db/gen/nidus-sync/publicreport/model/report.go create mode 100644 db/gen/nidus-sync/publicreport/model/report_image.go create mode 100644 db/gen/nidus-sync/publicreport/model/report_log.go create mode 100644 db/gen/nidus-sync/publicreport/model/reportlogtype.go create mode 100644 db/gen/nidus-sync/publicreport/model/reportstatustype.go create mode 100644 db/gen/nidus-sync/publicreport/model/reporttype.go create mode 100644 db/gen/nidus-sync/publicreport/model/subscribe_email.go create mode 100644 db/gen/nidus-sync/publicreport/model/subscribe_phone.go create mode 100644 db/gen/nidus-sync/publicreport/model/water.go create mode 100644 db/gen/nidus-sync/publicreport/model/water_image_old.go create mode 100644 db/gen/nidus-sync/publicreport/model/water_old.go create mode 100644 db/gen/nidus-sync/publicreport/table/client.go create mode 100644 db/gen/nidus-sync/publicreport/table/compliance.go create mode 100644 db/gen/nidus-sync/publicreport/table/image.go create mode 100644 db/gen/nidus-sync/publicreport/table/image_exif.go create mode 100644 db/gen/nidus-sync/publicreport/table/notify_email.go create mode 100644 db/gen/nidus-sync/publicreport/table/notify_email_nuisance_old.go create mode 100644 db/gen/nidus-sync/publicreport/table/notify_email_water_old.go create mode 100644 db/gen/nidus-sync/publicreport/table/notify_phone.go create mode 100644 db/gen/nidus-sync/publicreport/table/notify_phone_nuisance_old.go create mode 100644 db/gen/nidus-sync/publicreport/table/notify_phone_water_old.go create mode 100644 db/gen/nidus-sync/publicreport/table/nuisance.go create mode 100644 db/gen/nidus-sync/publicreport/table/nuisance_image_old.go create mode 100644 db/gen/nidus-sync/publicreport/table/nuisance_old.go create mode 100644 db/gen/nidus-sync/publicreport/table/report.go create mode 100644 db/gen/nidus-sync/publicreport/table/report_image.go create mode 100644 db/gen/nidus-sync/publicreport/table/report_log.go create mode 100644 db/gen/nidus-sync/publicreport/table/subscribe_email.go create mode 100644 db/gen/nidus-sync/publicreport/table/subscribe_phone.go create mode 100644 db/gen/nidus-sync/publicreport/table/table_use_schema.go create mode 100644 db/gen/nidus-sync/publicreport/table/water.go create mode 100644 db/gen/nidus-sync/publicreport/table/water_image_old.go create mode 100644 db/gen/nidus-sync/publicreport/table/water_old.go create mode 100644 db/gen/nidus-sync/publicreport/view/organization_report_count.go create mode 100644 db/gen/nidus-sync/publicreport/view/view_use_schema.go create mode 100644 db/gen/nidus-sync/stadia/model/api_request.go create mode 100644 db/gen/nidus-sync/stadia/table/api_request.go create mode 100644 db/gen/nidus-sync/stadia/table/table_use_schema.go diff --git a/db/gen/nidus-sync/arcgis/enum/fieldtype.go b/db/gen/nidus-sync/arcgis/enum/fieldtype.go new file mode 100644 index 00000000..41fdce0d --- /dev/null +++ b/db/gen/nidus-sync/arcgis/enum/fieldtype.go @@ -0,0 +1,42 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Fieldtype = &struct { + EsriFieldTypeSmallInteger postgres.StringExpression + EsriFieldTypeInteger postgres.StringExpression + EsriFieldTypeSingle postgres.StringExpression + EsriFieldTypeDouble postgres.StringExpression + EsriFieldTypeString postgres.StringExpression + EsriFieldTypeDate postgres.StringExpression + EsriFieldTypeOID postgres.StringExpression + EsriFieldTypeGeometry postgres.StringExpression + EsriFieldTypeBlob postgres.StringExpression + EsriFieldTypeRaster postgres.StringExpression + EsriFieldTypeGUID postgres.StringExpression + EsriFieldTypeGlobalID postgres.StringExpression + EsriFieldTypeXML postgres.StringExpression + EsriFieldTypeBigInteger postgres.StringExpression +}{ + EsriFieldTypeSmallInteger: postgres.NewEnumValue("esriFieldTypeSmallInteger"), + EsriFieldTypeInteger: postgres.NewEnumValue("esriFieldTypeInteger"), + EsriFieldTypeSingle: postgres.NewEnumValue("esriFieldTypeSingle"), + EsriFieldTypeDouble: postgres.NewEnumValue("esriFieldTypeDouble"), + EsriFieldTypeString: postgres.NewEnumValue("esriFieldTypeString"), + EsriFieldTypeDate: postgres.NewEnumValue("esriFieldTypeDate"), + EsriFieldTypeOID: postgres.NewEnumValue("esriFieldTypeOID"), + EsriFieldTypeGeometry: postgres.NewEnumValue("esriFieldTypeGeometry"), + EsriFieldTypeBlob: postgres.NewEnumValue("esriFieldTypeBlob"), + EsriFieldTypeRaster: postgres.NewEnumValue("esriFieldTypeRaster"), + EsriFieldTypeGUID: postgres.NewEnumValue("esriFieldTypeGUID"), + EsriFieldTypeGlobalID: postgres.NewEnumValue("esriFieldTypeGlobalID"), + EsriFieldTypeXML: postgres.NewEnumValue("esriFieldTypeXML"), + EsriFieldTypeBigInteger: postgres.NewEnumValue("esriFieldTypeBigInteger"), +} diff --git a/db/gen/nidus-sync/arcgis/enum/mappingdestinationaddress.go b/db/gen/nidus-sync/arcgis/enum/mappingdestinationaddress.go new file mode 100644 index 00000000..70d254bf --- /dev/null +++ b/db/gen/nidus-sync/arcgis/enum/mappingdestinationaddress.go @@ -0,0 +1,24 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Mappingdestinationaddress = &struct { + Country postgres.StringExpression + Locality postgres.StringExpression + PostalCode postgres.StringExpression + Street postgres.StringExpression + Unit postgres.StringExpression +}{ + Country: postgres.NewEnumValue("country"), + Locality: postgres.NewEnumValue("locality"), + PostalCode: postgres.NewEnumValue("postal_code"), + Street: postgres.NewEnumValue("street"), + Unit: postgres.NewEnumValue("unit"), +} diff --git a/db/gen/nidus-sync/arcgis/enum/mappingdestinationparcel.go b/db/gen/nidus-sync/arcgis/enum/mappingdestinationparcel.go new file mode 100644 index 00000000..d9efffa3 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/enum/mappingdestinationparcel.go @@ -0,0 +1,18 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Mappingdestinationparcel = &struct { + Apn postgres.StringExpression + Description postgres.StringExpression +}{ + Apn: postgres.NewEnumValue("apn"), + Description: postgres.NewEnumValue("description"), +} diff --git a/db/gen/nidus-sync/arcgis/model/account.go b/db/gen/nidus-sync/arcgis/model/account.go new file mode 100644 index 00000000..6e6a1f79 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/account.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type Account struct { + ID string `sql:"primary_key"` + Name string + OrganizationID int32 + URLFeatures *string + URLInsights *string + URLGeometry *string + URLNotebooks *string + URLTiles *string +} diff --git a/db/gen/nidus-sync/arcgis/model/address_mapping.go b/db/gen/nidus-sync/arcgis/model/address_mapping.go new file mode 100644 index 00000000..3a6bd6e5 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/address_mapping.go @@ -0,0 +1,16 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type AddressMapping struct { + Destination Mappingdestinationaddress `sql:"primary_key"` + LayerFeatureServiceItemID string + LayerIndex int32 + LayerFieldName string + OrganizationID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/arcgis/model/fieldtype.go b/db/gen/nidus-sync/arcgis/model/fieldtype.go new file mode 100644 index 00000000..46c9be72 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/fieldtype.go @@ -0,0 +1,97 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Fieldtype string + +const ( + Fieldtype_EsriFieldTypeSmallInteger Fieldtype = "esriFieldTypeSmallInteger" + Fieldtype_EsriFieldTypeInteger Fieldtype = "esriFieldTypeInteger" + Fieldtype_EsriFieldTypeSingle Fieldtype = "esriFieldTypeSingle" + Fieldtype_EsriFieldTypeDouble Fieldtype = "esriFieldTypeDouble" + Fieldtype_EsriFieldTypeString Fieldtype = "esriFieldTypeString" + Fieldtype_EsriFieldTypeDate Fieldtype = "esriFieldTypeDate" + Fieldtype_EsriFieldTypeOID Fieldtype = "esriFieldTypeOID" + Fieldtype_EsriFieldTypeGeometry Fieldtype = "esriFieldTypeGeometry" + Fieldtype_EsriFieldTypeBlob Fieldtype = "esriFieldTypeBlob" + Fieldtype_EsriFieldTypeRaster Fieldtype = "esriFieldTypeRaster" + Fieldtype_EsriFieldTypeGUID Fieldtype = "esriFieldTypeGUID" + Fieldtype_EsriFieldTypeGlobalID Fieldtype = "esriFieldTypeGlobalID" + Fieldtype_EsriFieldTypeXML Fieldtype = "esriFieldTypeXML" + Fieldtype_EsriFieldTypeBigInteger Fieldtype = "esriFieldTypeBigInteger" +) + +var FieldtypeAllValues = []Fieldtype{ + Fieldtype_EsriFieldTypeSmallInteger, + Fieldtype_EsriFieldTypeInteger, + Fieldtype_EsriFieldTypeSingle, + Fieldtype_EsriFieldTypeDouble, + Fieldtype_EsriFieldTypeString, + Fieldtype_EsriFieldTypeDate, + Fieldtype_EsriFieldTypeOID, + Fieldtype_EsriFieldTypeGeometry, + Fieldtype_EsriFieldTypeBlob, + Fieldtype_EsriFieldTypeRaster, + Fieldtype_EsriFieldTypeGUID, + Fieldtype_EsriFieldTypeGlobalID, + Fieldtype_EsriFieldTypeXML, + Fieldtype_EsriFieldTypeBigInteger, +} + +func (e *Fieldtype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "esriFieldTypeSmallInteger": + *e = Fieldtype_EsriFieldTypeSmallInteger + case "esriFieldTypeInteger": + *e = Fieldtype_EsriFieldTypeInteger + case "esriFieldTypeSingle": + *e = Fieldtype_EsriFieldTypeSingle + case "esriFieldTypeDouble": + *e = Fieldtype_EsriFieldTypeDouble + case "esriFieldTypeString": + *e = Fieldtype_EsriFieldTypeString + case "esriFieldTypeDate": + *e = Fieldtype_EsriFieldTypeDate + case "esriFieldTypeOID": + *e = Fieldtype_EsriFieldTypeOID + case "esriFieldTypeGeometry": + *e = Fieldtype_EsriFieldTypeGeometry + case "esriFieldTypeBlob": + *e = Fieldtype_EsriFieldTypeBlob + case "esriFieldTypeRaster": + *e = Fieldtype_EsriFieldTypeRaster + case "esriFieldTypeGUID": + *e = Fieldtype_EsriFieldTypeGUID + case "esriFieldTypeGlobalID": + *e = Fieldtype_EsriFieldTypeGlobalID + case "esriFieldTypeXML": + *e = Fieldtype_EsriFieldTypeXML + case "esriFieldTypeBigInteger": + *e = Fieldtype_EsriFieldTypeBigInteger + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Fieldtype enum") + } + + return nil +} + +func (e Fieldtype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/arcgis/model/layer.go b/db/gen/nidus-sync/arcgis/model/layer.go new file mode 100644 index 00000000..ebc01842 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/layer.go @@ -0,0 +1,18 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" +) + +type Layer struct { + Extent geom.Bounds + FeatureServiceItemID string `sql:"primary_key"` + Index int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/arcgis/model/layer_field.go b/db/gen/nidus-sync/arcgis/model/layer_field.go new file mode 100644 index 00000000..c5cdc75b --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/layer_field.go @@ -0,0 +1,15 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type LayerField struct { + LayerFeatureServiceItemID string `sql:"primary_key"` + LayerIndex int32 `sql:"primary_key"` + Name string `sql:"primary_key"` + Type Fieldtype +} diff --git a/db/gen/nidus-sync/arcgis/model/mappingdestinationaddress.go b/db/gen/nidus-sync/arcgis/model/mappingdestinationaddress.go new file mode 100644 index 00000000..881be412 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/mappingdestinationaddress.go @@ -0,0 +1,61 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Mappingdestinationaddress string + +const ( + Mappingdestinationaddress_Country Mappingdestinationaddress = "country" + Mappingdestinationaddress_Locality Mappingdestinationaddress = "locality" + Mappingdestinationaddress_PostalCode Mappingdestinationaddress = "postal_code" + Mappingdestinationaddress_Street Mappingdestinationaddress = "street" + Mappingdestinationaddress_Unit Mappingdestinationaddress = "unit" +) + +var MappingdestinationaddressAllValues = []Mappingdestinationaddress{ + Mappingdestinationaddress_Country, + Mappingdestinationaddress_Locality, + Mappingdestinationaddress_PostalCode, + Mappingdestinationaddress_Street, + Mappingdestinationaddress_Unit, +} + +func (e *Mappingdestinationaddress) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "country": + *e = Mappingdestinationaddress_Country + case "locality": + *e = Mappingdestinationaddress_Locality + case "postal_code": + *e = Mappingdestinationaddress_PostalCode + case "street": + *e = Mappingdestinationaddress_Street + case "unit": + *e = Mappingdestinationaddress_Unit + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Mappingdestinationaddress enum") + } + + return nil +} + +func (e Mappingdestinationaddress) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/arcgis/model/mappingdestinationparcel.go b/db/gen/nidus-sync/arcgis/model/mappingdestinationparcel.go new file mode 100644 index 00000000..656b3f94 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/mappingdestinationparcel.go @@ -0,0 +1,49 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Mappingdestinationparcel string + +const ( + Mappingdestinationparcel_Apn Mappingdestinationparcel = "apn" + Mappingdestinationparcel_Description Mappingdestinationparcel = "description" +) + +var MappingdestinationparcelAllValues = []Mappingdestinationparcel{ + Mappingdestinationparcel_Apn, + Mappingdestinationparcel_Description, +} + +func (e *Mappingdestinationparcel) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "apn": + *e = Mappingdestinationparcel_Apn + case "description": + *e = Mappingdestinationparcel_Description + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Mappingdestinationparcel enum") + } + + return nil +} + +func (e Mappingdestinationparcel) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/arcgis/model/oauth_token.go b/db/gen/nidus-sync/arcgis/model/oauth_token.go new file mode 100644 index 00000000..a29d4ae8 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/oauth_token.go @@ -0,0 +1,27 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type OAuthToken struct { + AccessToken string + AccessTokenExpires time.Time + ArcgisAccountID *string + ArcgisID *string + ArcgisLicenseTypeID *string + Created time.Time + ID int32 `sql:"primary_key"` + InvalidatedAt *time.Time + RefreshToken string + RefreshTokenExpires time.Time + UserID int32 + Username string +} diff --git a/db/gen/nidus-sync/arcgis/model/parcel_mapping.go b/db/gen/nidus-sync/arcgis/model/parcel_mapping.go new file mode 100644 index 00000000..47bf8345 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/parcel_mapping.go @@ -0,0 +1,16 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type ParcelMapping struct { + Destination Mappingdestinationparcel `sql:"primary_key"` + LayerFeatureServiceItemID string + LayerIndex int32 + LayerFieldName string + OrganizationID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/arcgis/model/service_feature.go b/db/gen/nidus-sync/arcgis/model/service_feature.go new file mode 100644 index 00000000..7cc15ac0 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/service_feature.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" +) + +type ServiceFeature struct { + Extent geom.Bounds + ItemID string `sql:"primary_key"` + SpatialReference int32 + URL string + AccountID *string +} diff --git a/db/gen/nidus-sync/arcgis/model/service_map.go b/db/gen/nidus-sync/arcgis/model/service_map.go new file mode 100644 index 00000000..4d340b14 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/service_map.go @@ -0,0 +1,16 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type ServiceMap struct { + AccountID string + ArcgisID string `sql:"primary_key"` + Name string + Title string + URL string +} diff --git a/db/gen/nidus-sync/arcgis/model/user_.go b/db/gen/nidus-sync/arcgis/model/user_.go new file mode 100644 index 00000000..e64b69e1 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/user_.go @@ -0,0 +1,29 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type User struct { + Access string + Created time.Time + Email string + FullName string + ID string `sql:"primary_key"` + Level string + OrgID string + PublicUserID int32 + Region string + Role string + RoleID string + Username string + UserLicenseTypeID string + UserType string +} diff --git a/db/gen/nidus-sync/arcgis/model/user_privilege.go b/db/gen/nidus-sync/arcgis/model/user_privilege.go new file mode 100644 index 00000000..018f1d7a --- /dev/null +++ b/db/gen/nidus-sync/arcgis/model/user_privilege.go @@ -0,0 +1,13 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type UserPrivilege struct { + UserID string `sql:"primary_key"` + Privilege string `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/arcgis/table/account.go b/db/gen/nidus-sync/arcgis/table/account.go new file mode 100644 index 00000000..54194816 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/account.go @@ -0,0 +1,99 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Account = newAccountTable("arcgis", "account", "") + +type accountTable struct { + postgres.Table + + // Columns + ID postgres.ColumnString + Name postgres.ColumnString + OrganizationID postgres.ColumnInteger + URLFeatures postgres.ColumnString + URLInsights postgres.ColumnString + URLGeometry postgres.ColumnString + URLNotebooks postgres.ColumnString + URLTiles postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type AccountTable struct { + accountTable + + EXCLUDED accountTable +} + +// AS creates new AccountTable with assigned alias +func (a AccountTable) AS(alias string) *AccountTable { + return newAccountTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new AccountTable with assigned schema name +func (a AccountTable) FromSchema(schemaName string) *AccountTable { + return newAccountTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new AccountTable with assigned table prefix +func (a AccountTable) WithPrefix(prefix string) *AccountTable { + return newAccountTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new AccountTable with assigned table suffix +func (a AccountTable) WithSuffix(suffix string) *AccountTable { + return newAccountTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newAccountTable(schemaName, tableName, alias string) *AccountTable { + return &AccountTable{ + accountTable: newAccountTableImpl(schemaName, tableName, alias), + EXCLUDED: newAccountTableImpl("", "excluded", ""), + } +} + +func newAccountTableImpl(schemaName, tableName, alias string) accountTable { + var ( + IDColumn = postgres.StringColumn("id") + NameColumn = postgres.StringColumn("name") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + URLFeaturesColumn = postgres.StringColumn("url_features") + URLInsightsColumn = postgres.StringColumn("url_insights") + URLGeometryColumn = postgres.StringColumn("url_geometry") + URLNotebooksColumn = postgres.StringColumn("url_notebooks") + URLTilesColumn = postgres.StringColumn("url_tiles") + allColumns = postgres.ColumnList{IDColumn, NameColumn, OrganizationIDColumn, URLFeaturesColumn, URLInsightsColumn, URLGeometryColumn, URLNotebooksColumn, URLTilesColumn} + mutableColumns = postgres.ColumnList{NameColumn, OrganizationIDColumn, URLFeaturesColumn, URLInsightsColumn, URLGeometryColumn, URLNotebooksColumn, URLTilesColumn} + defaultColumns = postgres.ColumnList{} + ) + + return accountTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + Name: NameColumn, + OrganizationID: OrganizationIDColumn, + URLFeatures: URLFeaturesColumn, + URLInsights: URLInsightsColumn, + URLGeometry: URLGeometryColumn, + URLNotebooks: URLNotebooksColumn, + URLTiles: URLTilesColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/arcgis/table/address_mapping.go b/db/gen/nidus-sync/arcgis/table/address_mapping.go new file mode 100644 index 00000000..e0f4c983 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/address_mapping.go @@ -0,0 +1,90 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var AddressMapping = newAddressMappingTable("arcgis", "address_mapping", "") + +type addressMappingTable struct { + postgres.Table + + // Columns + Destination postgres.ColumnString + LayerFeatureServiceItemID postgres.ColumnString + LayerIndex postgres.ColumnInteger + LayerFieldName postgres.ColumnString + OrganizationID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type AddressMappingTable struct { + addressMappingTable + + EXCLUDED addressMappingTable +} + +// AS creates new AddressMappingTable with assigned alias +func (a AddressMappingTable) AS(alias string) *AddressMappingTable { + return newAddressMappingTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new AddressMappingTable with assigned schema name +func (a AddressMappingTable) FromSchema(schemaName string) *AddressMappingTable { + return newAddressMappingTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new AddressMappingTable with assigned table prefix +func (a AddressMappingTable) WithPrefix(prefix string) *AddressMappingTable { + return newAddressMappingTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new AddressMappingTable with assigned table suffix +func (a AddressMappingTable) WithSuffix(suffix string) *AddressMappingTable { + return newAddressMappingTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newAddressMappingTable(schemaName, tableName, alias string) *AddressMappingTable { + return &AddressMappingTable{ + addressMappingTable: newAddressMappingTableImpl(schemaName, tableName, alias), + EXCLUDED: newAddressMappingTableImpl("", "excluded", ""), + } +} + +func newAddressMappingTableImpl(schemaName, tableName, alias string) addressMappingTable { + var ( + DestinationColumn = postgres.StringColumn("destination") + LayerFeatureServiceItemIDColumn = postgres.StringColumn("layer_feature_service_item_id") + LayerIndexColumn = postgres.IntegerColumn("layer_index") + LayerFieldNameColumn = postgres.StringColumn("layer_field_name") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + allColumns = postgres.ColumnList{DestinationColumn, LayerFeatureServiceItemIDColumn, LayerIndexColumn, LayerFieldNameColumn, OrganizationIDColumn} + mutableColumns = postgres.ColumnList{LayerFeatureServiceItemIDColumn, LayerIndexColumn, LayerFieldNameColumn} + defaultColumns = postgres.ColumnList{} + ) + + return addressMappingTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Destination: DestinationColumn, + LayerFeatureServiceItemID: LayerFeatureServiceItemIDColumn, + LayerIndex: LayerIndexColumn, + LayerFieldName: LayerFieldNameColumn, + OrganizationID: OrganizationIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/arcgis/table/layer.go b/db/gen/nidus-sync/arcgis/table/layer.go new file mode 100644 index 00000000..d7d43fa8 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/layer.go @@ -0,0 +1,84 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Layer = newLayerTable("arcgis", "layer", "") + +type layerTable struct { + postgres.Table + + // Columns + Extent postgres.ColumnString + FeatureServiceItemID postgres.ColumnString + Index postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type LayerTable struct { + layerTable + + EXCLUDED layerTable +} + +// AS creates new LayerTable with assigned alias +func (a LayerTable) AS(alias string) *LayerTable { + return newLayerTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new LayerTable with assigned schema name +func (a LayerTable) FromSchema(schemaName string) *LayerTable { + return newLayerTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new LayerTable with assigned table prefix +func (a LayerTable) WithPrefix(prefix string) *LayerTable { + return newLayerTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new LayerTable with assigned table suffix +func (a LayerTable) WithSuffix(suffix string) *LayerTable { + return newLayerTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newLayerTable(schemaName, tableName, alias string) *LayerTable { + return &LayerTable{ + layerTable: newLayerTableImpl(schemaName, tableName, alias), + EXCLUDED: newLayerTableImpl("", "excluded", ""), + } +} + +func newLayerTableImpl(schemaName, tableName, alias string) layerTable { + var ( + ExtentColumn = postgres.StringColumn("extent") + FeatureServiceItemIDColumn = postgres.StringColumn("feature_service_item_id") + IndexColumn = postgres.IntegerColumn("index_") + allColumns = postgres.ColumnList{ExtentColumn, FeatureServiceItemIDColumn, IndexColumn} + mutableColumns = postgres.ColumnList{ExtentColumn} + defaultColumns = postgres.ColumnList{} + ) + + return layerTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Extent: ExtentColumn, + FeatureServiceItemID: FeatureServiceItemIDColumn, + Index: IndexColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/arcgis/table/layer_field.go b/db/gen/nidus-sync/arcgis/table/layer_field.go new file mode 100644 index 00000000..d9aa0289 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/layer_field.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var LayerField = newLayerFieldTable("arcgis", "layer_field", "") + +type layerFieldTable struct { + postgres.Table + + // Columns + LayerFeatureServiceItemID postgres.ColumnString + LayerIndex postgres.ColumnInteger + Name postgres.ColumnString + Type postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type LayerFieldTable struct { + layerFieldTable + + EXCLUDED layerFieldTable +} + +// AS creates new LayerFieldTable with assigned alias +func (a LayerFieldTable) AS(alias string) *LayerFieldTable { + return newLayerFieldTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new LayerFieldTable with assigned schema name +func (a LayerFieldTable) FromSchema(schemaName string) *LayerFieldTable { + return newLayerFieldTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new LayerFieldTable with assigned table prefix +func (a LayerFieldTable) WithPrefix(prefix string) *LayerFieldTable { + return newLayerFieldTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new LayerFieldTable with assigned table suffix +func (a LayerFieldTable) WithSuffix(suffix string) *LayerFieldTable { + return newLayerFieldTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newLayerFieldTable(schemaName, tableName, alias string) *LayerFieldTable { + return &LayerFieldTable{ + layerFieldTable: newLayerFieldTableImpl(schemaName, tableName, alias), + EXCLUDED: newLayerFieldTableImpl("", "excluded", ""), + } +} + +func newLayerFieldTableImpl(schemaName, tableName, alias string) layerFieldTable { + var ( + LayerFeatureServiceItemIDColumn = postgres.StringColumn("layer_feature_service_item_id") + LayerIndexColumn = postgres.IntegerColumn("layer_index") + NameColumn = postgres.StringColumn("name") + TypeColumn = postgres.StringColumn("type_") + allColumns = postgres.ColumnList{LayerFeatureServiceItemIDColumn, LayerIndexColumn, NameColumn, TypeColumn} + mutableColumns = postgres.ColumnList{TypeColumn} + defaultColumns = postgres.ColumnList{} + ) + + return layerFieldTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + LayerFeatureServiceItemID: LayerFeatureServiceItemIDColumn, + LayerIndex: LayerIndexColumn, + Name: NameColumn, + Type: TypeColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/arcgis/table/oauth_token.go b/db/gen/nidus-sync/arcgis/table/oauth_token.go new file mode 100644 index 00000000..f7eec809 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/oauth_token.go @@ -0,0 +1,111 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var OAuthToken = newOAuthTokenTable("arcgis", "oauth_token", "") + +type oAuthTokenTable struct { + postgres.Table + + // Columns + AccessToken postgres.ColumnString + AccessTokenExpires postgres.ColumnTimestamp + ArcgisAccountID postgres.ColumnString + ArcgisID postgres.ColumnString + ArcgisLicenseTypeID postgres.ColumnString + Created postgres.ColumnTimestamp + ID postgres.ColumnInteger + InvalidatedAt postgres.ColumnTimestamp + RefreshToken postgres.ColumnString + RefreshTokenExpires postgres.ColumnTimestamp + UserID postgres.ColumnInteger + Username postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type OAuthTokenTable struct { + oAuthTokenTable + + EXCLUDED oAuthTokenTable +} + +// AS creates new OAuthTokenTable with assigned alias +func (a OAuthTokenTable) AS(alias string) *OAuthTokenTable { + return newOAuthTokenTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new OAuthTokenTable with assigned schema name +func (a OAuthTokenTable) FromSchema(schemaName string) *OAuthTokenTable { + return newOAuthTokenTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new OAuthTokenTable with assigned table prefix +func (a OAuthTokenTable) WithPrefix(prefix string) *OAuthTokenTable { + return newOAuthTokenTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new OAuthTokenTable with assigned table suffix +func (a OAuthTokenTable) WithSuffix(suffix string) *OAuthTokenTable { + return newOAuthTokenTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newOAuthTokenTable(schemaName, tableName, alias string) *OAuthTokenTable { + return &OAuthTokenTable{ + oAuthTokenTable: newOAuthTokenTableImpl(schemaName, tableName, alias), + EXCLUDED: newOAuthTokenTableImpl("", "excluded", ""), + } +} + +func newOAuthTokenTableImpl(schemaName, tableName, alias string) oAuthTokenTable { + var ( + AccessTokenColumn = postgres.StringColumn("access_token") + AccessTokenExpiresColumn = postgres.TimestampColumn("access_token_expires") + ArcgisAccountIDColumn = postgres.StringColumn("arcgis_account_id") + ArcgisIDColumn = postgres.StringColumn("arcgis_id") + ArcgisLicenseTypeIDColumn = postgres.StringColumn("arcgis_license_type_id") + CreatedColumn = postgres.TimestampColumn("created") + IDColumn = postgres.IntegerColumn("id") + InvalidatedAtColumn = postgres.TimestampColumn("invalidated_at") + RefreshTokenColumn = postgres.StringColumn("refresh_token") + RefreshTokenExpiresColumn = postgres.TimestampColumn("refresh_token_expires") + UserIDColumn = postgres.IntegerColumn("user_id") + UsernameColumn = postgres.StringColumn("username") + allColumns = postgres.ColumnList{AccessTokenColumn, AccessTokenExpiresColumn, ArcgisAccountIDColumn, ArcgisIDColumn, ArcgisLicenseTypeIDColumn, CreatedColumn, IDColumn, InvalidatedAtColumn, RefreshTokenColumn, RefreshTokenExpiresColumn, UserIDColumn, UsernameColumn} + mutableColumns = postgres.ColumnList{AccessTokenColumn, AccessTokenExpiresColumn, ArcgisAccountIDColumn, ArcgisIDColumn, ArcgisLicenseTypeIDColumn, CreatedColumn, InvalidatedAtColumn, RefreshTokenColumn, RefreshTokenExpiresColumn, UserIDColumn, UsernameColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return oAuthTokenTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + AccessToken: AccessTokenColumn, + AccessTokenExpires: AccessTokenExpiresColumn, + ArcgisAccountID: ArcgisAccountIDColumn, + ArcgisID: ArcgisIDColumn, + ArcgisLicenseTypeID: ArcgisLicenseTypeIDColumn, + Created: CreatedColumn, + ID: IDColumn, + InvalidatedAt: InvalidatedAtColumn, + RefreshToken: RefreshTokenColumn, + RefreshTokenExpires: RefreshTokenExpiresColumn, + UserID: UserIDColumn, + Username: UsernameColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/arcgis/table/parcel_mapping.go b/db/gen/nidus-sync/arcgis/table/parcel_mapping.go new file mode 100644 index 00000000..bb95d868 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/parcel_mapping.go @@ -0,0 +1,90 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ParcelMapping = newParcelMappingTable("arcgis", "parcel_mapping", "") + +type parcelMappingTable struct { + postgres.Table + + // Columns + Destination postgres.ColumnString + LayerFeatureServiceItemID postgres.ColumnString + LayerIndex postgres.ColumnInteger + LayerFieldName postgres.ColumnString + OrganizationID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ParcelMappingTable struct { + parcelMappingTable + + EXCLUDED parcelMappingTable +} + +// AS creates new ParcelMappingTable with assigned alias +func (a ParcelMappingTable) AS(alias string) *ParcelMappingTable { + return newParcelMappingTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ParcelMappingTable with assigned schema name +func (a ParcelMappingTable) FromSchema(schemaName string) *ParcelMappingTable { + return newParcelMappingTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ParcelMappingTable with assigned table prefix +func (a ParcelMappingTable) WithPrefix(prefix string) *ParcelMappingTable { + return newParcelMappingTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ParcelMappingTable with assigned table suffix +func (a ParcelMappingTable) WithSuffix(suffix string) *ParcelMappingTable { + return newParcelMappingTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newParcelMappingTable(schemaName, tableName, alias string) *ParcelMappingTable { + return &ParcelMappingTable{ + parcelMappingTable: newParcelMappingTableImpl(schemaName, tableName, alias), + EXCLUDED: newParcelMappingTableImpl("", "excluded", ""), + } +} + +func newParcelMappingTableImpl(schemaName, tableName, alias string) parcelMappingTable { + var ( + DestinationColumn = postgres.StringColumn("destination") + LayerFeatureServiceItemIDColumn = postgres.StringColumn("layer_feature_service_item_id") + LayerIndexColumn = postgres.IntegerColumn("layer_index") + LayerFieldNameColumn = postgres.StringColumn("layer_field_name") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + allColumns = postgres.ColumnList{DestinationColumn, LayerFeatureServiceItemIDColumn, LayerIndexColumn, LayerFieldNameColumn, OrganizationIDColumn} + mutableColumns = postgres.ColumnList{LayerFeatureServiceItemIDColumn, LayerIndexColumn, LayerFieldNameColumn} + defaultColumns = postgres.ColumnList{} + ) + + return parcelMappingTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Destination: DestinationColumn, + LayerFeatureServiceItemID: LayerFeatureServiceItemIDColumn, + LayerIndex: LayerIndexColumn, + LayerFieldName: LayerFieldNameColumn, + OrganizationID: OrganizationIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/arcgis/table/service_feature.go b/db/gen/nidus-sync/arcgis/table/service_feature.go new file mode 100644 index 00000000..7b03e235 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/service_feature.go @@ -0,0 +1,90 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ServiceFeature = newServiceFeatureTable("arcgis", "service_feature", "") + +type serviceFeatureTable struct { + postgres.Table + + // Columns + Extent postgres.ColumnString + ItemID postgres.ColumnString + SpatialReference postgres.ColumnInteger + URL postgres.ColumnString + AccountID postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ServiceFeatureTable struct { + serviceFeatureTable + + EXCLUDED serviceFeatureTable +} + +// AS creates new ServiceFeatureTable with assigned alias +func (a ServiceFeatureTable) AS(alias string) *ServiceFeatureTable { + return newServiceFeatureTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ServiceFeatureTable with assigned schema name +func (a ServiceFeatureTable) FromSchema(schemaName string) *ServiceFeatureTable { + return newServiceFeatureTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ServiceFeatureTable with assigned table prefix +func (a ServiceFeatureTable) WithPrefix(prefix string) *ServiceFeatureTable { + return newServiceFeatureTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ServiceFeatureTable with assigned table suffix +func (a ServiceFeatureTable) WithSuffix(suffix string) *ServiceFeatureTable { + return newServiceFeatureTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newServiceFeatureTable(schemaName, tableName, alias string) *ServiceFeatureTable { + return &ServiceFeatureTable{ + serviceFeatureTable: newServiceFeatureTableImpl(schemaName, tableName, alias), + EXCLUDED: newServiceFeatureTableImpl("", "excluded", ""), + } +} + +func newServiceFeatureTableImpl(schemaName, tableName, alias string) serviceFeatureTable { + var ( + ExtentColumn = postgres.StringColumn("extent") + ItemIDColumn = postgres.StringColumn("item_id") + SpatialReferenceColumn = postgres.IntegerColumn("spatial_reference") + URLColumn = postgres.StringColumn("url") + AccountIDColumn = postgres.StringColumn("account_id") + allColumns = postgres.ColumnList{ExtentColumn, ItemIDColumn, SpatialReferenceColumn, URLColumn, AccountIDColumn} + mutableColumns = postgres.ColumnList{ExtentColumn, SpatialReferenceColumn, URLColumn, AccountIDColumn} + defaultColumns = postgres.ColumnList{} + ) + + return serviceFeatureTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Extent: ExtentColumn, + ItemID: ItemIDColumn, + SpatialReference: SpatialReferenceColumn, + URL: URLColumn, + AccountID: AccountIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/arcgis/table/service_map.go b/db/gen/nidus-sync/arcgis/table/service_map.go new file mode 100644 index 00000000..ee2effbc --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/service_map.go @@ -0,0 +1,90 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ServiceMap = newServiceMapTable("arcgis", "service_map", "") + +type serviceMapTable struct { + postgres.Table + + // Columns + AccountID postgres.ColumnString + ArcgisID postgres.ColumnString + Name postgres.ColumnString + Title postgres.ColumnString + URL postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ServiceMapTable struct { + serviceMapTable + + EXCLUDED serviceMapTable +} + +// AS creates new ServiceMapTable with assigned alias +func (a ServiceMapTable) AS(alias string) *ServiceMapTable { + return newServiceMapTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ServiceMapTable with assigned schema name +func (a ServiceMapTable) FromSchema(schemaName string) *ServiceMapTable { + return newServiceMapTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ServiceMapTable with assigned table prefix +func (a ServiceMapTable) WithPrefix(prefix string) *ServiceMapTable { + return newServiceMapTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ServiceMapTable with assigned table suffix +func (a ServiceMapTable) WithSuffix(suffix string) *ServiceMapTable { + return newServiceMapTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newServiceMapTable(schemaName, tableName, alias string) *ServiceMapTable { + return &ServiceMapTable{ + serviceMapTable: newServiceMapTableImpl(schemaName, tableName, alias), + EXCLUDED: newServiceMapTableImpl("", "excluded", ""), + } +} + +func newServiceMapTableImpl(schemaName, tableName, alias string) serviceMapTable { + var ( + AccountIDColumn = postgres.StringColumn("account_id") + ArcgisIDColumn = postgres.StringColumn("arcgis_id") + NameColumn = postgres.StringColumn("name") + TitleColumn = postgres.StringColumn("title") + URLColumn = postgres.StringColumn("url") + allColumns = postgres.ColumnList{AccountIDColumn, ArcgisIDColumn, NameColumn, TitleColumn, URLColumn} + mutableColumns = postgres.ColumnList{AccountIDColumn, NameColumn, TitleColumn, URLColumn} + defaultColumns = postgres.ColumnList{} + ) + + return serviceMapTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + AccountID: AccountIDColumn, + ArcgisID: ArcgisIDColumn, + Name: NameColumn, + Title: TitleColumn, + URL: URLColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/arcgis/table/table_use_schema.go b/db/gen/nidus-sync/arcgis/table/table_use_schema.go new file mode 100644 index 00000000..11fcd743 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/table_use_schema.go @@ -0,0 +1,23 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +// UseSchema sets a new schema name for all generated table SQL builder types. It is recommended to invoke +// this method only once at the beginning of the program. +func UseSchema(schema string) { + Account = Account.FromSchema(schema) + AddressMapping = AddressMapping.FromSchema(schema) + Layer = Layer.FromSchema(schema) + LayerField = LayerField.FromSchema(schema) + OAuthToken = OAuthToken.FromSchema(schema) + ParcelMapping = ParcelMapping.FromSchema(schema) + ServiceFeature = ServiceFeature.FromSchema(schema) + ServiceMap = ServiceMap.FromSchema(schema) + User = User.FromSchema(schema) + UserPrivilege = UserPrivilege.FromSchema(schema) +} diff --git a/db/gen/nidus-sync/arcgis/table/user_.go b/db/gen/nidus-sync/arcgis/table/user_.go new file mode 100644 index 00000000..90c85132 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/user_.go @@ -0,0 +1,117 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var User = newUserTable("arcgis", "user_", "") + +type userTable struct { + postgres.Table + + // Columns + Access postgres.ColumnString + Created postgres.ColumnTimestamp + Email postgres.ColumnString + FullName postgres.ColumnString + ID postgres.ColumnString + Level postgres.ColumnString + OrgID postgres.ColumnString + PublicUserID postgres.ColumnInteger + Region postgres.ColumnString + Role postgres.ColumnString + RoleID postgres.ColumnString + Username postgres.ColumnString + UserLicenseTypeID postgres.ColumnString + UserType postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type UserTable struct { + userTable + + EXCLUDED userTable +} + +// AS creates new UserTable with assigned alias +func (a UserTable) AS(alias string) *UserTable { + return newUserTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new UserTable with assigned schema name +func (a UserTable) FromSchema(schemaName string) *UserTable { + return newUserTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new UserTable with assigned table prefix +func (a UserTable) WithPrefix(prefix string) *UserTable { + return newUserTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new UserTable with assigned table suffix +func (a UserTable) WithSuffix(suffix string) *UserTable { + return newUserTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newUserTable(schemaName, tableName, alias string) *UserTable { + return &UserTable{ + userTable: newUserTableImpl(schemaName, tableName, alias), + EXCLUDED: newUserTableImpl("", "excluded", ""), + } +} + +func newUserTableImpl(schemaName, tableName, alias string) userTable { + var ( + AccessColumn = postgres.StringColumn("access") + CreatedColumn = postgres.TimestampColumn("created") + EmailColumn = postgres.StringColumn("email") + FullNameColumn = postgres.StringColumn("full_name") + IDColumn = postgres.StringColumn("id") + LevelColumn = postgres.StringColumn("level") + OrgIDColumn = postgres.StringColumn("org_id") + PublicUserIDColumn = postgres.IntegerColumn("public_user_id") + RegionColumn = postgres.StringColumn("region") + RoleColumn = postgres.StringColumn("role") + RoleIDColumn = postgres.StringColumn("role_id") + UsernameColumn = postgres.StringColumn("username") + UserLicenseTypeIDColumn = postgres.StringColumn("user_license_type_id") + UserTypeColumn = postgres.StringColumn("user_type") + allColumns = postgres.ColumnList{AccessColumn, CreatedColumn, EmailColumn, FullNameColumn, IDColumn, LevelColumn, OrgIDColumn, PublicUserIDColumn, RegionColumn, RoleColumn, RoleIDColumn, UsernameColumn, UserLicenseTypeIDColumn, UserTypeColumn} + mutableColumns = postgres.ColumnList{AccessColumn, CreatedColumn, EmailColumn, FullNameColumn, LevelColumn, OrgIDColumn, PublicUserIDColumn, RegionColumn, RoleColumn, RoleIDColumn, UsernameColumn, UserLicenseTypeIDColumn, UserTypeColumn} + defaultColumns = postgres.ColumnList{} + ) + + return userTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Access: AccessColumn, + Created: CreatedColumn, + Email: EmailColumn, + FullName: FullNameColumn, + ID: IDColumn, + Level: LevelColumn, + OrgID: OrgIDColumn, + PublicUserID: PublicUserIDColumn, + Region: RegionColumn, + Role: RoleColumn, + RoleID: RoleIDColumn, + Username: UsernameColumn, + UserLicenseTypeID: UserLicenseTypeIDColumn, + UserType: UserTypeColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/arcgis/table/user_privilege.go b/db/gen/nidus-sync/arcgis/table/user_privilege.go new file mode 100644 index 00000000..ba1923e4 --- /dev/null +++ b/db/gen/nidus-sync/arcgis/table/user_privilege.go @@ -0,0 +1,81 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var UserPrivilege = newUserPrivilegeTable("arcgis", "user_privilege", "") + +type userPrivilegeTable struct { + postgres.Table + + // Columns + UserID postgres.ColumnString + Privilege postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type UserPrivilegeTable struct { + userPrivilegeTable + + EXCLUDED userPrivilegeTable +} + +// AS creates new UserPrivilegeTable with assigned alias +func (a UserPrivilegeTable) AS(alias string) *UserPrivilegeTable { + return newUserPrivilegeTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new UserPrivilegeTable with assigned schema name +func (a UserPrivilegeTable) FromSchema(schemaName string) *UserPrivilegeTable { + return newUserPrivilegeTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new UserPrivilegeTable with assigned table prefix +func (a UserPrivilegeTable) WithPrefix(prefix string) *UserPrivilegeTable { + return newUserPrivilegeTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new UserPrivilegeTable with assigned table suffix +func (a UserPrivilegeTable) WithSuffix(suffix string) *UserPrivilegeTable { + return newUserPrivilegeTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newUserPrivilegeTable(schemaName, tableName, alias string) *UserPrivilegeTable { + return &UserPrivilegeTable{ + userPrivilegeTable: newUserPrivilegeTableImpl(schemaName, tableName, alias), + EXCLUDED: newUserPrivilegeTableImpl("", "excluded", ""), + } +} + +func newUserPrivilegeTableImpl(schemaName, tableName, alias string) userPrivilegeTable { + var ( + UserIDColumn = postgres.StringColumn("user_id") + PrivilegeColumn = postgres.StringColumn("privilege") + allColumns = postgres.ColumnList{UserIDColumn, PrivilegeColumn} + mutableColumns = postgres.ColumnList{} + defaultColumns = postgres.ColumnList{} + ) + + return userPrivilegeTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + UserID: UserIDColumn, + Privilege: PrivilegeColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/enum/arcgislicensetype.go b/db/gen/nidus-sync/public/enum/arcgislicensetype.go new file mode 100644 index 00000000..f4d6eaba --- /dev/null +++ b/db/gen/nidus-sync/public/enum/arcgislicensetype.go @@ -0,0 +1,42 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Arcgislicensetype = &struct { + AdvancedUT postgres.StringExpression + BasicUT postgres.StringExpression + CreatorUT postgres.StringExpression + EditorUT postgres.StringExpression + FieldWorkerUT postgres.StringExpression + GisprofessionalAdvUT postgres.StringExpression + GisprofessionalBasicUT postgres.StringExpression + GisprofessionalStdUT postgres.StringExpression + IndoorsUserUT postgres.StringExpression + InsightsAnalystUT postgres.StringExpression + LiteUT postgres.StringExpression + StandardUT postgres.StringExpression + StorytellerUT postgres.StringExpression + ViewerUT postgres.StringExpression +}{ + AdvancedUT: postgres.NewEnumValue("advancedUT"), + BasicUT: postgres.NewEnumValue("basicUT"), + CreatorUT: postgres.NewEnumValue("creatorUT"), + EditorUT: postgres.NewEnumValue("editorUT"), + FieldWorkerUT: postgres.NewEnumValue("fieldWorkerUT"), + GisprofessionalAdvUT: postgres.NewEnumValue("GISProfessionalAdvUT"), + GisprofessionalBasicUT: postgres.NewEnumValue("GISProfessionalBasicUT"), + GisprofessionalStdUT: postgres.NewEnumValue("GISProfessionalStdUT"), + IndoorsUserUT: postgres.NewEnumValue("IndoorsUserUT"), + InsightsAnalystUT: postgres.NewEnumValue("insightsAnalystUT"), + LiteUT: postgres.NewEnumValue("liteUT"), + StandardUT: postgres.NewEnumValue("standardUT"), + StorytellerUT: postgres.NewEnumValue("storytellerUT"), + ViewerUT: postgres.NewEnumValue("viewerUT"), +} diff --git a/db/gen/nidus-sync/public/enum/audiodatatype.go b/db/gen/nidus-sync/public/enum/audiodatatype.go new file mode 100644 index 00000000..7e8ccc91 --- /dev/null +++ b/db/gen/nidus-sync/public/enum/audiodatatype.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Audiodatatype = &struct { + Raw postgres.StringExpression + RawNormalized postgres.StringExpression + Ogg postgres.StringExpression +}{ + Raw: postgres.NewEnumValue("raw"), + RawNormalized: postgres.NewEnumValue("raw_normalized"), + Ogg: postgres.NewEnumValue("ogg"), +} diff --git a/db/gen/nidus-sync/public/enum/communicationlogentry.go b/db/gen/nidus-sync/public/enum/communicationlogentry.go new file mode 100644 index 00000000..3a17e28f --- /dev/null +++ b/db/gen/nidus-sync/public/enum/communicationlogentry.go @@ -0,0 +1,28 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Communicationlogentry = &struct { + Created postgres.StringExpression + StatusClosed postgres.StringExpression + StatusInvalidated postgres.StringExpression + StatusOpened postgres.StringExpression + StatusPending postgres.StringExpression + StatusPossibleIssue postgres.StringExpression + StatusPossibleResolved postgres.StringExpression +}{ + Created: postgres.NewEnumValue("created"), + StatusClosed: postgres.NewEnumValue("status.closed"), + StatusInvalidated: postgres.NewEnumValue("status.invalidated"), + StatusOpened: postgres.NewEnumValue("status.opened"), + StatusPending: postgres.NewEnumValue("status.pending"), + StatusPossibleIssue: postgres.NewEnumValue("status.possible-issue"), + StatusPossibleResolved: postgres.NewEnumValue("status.possible-resolved"), +} diff --git a/db/gen/nidus-sync/public/enum/communicationstatus.go b/db/gen/nidus-sync/public/enum/communicationstatus.go new file mode 100644 index 00000000..9e8dc6ac --- /dev/null +++ b/db/gen/nidus-sync/public/enum/communicationstatus.go @@ -0,0 +1,30 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Communicationstatus = &struct { + Closed postgres.StringExpression + Invalid postgres.StringExpression + New postgres.StringExpression + Opened postgres.StringExpression + Pending postgres.StringExpression + PossibleIssue postgres.StringExpression + PossibleResolved postgres.StringExpression + Resolved postgres.StringExpression +}{ + Closed: postgres.NewEnumValue("closed"), + Invalid: postgres.NewEnumValue("invalid"), + New: postgres.NewEnumValue("new"), + Opened: postgres.NewEnumValue("opened"), + Pending: postgres.NewEnumValue("pending"), + PossibleIssue: postgres.NewEnumValue("possible-issue"), + PossibleResolved: postgres.NewEnumValue("possible-resolved"), + Resolved: postgres.NewEnumValue("resolved"), +} diff --git a/db/gen/nidus-sync/public/enum/communicationstatustype.go b/db/gen/nidus-sync/public/enum/communicationstatustype.go new file mode 100644 index 00000000..30890c94 --- /dev/null +++ b/db/gen/nidus-sync/public/enum/communicationstatustype.go @@ -0,0 +1,30 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Communicationstatustype = &struct { + Closed postgres.StringExpression + Invalid postgres.StringExpression + New postgres.StringExpression + Opened postgres.StringExpression + Pending postgres.StringExpression + PossibleIssue postgres.StringExpression + PossibleResolved postgres.StringExpression + Resolved postgres.StringExpression +}{ + Closed: postgres.NewEnumValue("closed"), + Invalid: postgres.NewEnumValue("invalid"), + New: postgres.NewEnumValue("new"), + Opened: postgres.NewEnumValue("opened"), + Pending: postgres.NewEnumValue("pending"), + PossibleIssue: postgres.NewEnumValue("possible-issue"), + PossibleResolved: postgres.NewEnumValue("possible-resolved"), + Resolved: postgres.NewEnumValue("resolved"), +} diff --git a/db/gen/nidus-sync/public/enum/h3aggregationtype.go b/db/gen/nidus-sync/public/enum/h3aggregationtype.go new file mode 100644 index 00000000..72baadea --- /dev/null +++ b/db/gen/nidus-sync/public/enum/h3aggregationtype.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var H3aggregationtype = &struct { + MosquitoSource postgres.StringExpression + ServiceRequest postgres.StringExpression + Trap postgres.StringExpression +}{ + MosquitoSource: postgres.NewEnumValue("MosquitoSource"), + ServiceRequest: postgres.NewEnumValue("ServiceRequest"), + Trap: postgres.NewEnumValue("Trap"), +} diff --git a/db/gen/nidus-sync/public/enum/hashtype.go b/db/gen/nidus-sync/public/enum/hashtype.go new file mode 100644 index 00000000..8f779200 --- /dev/null +++ b/db/gen/nidus-sync/public/enum/hashtype.go @@ -0,0 +1,16 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Hashtype = &struct { + Bcrypt14 postgres.StringExpression +}{ + Bcrypt14: postgres.NewEnumValue("bcrypt-14"), +} diff --git a/db/gen/nidus-sync/public/enum/imagedatatype.go b/db/gen/nidus-sync/public/enum/imagedatatype.go new file mode 100644 index 00000000..6208a4a3 --- /dev/null +++ b/db/gen/nidus-sync/public/enum/imagedatatype.go @@ -0,0 +1,18 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Imagedatatype = &struct { + Raw postgres.StringExpression + Png postgres.StringExpression +}{ + Raw: postgres.NewEnumValue("raw"), + Png: postgres.NewEnumValue("png"), +} diff --git a/db/gen/nidus-sync/public/enum/jobtype.go b/db/gen/nidus-sync/public/enum/jobtype.go new file mode 100644 index 00000000..c9d2a8a4 --- /dev/null +++ b/db/gen/nidus-sync/public/enum/jobtype.go @@ -0,0 +1,30 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Jobtype = &struct { + AudioTranscode postgres.StringExpression + CsvCommit postgres.StringExpression + CsvImport postgres.StringExpression + LabelStudioAudioCreate postgres.StringExpression + EmailSend postgres.StringExpression + TextRespond postgres.StringExpression + TextSend postgres.StringExpression + ComplianceMailerSend postgres.StringExpression +}{ + AudioTranscode: postgres.NewEnumValue("audio-transcode"), + CsvCommit: postgres.NewEnumValue("csv-commit"), + CsvImport: postgres.NewEnumValue("csv-import"), + LabelStudioAudioCreate: postgres.NewEnumValue("label-studio-audio-create"), + EmailSend: postgres.NewEnumValue("email-send"), + TextRespond: postgres.NewEnumValue("text-respond"), + TextSend: postgres.NewEnumValue("text-send"), + ComplianceMailerSend: postgres.NewEnumValue("compliance-mailer-send"), +} diff --git a/db/gen/nidus-sync/public/enum/leadtype.go b/db/gen/nidus-sync/public/enum/leadtype.go new file mode 100644 index 00000000..241e0ccd --- /dev/null +++ b/db/gen/nidus-sync/public/enum/leadtype.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Leadtype = &struct { + Unknown postgres.StringExpression + GreenPool postgres.StringExpression + PublicreportNuisance postgres.StringExpression + PublicreportWater postgres.StringExpression +}{ + Unknown: postgres.NewEnumValue("unknown"), + GreenPool: postgres.NewEnumValue("green-pool"), + PublicreportNuisance: postgres.NewEnumValue("publicreport-nuisance"), + PublicreportWater: postgres.NewEnumValue("publicreport-water"), +} diff --git a/db/gen/nidus-sync/public/enum/mosquitospecies.go b/db/gen/nidus-sync/public/enum/mosquitospecies.go new file mode 100644 index 00000000..49beae30 --- /dev/null +++ b/db/gen/nidus-sync/public/enum/mosquitospecies.go @@ -0,0 +1,24 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Mosquitospecies = &struct { + None postgres.StringExpression + AedesAegypti postgres.StringExpression + AedesAlbopictus postgres.StringExpression + CulexPipiens postgres.StringExpression + CulexTarsalis postgres.StringExpression +}{ + None: postgres.NewEnumValue("none"), + AedesAegypti: postgres.NewEnumValue("aedes aegypti"), + AedesAlbopictus: postgres.NewEnumValue("aedes albopictus"), + CulexPipiens: postgres.NewEnumValue("culex pipiens"), + CulexTarsalis: postgres.NewEnumValue("culex tarsalis"), +} diff --git a/db/gen/nidus-sync/public/enum/notificationtype.go b/db/gen/nidus-sync/public/enum/notificationtype.go new file mode 100644 index 00000000..55229343 --- /dev/null +++ b/db/gen/nidus-sync/public/enum/notificationtype.go @@ -0,0 +1,16 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Notificationtype = &struct { + OAuthTokenInvalidated postgres.StringExpression +}{ + OAuthTokenInvalidated: postgres.NewEnumValue("oauth_token_invalidated"), +} diff --git a/db/gen/nidus-sync/public/enum/poolconditiontype.go b/db/gen/nidus-sync/public/enum/poolconditiontype.go new file mode 100644 index 00000000..d3d07620 --- /dev/null +++ b/db/gen/nidus-sync/public/enum/poolconditiontype.go @@ -0,0 +1,26 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Poolconditiontype = &struct { + Blue postgres.StringExpression + Dry postgres.StringExpression + FalsePool postgres.StringExpression + Unknown postgres.StringExpression + Green postgres.StringExpression + Murky postgres.StringExpression +}{ + Blue: postgres.NewEnumValue("blue"), + Dry: postgres.NewEnumValue("dry"), + FalsePool: postgres.NewEnumValue("false pool"), + Unknown: postgres.NewEnumValue("unknown"), + Green: postgres.NewEnumValue("green"), + Murky: postgres.NewEnumValue("murky"), +} diff --git a/db/gen/nidus-sync/public/enum/reviewtaskresolutiontype.go b/db/gen/nidus-sync/public/enum/reviewtaskresolutiontype.go new file mode 100644 index 00000000..3f3d9333 --- /dev/null +++ b/db/gen/nidus-sync/public/enum/reviewtaskresolutiontype.go @@ -0,0 +1,18 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Reviewtaskresolutiontype = &struct { + Committed postgres.StringExpression + Discarded postgres.StringExpression +}{ + Committed: postgres.NewEnumValue("committed"), + Discarded: postgres.NewEnumValue("discarded"), +} diff --git a/db/gen/nidus-sync/public/enum/signaltype.go b/db/gen/nidus-sync/public/enum/signaltype.go new file mode 100644 index 00000000..86e9b22f --- /dev/null +++ b/db/gen/nidus-sync/public/enum/signaltype.go @@ -0,0 +1,28 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Signaltype = &struct { + FlyoverPool postgres.StringExpression + PlanFollowup postgres.StringExpression + PublicreportWater postgres.StringExpression + PublicreportNuisance postgres.StringExpression + ResidualExiring postgres.StringExpression + SurveillanceObservation postgres.StringExpression + TrapSpike postgres.StringExpression +}{ + FlyoverPool: postgres.NewEnumValue("flyover pool"), + PlanFollowup: postgres.NewEnumValue("plan followup"), + PublicreportWater: postgres.NewEnumValue("publicreport water"), + PublicreportNuisance: postgres.NewEnumValue("publicreport nuisance"), + ResidualExiring: postgres.NewEnumValue("residual exiring"), + SurveillanceObservation: postgres.NewEnumValue("surveillance observation"), + TrapSpike: postgres.NewEnumValue("trap spike"), +} diff --git a/db/gen/nidus-sync/public/enum/userrole.go b/db/gen/nidus-sync/public/enum/userrole.go new file mode 100644 index 00000000..0e21e80e --- /dev/null +++ b/db/gen/nidus-sync/public/enum/userrole.go @@ -0,0 +1,18 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Userrole = &struct { + Root postgres.StringExpression + AccountOwner postgres.StringExpression +}{ + Root: postgres.NewEnumValue("root"), + AccountOwner: postgres.NewEnumValue("account-owner"), +} diff --git a/db/gen/nidus-sync/public/model/address.go b/db/gen/nidus-sync/public/model/address.go new file mode 100644 index 00000000..0b1cce40 --- /dev/null +++ b/db/gen/nidus-sync/public/model/address.go @@ -0,0 +1,28 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" + "time" +) + +type Address struct { + Country string + Created time.Time + Location geom.T + H3cell string + ID int32 `sql:"primary_key"` + Locality string + PostalCode string + Street string + Unit string + Region string + Number string + Gid string +} diff --git a/db/gen/nidus-sync/public/model/arcgislicensetype.go b/db/gen/nidus-sync/public/model/arcgislicensetype.go new file mode 100644 index 00000000..0c28a143 --- /dev/null +++ b/db/gen/nidus-sync/public/model/arcgislicensetype.go @@ -0,0 +1,97 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Arcgislicensetype string + +const ( + Arcgislicensetype_AdvancedUT Arcgislicensetype = "advancedUT" + Arcgislicensetype_BasicUT Arcgislicensetype = "basicUT" + Arcgislicensetype_CreatorUT Arcgislicensetype = "creatorUT" + Arcgislicensetype_EditorUT Arcgislicensetype = "editorUT" + Arcgislicensetype_FieldWorkerUT Arcgislicensetype = "fieldWorkerUT" + Arcgislicensetype_GisprofessionalAdvUT Arcgislicensetype = "GISProfessionalAdvUT" + Arcgislicensetype_GisprofessionalBasicUT Arcgislicensetype = "GISProfessionalBasicUT" + Arcgislicensetype_GisprofessionalStdUT Arcgislicensetype = "GISProfessionalStdUT" + Arcgislicensetype_IndoorsUserUT Arcgislicensetype = "IndoorsUserUT" + Arcgislicensetype_InsightsAnalystUT Arcgislicensetype = "insightsAnalystUT" + Arcgislicensetype_LiteUT Arcgislicensetype = "liteUT" + Arcgislicensetype_StandardUT Arcgislicensetype = "standardUT" + Arcgislicensetype_StorytellerUT Arcgislicensetype = "storytellerUT" + Arcgislicensetype_ViewerUT Arcgislicensetype = "viewerUT" +) + +var ArcgislicensetypeAllValues = []Arcgislicensetype{ + Arcgislicensetype_AdvancedUT, + Arcgislicensetype_BasicUT, + Arcgislicensetype_CreatorUT, + Arcgislicensetype_EditorUT, + Arcgislicensetype_FieldWorkerUT, + Arcgislicensetype_GisprofessionalAdvUT, + Arcgislicensetype_GisprofessionalBasicUT, + Arcgislicensetype_GisprofessionalStdUT, + Arcgislicensetype_IndoorsUserUT, + Arcgislicensetype_InsightsAnalystUT, + Arcgislicensetype_LiteUT, + Arcgislicensetype_StandardUT, + Arcgislicensetype_StorytellerUT, + Arcgislicensetype_ViewerUT, +} + +func (e *Arcgislicensetype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "advancedUT": + *e = Arcgislicensetype_AdvancedUT + case "basicUT": + *e = Arcgislicensetype_BasicUT + case "creatorUT": + *e = Arcgislicensetype_CreatorUT + case "editorUT": + *e = Arcgislicensetype_EditorUT + case "fieldWorkerUT": + *e = Arcgislicensetype_FieldWorkerUT + case "GISProfessionalAdvUT": + *e = Arcgislicensetype_GisprofessionalAdvUT + case "GISProfessionalBasicUT": + *e = Arcgislicensetype_GisprofessionalBasicUT + case "GISProfessionalStdUT": + *e = Arcgislicensetype_GisprofessionalStdUT + case "IndoorsUserUT": + *e = Arcgislicensetype_IndoorsUserUT + case "insightsAnalystUT": + *e = Arcgislicensetype_InsightsAnalystUT + case "liteUT": + *e = Arcgislicensetype_LiteUT + case "standardUT": + *e = Arcgislicensetype_StandardUT + case "storytellerUT": + *e = Arcgislicensetype_StorytellerUT + case "viewerUT": + *e = Arcgislicensetype_ViewerUT + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Arcgislicensetype enum") + } + + return nil +} + +func (e Arcgislicensetype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/audiodatatype.go b/db/gen/nidus-sync/public/model/audiodatatype.go new file mode 100644 index 00000000..853124bc --- /dev/null +++ b/db/gen/nidus-sync/public/model/audiodatatype.go @@ -0,0 +1,53 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Audiodatatype string + +const ( + Audiodatatype_Raw Audiodatatype = "raw" + Audiodatatype_RawNormalized Audiodatatype = "raw_normalized" + Audiodatatype_Ogg Audiodatatype = "ogg" +) + +var AudiodatatypeAllValues = []Audiodatatype{ + Audiodatatype_Raw, + Audiodatatype_RawNormalized, + Audiodatatype_Ogg, +} + +func (e *Audiodatatype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "raw": + *e = Audiodatatype_Raw + case "raw_normalized": + *e = Audiodatatype_RawNormalized + case "ogg": + *e = Audiodatatype_Ogg + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Audiodatatype enum") + } + + return nil +} + +func (e Audiodatatype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/communication.go b/db/gen/nidus-sync/public/model/communication.go new file mode 100644 index 00000000..69e1a1ba --- /dev/null +++ b/db/gen/nidus-sync/public/model/communication.go @@ -0,0 +1,24 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type Communication struct { + Created time.Time + ID int32 `sql:"primary_key"` + OrganizationID int32 + ResponseEmailLogID *int32 + ResponseTextLogID *int32 + SourceEmailLogID *int32 + SourceReportID *int32 + SourceTextLogID *int32 + Status Communicationstatus +} diff --git a/db/gen/nidus-sync/public/model/communication_log_entry.go b/db/gen/nidus-sync/public/model/communication_log_entry.go new file mode 100644 index 00000000..f14cfd8e --- /dev/null +++ b/db/gen/nidus-sync/public/model/communication_log_entry.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type CommunicationLogEntry struct { + CommunicationID int32 + Created time.Time + ID int32 `sql:"primary_key"` + Type Communicationlogentry + User *int32 +} diff --git a/db/gen/nidus-sync/public/model/communicationlogentry.go b/db/gen/nidus-sync/public/model/communicationlogentry.go new file mode 100644 index 00000000..c691de2f --- /dev/null +++ b/db/gen/nidus-sync/public/model/communicationlogentry.go @@ -0,0 +1,69 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Communicationlogentry string + +const ( + Communicationlogentry_Created Communicationlogentry = "created" + Communicationlogentry_StatusClosed Communicationlogentry = "status.closed" + Communicationlogentry_StatusInvalidated Communicationlogentry = "status.invalidated" + Communicationlogentry_StatusOpened Communicationlogentry = "status.opened" + Communicationlogentry_StatusPending Communicationlogentry = "status.pending" + Communicationlogentry_StatusPossibleIssue Communicationlogentry = "status.possible-issue" + Communicationlogentry_StatusPossibleResolved Communicationlogentry = "status.possible-resolved" +) + +var CommunicationlogentryAllValues = []Communicationlogentry{ + Communicationlogentry_Created, + Communicationlogentry_StatusClosed, + Communicationlogentry_StatusInvalidated, + Communicationlogentry_StatusOpened, + Communicationlogentry_StatusPending, + Communicationlogentry_StatusPossibleIssue, + Communicationlogentry_StatusPossibleResolved, +} + +func (e *Communicationlogentry) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "created": + *e = Communicationlogentry_Created + case "status.closed": + *e = Communicationlogentry_StatusClosed + case "status.invalidated": + *e = Communicationlogentry_StatusInvalidated + case "status.opened": + *e = Communicationlogentry_StatusOpened + case "status.pending": + *e = Communicationlogentry_StatusPending + case "status.possible-issue": + *e = Communicationlogentry_StatusPossibleIssue + case "status.possible-resolved": + *e = Communicationlogentry_StatusPossibleResolved + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Communicationlogentry enum") + } + + return nil +} + +func (e Communicationlogentry) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/communicationstatus.go b/db/gen/nidus-sync/public/model/communicationstatus.go new file mode 100644 index 00000000..2d495939 --- /dev/null +++ b/db/gen/nidus-sync/public/model/communicationstatus.go @@ -0,0 +1,73 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Communicationstatus string + +const ( + Communicationstatus_Closed Communicationstatus = "closed" + Communicationstatus_Invalid Communicationstatus = "invalid" + Communicationstatus_New Communicationstatus = "new" + Communicationstatus_Opened Communicationstatus = "opened" + Communicationstatus_Pending Communicationstatus = "pending" + Communicationstatus_PossibleIssue Communicationstatus = "possible-issue" + Communicationstatus_PossibleResolved Communicationstatus = "possible-resolved" + Communicationstatus_Resolved Communicationstatus = "resolved" +) + +var CommunicationstatusAllValues = []Communicationstatus{ + Communicationstatus_Closed, + Communicationstatus_Invalid, + Communicationstatus_New, + Communicationstatus_Opened, + Communicationstatus_Pending, + Communicationstatus_PossibleIssue, + Communicationstatus_PossibleResolved, + Communicationstatus_Resolved, +} + +func (e *Communicationstatus) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "closed": + *e = Communicationstatus_Closed + case "invalid": + *e = Communicationstatus_Invalid + case "new": + *e = Communicationstatus_New + case "opened": + *e = Communicationstatus_Opened + case "pending": + *e = Communicationstatus_Pending + case "possible-issue": + *e = Communicationstatus_PossibleIssue + case "possible-resolved": + *e = Communicationstatus_PossibleResolved + case "resolved": + *e = Communicationstatus_Resolved + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Communicationstatus enum") + } + + return nil +} + +func (e Communicationstatus) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/communicationstatustype.go b/db/gen/nidus-sync/public/model/communicationstatustype.go new file mode 100644 index 00000000..1c3ecea9 --- /dev/null +++ b/db/gen/nidus-sync/public/model/communicationstatustype.go @@ -0,0 +1,73 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Communicationstatustype string + +const ( + Communicationstatustype_Closed Communicationstatustype = "closed" + Communicationstatustype_Invalid Communicationstatustype = "invalid" + Communicationstatustype_New Communicationstatustype = "new" + Communicationstatustype_Opened Communicationstatustype = "opened" + Communicationstatustype_Pending Communicationstatustype = "pending" + Communicationstatustype_PossibleIssue Communicationstatustype = "possible-issue" + Communicationstatustype_PossibleResolved Communicationstatustype = "possible-resolved" + Communicationstatustype_Resolved Communicationstatustype = "resolved" +) + +var CommunicationstatustypeAllValues = []Communicationstatustype{ + Communicationstatustype_Closed, + Communicationstatustype_Invalid, + Communicationstatustype_New, + Communicationstatustype_Opened, + Communicationstatustype_Pending, + Communicationstatustype_PossibleIssue, + Communicationstatustype_PossibleResolved, + Communicationstatustype_Resolved, +} + +func (e *Communicationstatustype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "closed": + *e = Communicationstatustype_Closed + case "invalid": + *e = Communicationstatustype_Invalid + case "new": + *e = Communicationstatustype_New + case "opened": + *e = Communicationstatustype_Opened + case "pending": + *e = Communicationstatustype_Pending + case "possible-issue": + *e = Communicationstatustype_PossibleIssue + case "possible-resolved": + *e = Communicationstatustype_PossibleResolved + case "resolved": + *e = Communicationstatustype_Resolved + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Communicationstatustype enum") + } + + return nil +} + +func (e Communicationstatustype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/compliance_report_request.go b/db/gen/nidus-sync/public/model/compliance_report_request.go new file mode 100644 index 00000000..26494556 --- /dev/null +++ b/db/gen/nidus-sync/public/model/compliance_report_request.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type ComplianceReportRequest struct { + Created time.Time + Creator int32 + ID int32 `sql:"primary_key"` + PublicID string + LeadID *int32 +} diff --git a/db/gen/nidus-sync/public/model/compliance_report_request_mailer.go b/db/gen/nidus-sync/public/model/compliance_report_request_mailer.go new file mode 100644 index 00000000..67fd09bb --- /dev/null +++ b/db/gen/nidus-sync/public/model/compliance_report_request_mailer.go @@ -0,0 +1,14 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type ComplianceReportRequestMailer struct { + ComplianceReportRequestID int32 + MailerID int32 + ID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/public/model/district_subscription_email.go b/db/gen/nidus-sync/public/model/district_subscription_email.go new file mode 100644 index 00000000..c69d72c7 --- /dev/null +++ b/db/gen/nidus-sync/public/model/district_subscription_email.go @@ -0,0 +1,13 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type DistrictSubscriptionEmail struct { + OrganizationID int32 `sql:"primary_key"` + EmailContactAddress string `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/public/model/district_subscription_phone.go b/db/gen/nidus-sync/public/model/district_subscription_phone.go new file mode 100644 index 00000000..b397ec8b --- /dev/null +++ b/db/gen/nidus-sync/public/model/district_subscription_phone.go @@ -0,0 +1,13 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type DistrictSubscriptionPhone struct { + OrganizationID int32 `sql:"primary_key"` + PhoneE164 string `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/public/model/feature.go b/db/gen/nidus-sync/public/model/feature.go new file mode 100644 index 00000000..3f9971ea --- /dev/null +++ b/db/gen/nidus-sync/public/model/feature.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" + "time" +) + +type Feature struct { + Created time.Time + CreatorID int32 + ID int32 `sql:"primary_key"` + OrganizationID int32 + SiteID int32 + Location *geom.T +} diff --git a/db/gen/nidus-sync/public/model/feature_pool.go b/db/gen/nidus-sync/public/model/feature_pool.go new file mode 100644 index 00000000..3235b2a7 --- /dev/null +++ b/db/gen/nidus-sync/public/model/feature_pool.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" +) + +type FeaturePool struct { + FeatureID int32 `sql:"primary_key"` + Condition Poolconditiontype + DepthMeters *float64 + Geometry *geom.T +} diff --git a/db/gen/nidus-sync/public/model/fieldseeker_sync.go b/db/gen/nidus-sync/public/model/fieldseeker_sync.go new file mode 100644 index 00000000..e2454641 --- /dev/null +++ b/db/gen/nidus-sync/public/model/fieldseeker_sync.go @@ -0,0 +1,21 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type FieldseekerSync struct { + ID int32 `sql:"primary_key"` + Created time.Time + RecordsCreated int32 + RecordsUpdated int32 + RecordsUnchanged int32 + OrganizationID int32 +} diff --git a/db/gen/nidus-sync/public/model/geography_columns.go b/db/gen/nidus-sync/public/model/geography_columns.go new file mode 100644 index 00000000..cf31fd2f --- /dev/null +++ b/db/gen/nidus-sync/public/model/geography_columns.go @@ -0,0 +1,18 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type GeographyColumns struct { + FTableCatalog *string + FTableSchema *string + FTableName *string + FGeographyColumn *string + CoordDimension *int32 + Srid *int32 + Type *string +} diff --git a/db/gen/nidus-sync/public/model/geometry_columns.go b/db/gen/nidus-sync/public/model/geometry_columns.go new file mode 100644 index 00000000..8a57fba6 --- /dev/null +++ b/db/gen/nidus-sync/public/model/geometry_columns.go @@ -0,0 +1,18 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type GeometryColumns struct { + FTableCatalog *string + FTableSchema *string + FTableName *string + FGeometryColumn *string + CoordDimension *int32 + Srid *int32 + Type *string +} diff --git a/db/gen/nidus-sync/public/model/goose_db_version.go b/db/gen/nidus-sync/public/model/goose_db_version.go new file mode 100644 index 00000000..c7f68e86 --- /dev/null +++ b/db/gen/nidus-sync/public/model/goose_db_version.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type GooseDbVersion struct { + ID int32 `sql:"primary_key"` + VersionID int64 + IsApplied bool + Tstamp time.Time +} diff --git a/db/gen/nidus-sync/public/model/h3_aggregation.go b/db/gen/nidus-sync/public/model/h3_aggregation.go new file mode 100644 index 00000000..9bdc6dde --- /dev/null +++ b/db/gen/nidus-sync/public/model/h3_aggregation.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" +) + +type H3Aggregation struct { + ID int32 `sql:"primary_key"` + Cell string + Count int32 + Geometry *geom.T + OrganizationID int32 + Resolution int32 + Type H3aggregationtype +} diff --git a/db/gen/nidus-sync/public/model/h3aggregationtype.go b/db/gen/nidus-sync/public/model/h3aggregationtype.go new file mode 100644 index 00000000..1f7d898d --- /dev/null +++ b/db/gen/nidus-sync/public/model/h3aggregationtype.go @@ -0,0 +1,53 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type H3aggregationtype string + +const ( + H3aggregationtype_MosquitoSource H3aggregationtype = "MosquitoSource" + H3aggregationtype_ServiceRequest H3aggregationtype = "ServiceRequest" + H3aggregationtype_Trap H3aggregationtype = "Trap" +) + +var H3aggregationtypeAllValues = []H3aggregationtype{ + H3aggregationtype_MosquitoSource, + H3aggregationtype_ServiceRequest, + H3aggregationtype_Trap, +} + +func (e *H3aggregationtype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "MosquitoSource": + *e = H3aggregationtype_MosquitoSource + case "ServiceRequest": + *e = H3aggregationtype_ServiceRequest + case "Trap": + *e = H3aggregationtype_Trap + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for H3aggregationtype enum") + } + + return nil +} + +func (e H3aggregationtype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/hashtype.go b/db/gen/nidus-sync/public/model/hashtype.go new file mode 100644 index 00000000..4a8e6fb3 --- /dev/null +++ b/db/gen/nidus-sync/public/model/hashtype.go @@ -0,0 +1,45 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Hashtype string + +const ( + Hashtype_Bcrypt14 Hashtype = "bcrypt-14" +) + +var HashtypeAllValues = []Hashtype{ + Hashtype_Bcrypt14, +} + +func (e *Hashtype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "bcrypt-14": + *e = Hashtype_Bcrypt14 + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Hashtype enum") + } + + return nil +} + +func (e Hashtype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/imagedatatype.go b/db/gen/nidus-sync/public/model/imagedatatype.go new file mode 100644 index 00000000..a50cd350 --- /dev/null +++ b/db/gen/nidus-sync/public/model/imagedatatype.go @@ -0,0 +1,49 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Imagedatatype string + +const ( + Imagedatatype_Raw Imagedatatype = "raw" + Imagedatatype_Png Imagedatatype = "png" +) + +var ImagedatatypeAllValues = []Imagedatatype{ + Imagedatatype_Raw, + Imagedatatype_Png, +} + +func (e *Imagedatatype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "raw": + *e = Imagedatatype_Raw + case "png": + *e = Imagedatatype_Png + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Imagedatatype enum") + } + + return nil +} + +func (e Imagedatatype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/job.go b/db/gen/nidus-sync/public/model/job.go new file mode 100644 index 00000000..e6f13988 --- /dev/null +++ b/db/gen/nidus-sync/public/model/job.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +// A temporary holding place for jobs that are pushed to backend workers. Once work is completed the job should be deleted +type Job struct { + Created time.Time + ID int32 `sql:"primary_key"` + Type Jobtype + RowID int32 +} diff --git a/db/gen/nidus-sync/public/model/jobtype.go b/db/gen/nidus-sync/public/model/jobtype.go new file mode 100644 index 00000000..4e6b57d4 --- /dev/null +++ b/db/gen/nidus-sync/public/model/jobtype.go @@ -0,0 +1,73 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Jobtype string + +const ( + Jobtype_AudioTranscode Jobtype = "audio-transcode" + Jobtype_CsvCommit Jobtype = "csv-commit" + Jobtype_CsvImport Jobtype = "csv-import" + Jobtype_LabelStudioAudioCreate Jobtype = "label-studio-audio-create" + Jobtype_EmailSend Jobtype = "email-send" + Jobtype_TextRespond Jobtype = "text-respond" + Jobtype_TextSend Jobtype = "text-send" + Jobtype_ComplianceMailerSend Jobtype = "compliance-mailer-send" +) + +var JobtypeAllValues = []Jobtype{ + Jobtype_AudioTranscode, + Jobtype_CsvCommit, + Jobtype_CsvImport, + Jobtype_LabelStudioAudioCreate, + Jobtype_EmailSend, + Jobtype_TextRespond, + Jobtype_TextSend, + Jobtype_ComplianceMailerSend, +} + +func (e *Jobtype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "audio-transcode": + *e = Jobtype_AudioTranscode + case "csv-commit": + *e = Jobtype_CsvCommit + case "csv-import": + *e = Jobtype_CsvImport + case "label-studio-audio-create": + *e = Jobtype_LabelStudioAudioCreate + case "email-send": + *e = Jobtype_EmailSend + case "text-respond": + *e = Jobtype_TextRespond + case "text-send": + *e = Jobtype_TextSend + case "compliance-mailer-send": + *e = Jobtype_ComplianceMailerSend + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Jobtype enum") + } + + return nil +} + +func (e Jobtype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/lead.go b/db/gen/nidus-sync/public/model/lead.go new file mode 100644 index 00000000..e0d25f1e --- /dev/null +++ b/db/gen/nidus-sync/public/model/lead.go @@ -0,0 +1,21 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type Lead struct { + Created time.Time + Creator int32 + ID int32 `sql:"primary_key"` + OrganizationID int32 + SiteID *int32 + Type Leadtype +} diff --git a/db/gen/nidus-sync/public/model/leadtype.go b/db/gen/nidus-sync/public/model/leadtype.go new file mode 100644 index 00000000..94ba2a07 --- /dev/null +++ b/db/gen/nidus-sync/public/model/leadtype.go @@ -0,0 +1,57 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Leadtype string + +const ( + Leadtype_Unknown Leadtype = "unknown" + Leadtype_GreenPool Leadtype = "green-pool" + Leadtype_PublicreportNuisance Leadtype = "publicreport-nuisance" + Leadtype_PublicreportWater Leadtype = "publicreport-water" +) + +var LeadtypeAllValues = []Leadtype{ + Leadtype_Unknown, + Leadtype_GreenPool, + Leadtype_PublicreportNuisance, + Leadtype_PublicreportWater, +} + +func (e *Leadtype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "unknown": + *e = Leadtype_Unknown + case "green-pool": + *e = Leadtype_GreenPool + case "publicreport-nuisance": + *e = Leadtype_PublicreportNuisance + case "publicreport-water": + *e = Leadtype_PublicreportWater + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Leadtype enum") + } + + return nil +} + +func (e Leadtype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/log_impersonation.go b/db/gen/nidus-sync/public/model/log_impersonation.go new file mode 100644 index 00000000..104c0413 --- /dev/null +++ b/db/gen/nidus-sync/public/model/log_impersonation.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type LogImpersonation struct { + BeginAt time.Time + EndAt *time.Time + ID int32 `sql:"primary_key"` + ImpersonatorID int32 + TargetID int32 +} diff --git a/db/gen/nidus-sync/public/model/mosquitospecies.go b/db/gen/nidus-sync/public/model/mosquitospecies.go new file mode 100644 index 00000000..065eafa9 --- /dev/null +++ b/db/gen/nidus-sync/public/model/mosquitospecies.go @@ -0,0 +1,61 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Mosquitospecies string + +const ( + Mosquitospecies_None Mosquitospecies = "none" + Mosquitospecies_AedesAegypti Mosquitospecies = "aedes aegypti" + Mosquitospecies_AedesAlbopictus Mosquitospecies = "aedes albopictus" + Mosquitospecies_CulexPipiens Mosquitospecies = "culex pipiens" + Mosquitospecies_CulexTarsalis Mosquitospecies = "culex tarsalis" +) + +var MosquitospeciesAllValues = []Mosquitospecies{ + Mosquitospecies_None, + Mosquitospecies_AedesAegypti, + Mosquitospecies_AedesAlbopictus, + Mosquitospecies_CulexPipiens, + Mosquitospecies_CulexTarsalis, +} + +func (e *Mosquitospecies) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "none": + *e = Mosquitospecies_None + case "aedes aegypti": + *e = Mosquitospecies_AedesAegypti + case "aedes albopictus": + *e = Mosquitospecies_AedesAlbopictus + case "culex pipiens": + *e = Mosquitospecies_CulexPipiens + case "culex tarsalis": + *e = Mosquitospecies_CulexTarsalis + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Mosquitospecies enum") + } + + return nil +} + +func (e Mosquitospecies) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/note_audio.go b/db/gen/nidus-sync/public/model/note_audio.go new file mode 100644 index 00000000..6c00e207 --- /dev/null +++ b/db/gen/nidus-sync/public/model/note_audio.go @@ -0,0 +1,27 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "time" +) + +type NoteAudio struct { + Created time.Time + CreatorID int32 + Deleted *time.Time + DeletorID *int32 + Duration float32 + OrganizationID int32 + Transcription *string + TranscriptionUserEdited bool + Version int32 `sql:"primary_key"` + UUID uuid.UUID `sql:"primary_key"` + ID int32 +} diff --git a/db/gen/nidus-sync/public/model/note_audio_breadcrumb.go b/db/gen/nidus-sync/public/model/note_audio_breadcrumb.go new file mode 100644 index 00000000..349bf697 --- /dev/null +++ b/db/gen/nidus-sync/public/model/note_audio_breadcrumb.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "time" +) + +type NoteAudioBreadcrumb struct { + Cell string + Created time.Time + ManuallySelected bool + NoteAudioVersion int32 `sql:"primary_key"` + NoteAudioUUID uuid.UUID `sql:"primary_key"` + Position int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/public/model/note_audio_data.go b/db/gen/nidus-sync/public/model/note_audio_data.go new file mode 100644 index 00000000..e98bb747 --- /dev/null +++ b/db/gen/nidus-sync/public/model/note_audio_data.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "time" +) + +type NoteAudioData struct { + Created time.Time + NoteAudioVersion int32 `sql:"primary_key"` + NoteAudioUUID uuid.UUID `sql:"primary_key"` + Type Audiodatatype `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/public/model/note_image.go b/db/gen/nidus-sync/public/model/note_image.go new file mode 100644 index 00000000..d38e8da3 --- /dev/null +++ b/db/gen/nidus-sync/public/model/note_image.go @@ -0,0 +1,24 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "time" +) + +type NoteImage struct { + Created time.Time + CreatorID int32 + Deleted *time.Time + DeletorID *int32 + OrganizationID int32 + Version int32 `sql:"primary_key"` + UUID uuid.UUID `sql:"primary_key"` + ID int32 +} diff --git a/db/gen/nidus-sync/public/model/note_image_breadcrumb.go b/db/gen/nidus-sync/public/model/note_image_breadcrumb.go new file mode 100644 index 00000000..2c8d3230 --- /dev/null +++ b/db/gen/nidus-sync/public/model/note_image_breadcrumb.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "time" +) + +type NoteImageBreadcrumb struct { + Cell string + Created time.Time + ManuallySelected bool + NoteImageVersion int32 `sql:"primary_key"` + NoteImageUUID uuid.UUID `sql:"primary_key"` + Position int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/public/model/note_image_data.go b/db/gen/nidus-sync/public/model/note_image_data.go new file mode 100644 index 00000000..1a8417bd --- /dev/null +++ b/db/gen/nidus-sync/public/model/note_image_data.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "time" +) + +type NoteImageData struct { + Created time.Time + NoteImageVersion int32 `sql:"primary_key"` + NoteImageUUID uuid.UUID `sql:"primary_key"` + Type Audiodatatype `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/public/model/notification.go b/db/gen/nidus-sync/public/model/notification.go new file mode 100644 index 00000000..d548c505 --- /dev/null +++ b/db/gen/nidus-sync/public/model/notification.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type Notification struct { + ID int32 `sql:"primary_key"` + Created time.Time + Link string + Message string + Type Notificationtype + UserID int32 + ResolvedAt *time.Time +} diff --git a/db/gen/nidus-sync/public/model/notificationtype.go b/db/gen/nidus-sync/public/model/notificationtype.go new file mode 100644 index 00000000..8a4bf071 --- /dev/null +++ b/db/gen/nidus-sync/public/model/notificationtype.go @@ -0,0 +1,45 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Notificationtype string + +const ( + Notificationtype_OAuthTokenInvalidated Notificationtype = "oauth_token_invalidated" +) + +var NotificationtypeAllValues = []Notificationtype{ + Notificationtype_OAuthTokenInvalidated, +} + +func (e *Notificationtype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "oauth_token_invalidated": + *e = Notificationtype_OAuthTokenInvalidated + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Notificationtype enum") + } + + return nil +} + +func (e Notificationtype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/organization.go b/db/gen/nidus-sync/public/model/organization.go new file mode 100644 index 00000000..b7f08075 --- /dev/null +++ b/db/gen/nidus-sync/public/model/organization.go @@ -0,0 +1,51 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "github.com/twpayne/go-geom" +) + +type Organization struct { + ID int32 `sql:"primary_key"` + Name string + ImportDistrictGid *int32 + Website *string + LogoUUID *uuid.UUID + Slug *string + GeneralManagerName *string + MailingAddressCity *string + MailingAddressPostalCode *string + MailingAddressStreet *string + OfficeAddressCity *string + OfficeAddressPostalCode *string + OfficeAddressStreet *string + ServiceAreaGeometry *geom.T + ServiceAreaSquareMeters *float64 + ServiceAreaCentroid *geom.T + ServiceAreaExtent *geom.T + OfficeFax *string + OfficePhone *string + ServiceAreaXmin *float64 + ServiceAreaYmin *float64 + ServiceAreaXmax *float64 + ServiceAreaYmax *float64 + ServiceAreaCentroidGeojson *string + ServiceAreaCentroidX *float64 + ServiceAreaCentroidY *float64 + MailingAddressCountry *string + MailingAddressState *string + OfficeAddressCountry *string + OfficeAddressState *string + ArcgisAccountID *string + FieldseekerServiceFeatureItemID *string + ArcgisMapServiceID *string + IsCatchall bool + LobAddressID *string +} diff --git a/db/gen/nidus-sync/public/model/parcel.go b/db/gen/nidus-sync/public/model/parcel.go new file mode 100644 index 00000000..8854a75c --- /dev/null +++ b/db/gen/nidus-sync/public/model/parcel.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" +) + +type Parcel struct { + Apn *string + Description *string + ID int32 `sql:"primary_key"` + Geometry geom.T +} diff --git a/db/gen/nidus-sync/public/model/poolconditiontype.go b/db/gen/nidus-sync/public/model/poolconditiontype.go new file mode 100644 index 00000000..7f681f90 --- /dev/null +++ b/db/gen/nidus-sync/public/model/poolconditiontype.go @@ -0,0 +1,65 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Poolconditiontype string + +const ( + Poolconditiontype_Blue Poolconditiontype = "blue" + Poolconditiontype_Dry Poolconditiontype = "dry" + Poolconditiontype_FalsePool Poolconditiontype = "false pool" + Poolconditiontype_Unknown Poolconditiontype = "unknown" + Poolconditiontype_Green Poolconditiontype = "green" + Poolconditiontype_Murky Poolconditiontype = "murky" +) + +var PoolconditiontypeAllValues = []Poolconditiontype{ + Poolconditiontype_Blue, + Poolconditiontype_Dry, + Poolconditiontype_FalsePool, + Poolconditiontype_Unknown, + Poolconditiontype_Green, + Poolconditiontype_Murky, +} + +func (e *Poolconditiontype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "blue": + *e = Poolconditiontype_Blue + case "dry": + *e = Poolconditiontype_Dry + case "false pool": + *e = Poolconditiontype_FalsePool + case "unknown": + *e = Poolconditiontype_Unknown + case "green": + *e = Poolconditiontype_Green + case "murky": + *e = Poolconditiontype_Murky + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Poolconditiontype enum") + } + + return nil +} + +func (e Poolconditiontype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/raster_columns.go b/db/gen/nidus-sync/public/model/raster_columns.go new file mode 100644 index 00000000..d5f29168 --- /dev/null +++ b/db/gen/nidus-sync/public/model/raster_columns.go @@ -0,0 +1,32 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/lib/pq" +) + +type RasterColumns struct { + RTableCatalog *string + RTableSchema *string + RTableName *string + RRasterColumn *string + Srid *int32 + ScaleX *float64 + ScaleY *float64 + BlocksizeX *int32 + BlocksizeY *int32 + SameAlignment *bool + RegularBlocking *bool + NumBands *int32 + PixelTypes *pq.StringArray + NodataValues *pq.Float64Array + OutDb *pq.BoolArray + Extent *string + SpatialIndex *bool +} diff --git a/db/gen/nidus-sync/public/model/raster_overviews.go b/db/gen/nidus-sync/public/model/raster_overviews.go new file mode 100644 index 00000000..b59ca159 --- /dev/null +++ b/db/gen/nidus-sync/public/model/raster_overviews.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type RasterOverviews struct { + OTableCatalog *string + OTableSchema *string + OTableName *string + ORasterColumn *string + RTableCatalog *string + RTableSchema *string + RTableName *string + RRasterColumn *string + OverviewFactor *int32 +} diff --git a/db/gen/nidus-sync/public/model/report_text.go b/db/gen/nidus-sync/public/model/report_text.go new file mode 100644 index 00000000..80c822f9 --- /dev/null +++ b/db/gen/nidus-sync/public/model/report_text.go @@ -0,0 +1,14 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type ReportText struct { + CreatorID int32 `sql:"primary_key"` + ReportID int32 `sql:"primary_key"` + TextLogID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/public/model/resident.go b/db/gen/nidus-sync/public/model/resident.go new file mode 100644 index 00000000..c5de6a16 --- /dev/null +++ b/db/gen/nidus-sync/public/model/resident.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type Resident struct { + AddressID int32 + Created time.Time + Creator int32 + ID int32 `sql:"primary_key"` + Name string + PhoneMobile *string + SiteID int32 +} diff --git a/db/gen/nidus-sync/public/model/review_task.go b/db/gen/nidus-sync/public/model/review_task.go new file mode 100644 index 00000000..078dee56 --- /dev/null +++ b/db/gen/nidus-sync/public/model/review_task.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type ReviewTask struct { + Created time.Time + CreatorID *int32 + ID int32 `sql:"primary_key"` + OrganizationID int32 + Reviewed *time.Time + ReviewerID *int32 + Resolution *Reviewtaskresolutiontype +} diff --git a/db/gen/nidus-sync/public/model/review_task_pool.go b/db/gen/nidus-sync/public/model/review_task_pool.go new file mode 100644 index 00000000..3f4ade3a --- /dev/null +++ b/db/gen/nidus-sync/public/model/review_task_pool.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" +) + +type ReviewTaskPool struct { + FeaturePoolID int32 + Location *geom.T + Geometry *geom.T + ReviewTaskID int32 `sql:"primary_key"` + Condition *Poolconditiontype +} diff --git a/db/gen/nidus-sync/public/model/reviewtaskresolutiontype.go b/db/gen/nidus-sync/public/model/reviewtaskresolutiontype.go new file mode 100644 index 00000000..ab1cbcb1 --- /dev/null +++ b/db/gen/nidus-sync/public/model/reviewtaskresolutiontype.go @@ -0,0 +1,49 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Reviewtaskresolutiontype string + +const ( + Reviewtaskresolutiontype_Committed Reviewtaskresolutiontype = "committed" + Reviewtaskresolutiontype_Discarded Reviewtaskresolutiontype = "discarded" +) + +var ReviewtaskresolutiontypeAllValues = []Reviewtaskresolutiontype{ + Reviewtaskresolutiontype_Committed, + Reviewtaskresolutiontype_Discarded, +} + +func (e *Reviewtaskresolutiontype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "committed": + *e = Reviewtaskresolutiontype_Committed + case "discarded": + *e = Reviewtaskresolutiontype_Discarded + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Reviewtaskresolutiontype enum") + } + + return nil +} + +func (e Reviewtaskresolutiontype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/sessions.go b/db/gen/nidus-sync/public/model/sessions.go new file mode 100644 index 00000000..2f5530d2 --- /dev/null +++ b/db/gen/nidus-sync/public/model/sessions.go @@ -0,0 +1,18 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type Sessions struct { + Token string `sql:"primary_key"` + Data []byte + Expiry time.Time +} diff --git a/db/gen/nidus-sync/public/model/signal.go b/db/gen/nidus-sync/public/model/signal.go new file mode 100644 index 00000000..37241c1c --- /dev/null +++ b/db/gen/nidus-sync/public/model/signal.go @@ -0,0 +1,28 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" + "time" +) + +type Signal struct { + Addressed *time.Time + Addressor *int32 + Created time.Time + Creator int32 + ID int32 `sql:"primary_key"` + OrganizationID int32 + Species *Mosquitospecies + Type Signaltype + SiteID *int32 + Location geom.T + FeaturePoolFeatureID *int32 + ReportID *int32 +} diff --git a/db/gen/nidus-sync/public/model/signaltype.go b/db/gen/nidus-sync/public/model/signaltype.go new file mode 100644 index 00000000..d9310824 --- /dev/null +++ b/db/gen/nidus-sync/public/model/signaltype.go @@ -0,0 +1,69 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Signaltype string + +const ( + Signaltype_FlyoverPool Signaltype = "flyover pool" + Signaltype_PlanFollowup Signaltype = "plan followup" + Signaltype_PublicreportWater Signaltype = "publicreport water" + Signaltype_PublicreportNuisance Signaltype = "publicreport nuisance" + Signaltype_ResidualExiring Signaltype = "residual exiring" + Signaltype_SurveillanceObservation Signaltype = "surveillance observation" + Signaltype_TrapSpike Signaltype = "trap spike" +) + +var SignaltypeAllValues = []Signaltype{ + Signaltype_FlyoverPool, + Signaltype_PlanFollowup, + Signaltype_PublicreportWater, + Signaltype_PublicreportNuisance, + Signaltype_ResidualExiring, + Signaltype_SurveillanceObservation, + Signaltype_TrapSpike, +} + +func (e *Signaltype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "flyover pool": + *e = Signaltype_FlyoverPool + case "plan followup": + *e = Signaltype_PlanFollowup + case "publicreport water": + *e = Signaltype_PublicreportWater + case "publicreport nuisance": + *e = Signaltype_PublicreportNuisance + case "residual exiring": + *e = Signaltype_ResidualExiring + case "surveillance observation": + *e = Signaltype_SurveillanceObservation + case "trap spike": + *e = Signaltype_TrapSpike + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Signaltype enum") + } + + return nil +} + +func (e Signaltype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/model/site.go b/db/gen/nidus-sync/public/model/site.go new file mode 100644 index 00000000..f3420bd3 --- /dev/null +++ b/db/gen/nidus-sync/public/model/site.go @@ -0,0 +1,28 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type Site struct { + AddressID int32 + Created time.Time + CreatorID int32 + FileID *int32 + ID int32 `sql:"primary_key"` + Notes string + OrganizationID int32 + OwnerName string + OwnerPhoneE164 *string + ParcelID *int32 + ResidentOwned *bool + Tags string + Version int32 +} diff --git a/db/gen/nidus-sync/public/model/spatial_ref_sys.go b/db/gen/nidus-sync/public/model/spatial_ref_sys.go new file mode 100644 index 00000000..c6a99715 --- /dev/null +++ b/db/gen/nidus-sync/public/model/spatial_ref_sys.go @@ -0,0 +1,16 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type SpatialRefSys struct { + Srid int32 `sql:"primary_key"` + AuthName *string + AuthSrid *int32 + Srtext *string + Proj4text *string +} diff --git a/db/gen/nidus-sync/public/model/user_.go b/db/gen/nidus-sync/public/model/user_.go new file mode 100644 index 00000000..418a3ae2 --- /dev/null +++ b/db/gen/nidus-sync/public/model/user_.go @@ -0,0 +1,33 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "time" +) + +type User struct { + ID int32 `sql:"primary_key"` + ArcgisAccessToken *string + ArcgisLicense *Arcgislicensetype + ArcgisRefreshToken *string + ArcgisRefreshTokenExpires *time.Time + ArcgisRole *string + DisplayName string + Email *string + OrganizationID int32 + Username string + PasswordHashType Hashtype + PasswordHash string + Role Userrole + Avatar *uuid.UUID + IsActive bool + IsDronePilot bool + IsWarrant bool +} diff --git a/db/gen/nidus-sync/public/model/userrole.go b/db/gen/nidus-sync/public/model/userrole.go new file mode 100644 index 00000000..a0102431 --- /dev/null +++ b/db/gen/nidus-sync/public/model/userrole.go @@ -0,0 +1,49 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Userrole string + +const ( + Userrole_Root Userrole = "root" + Userrole_AccountOwner Userrole = "account-owner" +) + +var UserroleAllValues = []Userrole{ + Userrole_Root, + Userrole_AccountOwner, +} + +func (e *Userrole) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "root": + *e = Userrole_Root + case "account-owner": + *e = Userrole_AccountOwner + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Userrole enum") + } + + return nil +} + +func (e Userrole) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/public/table/address.go b/db/gen/nidus-sync/public/table/address.go new file mode 100644 index 00000000..97966e76 --- /dev/null +++ b/db/gen/nidus-sync/public/table/address.go @@ -0,0 +1,111 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Address = newAddressTable("public", "address", "") + +type addressTable struct { + postgres.Table + + // Columns + Country postgres.ColumnString + Created postgres.ColumnTimestamp + Location postgres.ColumnGeometry + H3cell postgres.ColumnString + ID postgres.ColumnInteger + Locality postgres.ColumnString + PostalCode postgres.ColumnString + Street postgres.ColumnString + Unit postgres.ColumnString + Region postgres.ColumnString + Number postgres.ColumnString + Gid postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type AddressTable struct { + addressTable + + EXCLUDED addressTable +} + +// AS creates new AddressTable with assigned alias +func (a AddressTable) AS(alias string) *AddressTable { + return newAddressTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new AddressTable with assigned schema name +func (a AddressTable) FromSchema(schemaName string) *AddressTable { + return newAddressTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new AddressTable with assigned table prefix +func (a AddressTable) WithPrefix(prefix string) *AddressTable { + return newAddressTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new AddressTable with assigned table suffix +func (a AddressTable) WithSuffix(suffix string) *AddressTable { + return newAddressTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newAddressTable(schemaName, tableName, alias string) *AddressTable { + return &AddressTable{ + addressTable: newAddressTableImpl(schemaName, tableName, alias), + EXCLUDED: newAddressTableImpl("", "excluded", ""), + } +} + +func newAddressTableImpl(schemaName, tableName, alias string) addressTable { + var ( + CountryColumn = postgres.StringColumn("country") + CreatedColumn = postgres.TimestampColumn("created") + LocationColumn = postgres.GeometryColumn("location") + H3cellColumn = postgres.StringColumn("h3cell") + IDColumn = postgres.IntegerColumn("id") + LocalityColumn = postgres.StringColumn("locality") + PostalCodeColumn = postgres.StringColumn("postal_code") + StreetColumn = postgres.StringColumn("street") + UnitColumn = postgres.StringColumn("unit") + RegionColumn = postgres.StringColumn("region") + NumberColumn = postgres.StringColumn("number_") + GidColumn = postgres.StringColumn("gid") + allColumns = postgres.ColumnList{CountryColumn, CreatedColumn, LocationColumn, H3cellColumn, IDColumn, LocalityColumn, PostalCodeColumn, StreetColumn, UnitColumn, RegionColumn, NumberColumn, GidColumn} + mutableColumns = postgres.ColumnList{CountryColumn, CreatedColumn, LocationColumn, H3cellColumn, LocalityColumn, PostalCodeColumn, StreetColumn, UnitColumn, RegionColumn, NumberColumn, GidColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return addressTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Country: CountryColumn, + Created: CreatedColumn, + Location: LocationColumn, + H3cell: H3cellColumn, + ID: IDColumn, + Locality: LocalityColumn, + PostalCode: PostalCodeColumn, + Street: StreetColumn, + Unit: UnitColumn, + Region: RegionColumn, + Number: NumberColumn, + Gid: GidColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/communication.go b/db/gen/nidus-sync/public/table/communication.go new file mode 100644 index 00000000..2d3d8ec0 --- /dev/null +++ b/db/gen/nidus-sync/public/table/communication.go @@ -0,0 +1,102 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Communication = newCommunicationTable("public", "communication", "") + +type communicationTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + ID postgres.ColumnInteger + OrganizationID postgres.ColumnInteger + ResponseEmailLogID postgres.ColumnInteger + ResponseTextLogID postgres.ColumnInteger + SourceEmailLogID postgres.ColumnInteger + SourceReportID postgres.ColumnInteger + SourceTextLogID postgres.ColumnInteger + Status postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type CommunicationTable struct { + communicationTable + + EXCLUDED communicationTable +} + +// AS creates new CommunicationTable with assigned alias +func (a CommunicationTable) AS(alias string) *CommunicationTable { + return newCommunicationTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new CommunicationTable with assigned schema name +func (a CommunicationTable) FromSchema(schemaName string) *CommunicationTable { + return newCommunicationTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new CommunicationTable with assigned table prefix +func (a CommunicationTable) WithPrefix(prefix string) *CommunicationTable { + return newCommunicationTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new CommunicationTable with assigned table suffix +func (a CommunicationTable) WithSuffix(suffix string) *CommunicationTable { + return newCommunicationTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newCommunicationTable(schemaName, tableName, alias string) *CommunicationTable { + return &CommunicationTable{ + communicationTable: newCommunicationTableImpl(schemaName, tableName, alias), + EXCLUDED: newCommunicationTableImpl("", "excluded", ""), + } +} + +func newCommunicationTableImpl(schemaName, tableName, alias string) communicationTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + IDColumn = postgres.IntegerColumn("id") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + ResponseEmailLogIDColumn = postgres.IntegerColumn("response_email_log_id") + ResponseTextLogIDColumn = postgres.IntegerColumn("response_text_log_id") + SourceEmailLogIDColumn = postgres.IntegerColumn("source_email_log_id") + SourceReportIDColumn = postgres.IntegerColumn("source_report_id") + SourceTextLogIDColumn = postgres.IntegerColumn("source_text_log_id") + StatusColumn = postgres.StringColumn("status") + allColumns = postgres.ColumnList{CreatedColumn, IDColumn, OrganizationIDColumn, ResponseEmailLogIDColumn, ResponseTextLogIDColumn, SourceEmailLogIDColumn, SourceReportIDColumn, SourceTextLogIDColumn, StatusColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, OrganizationIDColumn, ResponseEmailLogIDColumn, ResponseTextLogIDColumn, SourceEmailLogIDColumn, SourceReportIDColumn, SourceTextLogIDColumn, StatusColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return communicationTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + ID: IDColumn, + OrganizationID: OrganizationIDColumn, + ResponseEmailLogID: ResponseEmailLogIDColumn, + ResponseTextLogID: ResponseTextLogIDColumn, + SourceEmailLogID: SourceEmailLogIDColumn, + SourceReportID: SourceReportIDColumn, + SourceTextLogID: SourceTextLogIDColumn, + Status: StatusColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/communication_log_entry.go b/db/gen/nidus-sync/public/table/communication_log_entry.go new file mode 100644 index 00000000..945c7ffe --- /dev/null +++ b/db/gen/nidus-sync/public/table/communication_log_entry.go @@ -0,0 +1,90 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var CommunicationLogEntry = newCommunicationLogEntryTable("public", "communication_log_entry", "") + +type communicationLogEntryTable struct { + postgres.Table + + // Columns + CommunicationID postgres.ColumnInteger + Created postgres.ColumnTimestamp + ID postgres.ColumnInteger + Type postgres.ColumnString + User postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type CommunicationLogEntryTable struct { + communicationLogEntryTable + + EXCLUDED communicationLogEntryTable +} + +// AS creates new CommunicationLogEntryTable with assigned alias +func (a CommunicationLogEntryTable) AS(alias string) *CommunicationLogEntryTable { + return newCommunicationLogEntryTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new CommunicationLogEntryTable with assigned schema name +func (a CommunicationLogEntryTable) FromSchema(schemaName string) *CommunicationLogEntryTable { + return newCommunicationLogEntryTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new CommunicationLogEntryTable with assigned table prefix +func (a CommunicationLogEntryTable) WithPrefix(prefix string) *CommunicationLogEntryTable { + return newCommunicationLogEntryTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new CommunicationLogEntryTable with assigned table suffix +func (a CommunicationLogEntryTable) WithSuffix(suffix string) *CommunicationLogEntryTable { + return newCommunicationLogEntryTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newCommunicationLogEntryTable(schemaName, tableName, alias string) *CommunicationLogEntryTable { + return &CommunicationLogEntryTable{ + communicationLogEntryTable: newCommunicationLogEntryTableImpl(schemaName, tableName, alias), + EXCLUDED: newCommunicationLogEntryTableImpl("", "excluded", ""), + } +} + +func newCommunicationLogEntryTableImpl(schemaName, tableName, alias string) communicationLogEntryTable { + var ( + CommunicationIDColumn = postgres.IntegerColumn("communication_id") + CreatedColumn = postgres.TimestampColumn("created") + IDColumn = postgres.IntegerColumn("id") + TypeColumn = postgres.StringColumn("type_") + UserColumn = postgres.IntegerColumn("user_") + allColumns = postgres.ColumnList{CommunicationIDColumn, CreatedColumn, IDColumn, TypeColumn, UserColumn} + mutableColumns = postgres.ColumnList{CommunicationIDColumn, CreatedColumn, TypeColumn, UserColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return communicationLogEntryTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + CommunicationID: CommunicationIDColumn, + Created: CreatedColumn, + ID: IDColumn, + Type: TypeColumn, + User: UserColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/compliance_report_request.go b/db/gen/nidus-sync/public/table/compliance_report_request.go new file mode 100644 index 00000000..65982f75 --- /dev/null +++ b/db/gen/nidus-sync/public/table/compliance_report_request.go @@ -0,0 +1,90 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ComplianceReportRequest = newComplianceReportRequestTable("public", "compliance_report_request", "") + +type complianceReportRequestTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Creator postgres.ColumnInteger + ID postgres.ColumnInteger + PublicID postgres.ColumnString + LeadID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ComplianceReportRequestTable struct { + complianceReportRequestTable + + EXCLUDED complianceReportRequestTable +} + +// AS creates new ComplianceReportRequestTable with assigned alias +func (a ComplianceReportRequestTable) AS(alias string) *ComplianceReportRequestTable { + return newComplianceReportRequestTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ComplianceReportRequestTable with assigned schema name +func (a ComplianceReportRequestTable) FromSchema(schemaName string) *ComplianceReportRequestTable { + return newComplianceReportRequestTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ComplianceReportRequestTable with assigned table prefix +func (a ComplianceReportRequestTable) WithPrefix(prefix string) *ComplianceReportRequestTable { + return newComplianceReportRequestTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ComplianceReportRequestTable with assigned table suffix +func (a ComplianceReportRequestTable) WithSuffix(suffix string) *ComplianceReportRequestTable { + return newComplianceReportRequestTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newComplianceReportRequestTable(schemaName, tableName, alias string) *ComplianceReportRequestTable { + return &ComplianceReportRequestTable{ + complianceReportRequestTable: newComplianceReportRequestTableImpl(schemaName, tableName, alias), + EXCLUDED: newComplianceReportRequestTableImpl("", "excluded", ""), + } +} + +func newComplianceReportRequestTableImpl(schemaName, tableName, alias string) complianceReportRequestTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + CreatorColumn = postgres.IntegerColumn("creator") + IDColumn = postgres.IntegerColumn("id") + PublicIDColumn = postgres.StringColumn("public_id") + LeadIDColumn = postgres.IntegerColumn("lead_id") + allColumns = postgres.ColumnList{CreatedColumn, CreatorColumn, IDColumn, PublicIDColumn, LeadIDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, CreatorColumn, PublicIDColumn, LeadIDColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return complianceReportRequestTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Creator: CreatorColumn, + ID: IDColumn, + PublicID: PublicIDColumn, + LeadID: LeadIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/compliance_report_request_mailer.go b/db/gen/nidus-sync/public/table/compliance_report_request_mailer.go new file mode 100644 index 00000000..a88fa47a --- /dev/null +++ b/db/gen/nidus-sync/public/table/compliance_report_request_mailer.go @@ -0,0 +1,84 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ComplianceReportRequestMailer = newComplianceReportRequestMailerTable("public", "compliance_report_request_mailer", "") + +type complianceReportRequestMailerTable struct { + postgres.Table + + // Columns + ComplianceReportRequestID postgres.ColumnInteger + MailerID postgres.ColumnInteger + ID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ComplianceReportRequestMailerTable struct { + complianceReportRequestMailerTable + + EXCLUDED complianceReportRequestMailerTable +} + +// AS creates new ComplianceReportRequestMailerTable with assigned alias +func (a ComplianceReportRequestMailerTable) AS(alias string) *ComplianceReportRequestMailerTable { + return newComplianceReportRequestMailerTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ComplianceReportRequestMailerTable with assigned schema name +func (a ComplianceReportRequestMailerTable) FromSchema(schemaName string) *ComplianceReportRequestMailerTable { + return newComplianceReportRequestMailerTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ComplianceReportRequestMailerTable with assigned table prefix +func (a ComplianceReportRequestMailerTable) WithPrefix(prefix string) *ComplianceReportRequestMailerTable { + return newComplianceReportRequestMailerTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ComplianceReportRequestMailerTable with assigned table suffix +func (a ComplianceReportRequestMailerTable) WithSuffix(suffix string) *ComplianceReportRequestMailerTable { + return newComplianceReportRequestMailerTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newComplianceReportRequestMailerTable(schemaName, tableName, alias string) *ComplianceReportRequestMailerTable { + return &ComplianceReportRequestMailerTable{ + complianceReportRequestMailerTable: newComplianceReportRequestMailerTableImpl(schemaName, tableName, alias), + EXCLUDED: newComplianceReportRequestMailerTableImpl("", "excluded", ""), + } +} + +func newComplianceReportRequestMailerTableImpl(schemaName, tableName, alias string) complianceReportRequestMailerTable { + var ( + ComplianceReportRequestIDColumn = postgres.IntegerColumn("compliance_report_request_id") + MailerIDColumn = postgres.IntegerColumn("mailer_id") + IDColumn = postgres.IntegerColumn("id") + allColumns = postgres.ColumnList{ComplianceReportRequestIDColumn, MailerIDColumn, IDColumn} + mutableColumns = postgres.ColumnList{ComplianceReportRequestIDColumn, MailerIDColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return complianceReportRequestMailerTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ComplianceReportRequestID: ComplianceReportRequestIDColumn, + MailerID: MailerIDColumn, + ID: IDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/district_subscription_email.go b/db/gen/nidus-sync/public/table/district_subscription_email.go new file mode 100644 index 00000000..b5d44e9a --- /dev/null +++ b/db/gen/nidus-sync/public/table/district_subscription_email.go @@ -0,0 +1,81 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var DistrictSubscriptionEmail = newDistrictSubscriptionEmailTable("public", "district_subscription_email", "") + +type districtSubscriptionEmailTable struct { + postgres.Table + + // Columns + OrganizationID postgres.ColumnInteger + EmailContactAddress postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type DistrictSubscriptionEmailTable struct { + districtSubscriptionEmailTable + + EXCLUDED districtSubscriptionEmailTable +} + +// AS creates new DistrictSubscriptionEmailTable with assigned alias +func (a DistrictSubscriptionEmailTable) AS(alias string) *DistrictSubscriptionEmailTable { + return newDistrictSubscriptionEmailTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new DistrictSubscriptionEmailTable with assigned schema name +func (a DistrictSubscriptionEmailTable) FromSchema(schemaName string) *DistrictSubscriptionEmailTable { + return newDistrictSubscriptionEmailTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new DistrictSubscriptionEmailTable with assigned table prefix +func (a DistrictSubscriptionEmailTable) WithPrefix(prefix string) *DistrictSubscriptionEmailTable { + return newDistrictSubscriptionEmailTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new DistrictSubscriptionEmailTable with assigned table suffix +func (a DistrictSubscriptionEmailTable) WithSuffix(suffix string) *DistrictSubscriptionEmailTable { + return newDistrictSubscriptionEmailTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newDistrictSubscriptionEmailTable(schemaName, tableName, alias string) *DistrictSubscriptionEmailTable { + return &DistrictSubscriptionEmailTable{ + districtSubscriptionEmailTable: newDistrictSubscriptionEmailTableImpl(schemaName, tableName, alias), + EXCLUDED: newDistrictSubscriptionEmailTableImpl("", "excluded", ""), + } +} + +func newDistrictSubscriptionEmailTableImpl(schemaName, tableName, alias string) districtSubscriptionEmailTable { + var ( + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + EmailContactAddressColumn = postgres.StringColumn("email_contact_address") + allColumns = postgres.ColumnList{OrganizationIDColumn, EmailContactAddressColumn} + mutableColumns = postgres.ColumnList{} + defaultColumns = postgres.ColumnList{} + ) + + return districtSubscriptionEmailTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + OrganizationID: OrganizationIDColumn, + EmailContactAddress: EmailContactAddressColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/district_subscription_phone.go b/db/gen/nidus-sync/public/table/district_subscription_phone.go new file mode 100644 index 00000000..d3d921b4 --- /dev/null +++ b/db/gen/nidus-sync/public/table/district_subscription_phone.go @@ -0,0 +1,81 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var DistrictSubscriptionPhone = newDistrictSubscriptionPhoneTable("public", "district_subscription_phone", "") + +type districtSubscriptionPhoneTable struct { + postgres.Table + + // Columns + OrganizationID postgres.ColumnInteger + PhoneE164 postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type DistrictSubscriptionPhoneTable struct { + districtSubscriptionPhoneTable + + EXCLUDED districtSubscriptionPhoneTable +} + +// AS creates new DistrictSubscriptionPhoneTable with assigned alias +func (a DistrictSubscriptionPhoneTable) AS(alias string) *DistrictSubscriptionPhoneTable { + return newDistrictSubscriptionPhoneTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new DistrictSubscriptionPhoneTable with assigned schema name +func (a DistrictSubscriptionPhoneTable) FromSchema(schemaName string) *DistrictSubscriptionPhoneTable { + return newDistrictSubscriptionPhoneTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new DistrictSubscriptionPhoneTable with assigned table prefix +func (a DistrictSubscriptionPhoneTable) WithPrefix(prefix string) *DistrictSubscriptionPhoneTable { + return newDistrictSubscriptionPhoneTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new DistrictSubscriptionPhoneTable with assigned table suffix +func (a DistrictSubscriptionPhoneTable) WithSuffix(suffix string) *DistrictSubscriptionPhoneTable { + return newDistrictSubscriptionPhoneTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newDistrictSubscriptionPhoneTable(schemaName, tableName, alias string) *DistrictSubscriptionPhoneTable { + return &DistrictSubscriptionPhoneTable{ + districtSubscriptionPhoneTable: newDistrictSubscriptionPhoneTableImpl(schemaName, tableName, alias), + EXCLUDED: newDistrictSubscriptionPhoneTableImpl("", "excluded", ""), + } +} + +func newDistrictSubscriptionPhoneTableImpl(schemaName, tableName, alias string) districtSubscriptionPhoneTable { + var ( + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + PhoneE164Column = postgres.StringColumn("phone_e164") + allColumns = postgres.ColumnList{OrganizationIDColumn, PhoneE164Column} + mutableColumns = postgres.ColumnList{} + defaultColumns = postgres.ColumnList{} + ) + + return districtSubscriptionPhoneTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + OrganizationID: OrganizationIDColumn, + PhoneE164: PhoneE164Column, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/feature.go b/db/gen/nidus-sync/public/table/feature.go new file mode 100644 index 00000000..8b6d6802 --- /dev/null +++ b/db/gen/nidus-sync/public/table/feature.go @@ -0,0 +1,93 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Feature = newFeatureTable("public", "feature", "") + +type featureTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + CreatorID postgres.ColumnInteger + ID postgres.ColumnInteger + OrganizationID postgres.ColumnInteger + SiteID postgres.ColumnInteger + Location postgres.ColumnGeometry + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type FeatureTable struct { + featureTable + + EXCLUDED featureTable +} + +// AS creates new FeatureTable with assigned alias +func (a FeatureTable) AS(alias string) *FeatureTable { + return newFeatureTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new FeatureTable with assigned schema name +func (a FeatureTable) FromSchema(schemaName string) *FeatureTable { + return newFeatureTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new FeatureTable with assigned table prefix +func (a FeatureTable) WithPrefix(prefix string) *FeatureTable { + return newFeatureTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new FeatureTable with assigned table suffix +func (a FeatureTable) WithSuffix(suffix string) *FeatureTable { + return newFeatureTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newFeatureTable(schemaName, tableName, alias string) *FeatureTable { + return &FeatureTable{ + featureTable: newFeatureTableImpl(schemaName, tableName, alias), + EXCLUDED: newFeatureTableImpl("", "excluded", ""), + } +} + +func newFeatureTableImpl(schemaName, tableName, alias string) featureTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + CreatorIDColumn = postgres.IntegerColumn("creator_id") + IDColumn = postgres.IntegerColumn("id") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + SiteIDColumn = postgres.IntegerColumn("site_id") + LocationColumn = postgres.GeometryColumn("location") + allColumns = postgres.ColumnList{CreatedColumn, CreatorIDColumn, IDColumn, OrganizationIDColumn, SiteIDColumn, LocationColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, CreatorIDColumn, OrganizationIDColumn, SiteIDColumn, LocationColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return featureTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + CreatorID: CreatorIDColumn, + ID: IDColumn, + OrganizationID: OrganizationIDColumn, + SiteID: SiteIDColumn, + Location: LocationColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/feature_pool.go b/db/gen/nidus-sync/public/table/feature_pool.go new file mode 100644 index 00000000..235528e7 --- /dev/null +++ b/db/gen/nidus-sync/public/table/feature_pool.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var FeaturePool = newFeaturePoolTable("public", "feature_pool", "") + +type featurePoolTable struct { + postgres.Table + + // Columns + FeatureID postgres.ColumnInteger + Condition postgres.ColumnString + DepthMeters postgres.ColumnFloat + Geometry postgres.ColumnGeometry + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type FeaturePoolTable struct { + featurePoolTable + + EXCLUDED featurePoolTable +} + +// AS creates new FeaturePoolTable with assigned alias +func (a FeaturePoolTable) AS(alias string) *FeaturePoolTable { + return newFeaturePoolTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new FeaturePoolTable with assigned schema name +func (a FeaturePoolTable) FromSchema(schemaName string) *FeaturePoolTable { + return newFeaturePoolTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new FeaturePoolTable with assigned table prefix +func (a FeaturePoolTable) WithPrefix(prefix string) *FeaturePoolTable { + return newFeaturePoolTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new FeaturePoolTable with assigned table suffix +func (a FeaturePoolTable) WithSuffix(suffix string) *FeaturePoolTable { + return newFeaturePoolTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newFeaturePoolTable(schemaName, tableName, alias string) *FeaturePoolTable { + return &FeaturePoolTable{ + featurePoolTable: newFeaturePoolTableImpl(schemaName, tableName, alias), + EXCLUDED: newFeaturePoolTableImpl("", "excluded", ""), + } +} + +func newFeaturePoolTableImpl(schemaName, tableName, alias string) featurePoolTable { + var ( + FeatureIDColumn = postgres.IntegerColumn("feature_id") + ConditionColumn = postgres.StringColumn("condition") + DepthMetersColumn = postgres.FloatColumn("depth_meters") + GeometryColumn = postgres.GeometryColumn("geometry") + allColumns = postgres.ColumnList{FeatureIDColumn, ConditionColumn, DepthMetersColumn, GeometryColumn} + mutableColumns = postgres.ColumnList{ConditionColumn, DepthMetersColumn, GeometryColumn} + defaultColumns = postgres.ColumnList{} + ) + + return featurePoolTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + FeatureID: FeatureIDColumn, + Condition: ConditionColumn, + DepthMeters: DepthMetersColumn, + Geometry: GeometryColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/fieldseeker_sync.go b/db/gen/nidus-sync/public/table/fieldseeker_sync.go new file mode 100644 index 00000000..25c03bac --- /dev/null +++ b/db/gen/nidus-sync/public/table/fieldseeker_sync.go @@ -0,0 +1,93 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var FieldseekerSync = newFieldseekerSyncTable("public", "fieldseeker_sync", "") + +type fieldseekerSyncTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + Created postgres.ColumnTimestamp + RecordsCreated postgres.ColumnInteger + RecordsUpdated postgres.ColumnInteger + RecordsUnchanged postgres.ColumnInteger + OrganizationID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type FieldseekerSyncTable struct { + fieldseekerSyncTable + + EXCLUDED fieldseekerSyncTable +} + +// AS creates new FieldseekerSyncTable with assigned alias +func (a FieldseekerSyncTable) AS(alias string) *FieldseekerSyncTable { + return newFieldseekerSyncTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new FieldseekerSyncTable with assigned schema name +func (a FieldseekerSyncTable) FromSchema(schemaName string) *FieldseekerSyncTable { + return newFieldseekerSyncTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new FieldseekerSyncTable with assigned table prefix +func (a FieldseekerSyncTable) WithPrefix(prefix string) *FieldseekerSyncTable { + return newFieldseekerSyncTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new FieldseekerSyncTable with assigned table suffix +func (a FieldseekerSyncTable) WithSuffix(suffix string) *FieldseekerSyncTable { + return newFieldseekerSyncTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newFieldseekerSyncTable(schemaName, tableName, alias string) *FieldseekerSyncTable { + return &FieldseekerSyncTable{ + fieldseekerSyncTable: newFieldseekerSyncTableImpl(schemaName, tableName, alias), + EXCLUDED: newFieldseekerSyncTableImpl("", "excluded", ""), + } +} + +func newFieldseekerSyncTableImpl(schemaName, tableName, alias string) fieldseekerSyncTable { + var ( + IDColumn = postgres.IntegerColumn("id") + CreatedColumn = postgres.TimestampColumn("created") + RecordsCreatedColumn = postgres.IntegerColumn("records_created") + RecordsUpdatedColumn = postgres.IntegerColumn("records_updated") + RecordsUnchangedColumn = postgres.IntegerColumn("records_unchanged") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + allColumns = postgres.ColumnList{IDColumn, CreatedColumn, RecordsCreatedColumn, RecordsUpdatedColumn, RecordsUnchangedColumn, OrganizationIDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, RecordsCreatedColumn, RecordsUpdatedColumn, RecordsUnchangedColumn, OrganizationIDColumn} + defaultColumns = postgres.ColumnList{IDColumn, CreatedColumn} + ) + + return fieldseekerSyncTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + Created: CreatedColumn, + RecordsCreated: RecordsCreatedColumn, + RecordsUpdated: RecordsUpdatedColumn, + RecordsUnchanged: RecordsUnchangedColumn, + OrganizationID: OrganizationIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/goose_db_version.go b/db/gen/nidus-sync/public/table/goose_db_version.go new file mode 100644 index 00000000..a5a9ac41 --- /dev/null +++ b/db/gen/nidus-sync/public/table/goose_db_version.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var GooseDbVersion = newGooseDbVersionTable("public", "goose_db_version", "") + +type gooseDbVersionTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + VersionID postgres.ColumnInteger + IsApplied postgres.ColumnBool + Tstamp postgres.ColumnTimestamp + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type GooseDbVersionTable struct { + gooseDbVersionTable + + EXCLUDED gooseDbVersionTable +} + +// AS creates new GooseDbVersionTable with assigned alias +func (a GooseDbVersionTable) AS(alias string) *GooseDbVersionTable { + return newGooseDbVersionTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new GooseDbVersionTable with assigned schema name +func (a GooseDbVersionTable) FromSchema(schemaName string) *GooseDbVersionTable { + return newGooseDbVersionTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new GooseDbVersionTable with assigned table prefix +func (a GooseDbVersionTable) WithPrefix(prefix string) *GooseDbVersionTable { + return newGooseDbVersionTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new GooseDbVersionTable with assigned table suffix +func (a GooseDbVersionTable) WithSuffix(suffix string) *GooseDbVersionTable { + return newGooseDbVersionTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newGooseDbVersionTable(schemaName, tableName, alias string) *GooseDbVersionTable { + return &GooseDbVersionTable{ + gooseDbVersionTable: newGooseDbVersionTableImpl(schemaName, tableName, alias), + EXCLUDED: newGooseDbVersionTableImpl("", "excluded", ""), + } +} + +func newGooseDbVersionTableImpl(schemaName, tableName, alias string) gooseDbVersionTable { + var ( + IDColumn = postgres.IntegerColumn("id") + VersionIDColumn = postgres.IntegerColumn("version_id") + IsAppliedColumn = postgres.BoolColumn("is_applied") + TstampColumn = postgres.TimestampColumn("tstamp") + allColumns = postgres.ColumnList{IDColumn, VersionIDColumn, IsAppliedColumn, TstampColumn} + mutableColumns = postgres.ColumnList{VersionIDColumn, IsAppliedColumn, TstampColumn} + defaultColumns = postgres.ColumnList{TstampColumn} + ) + + return gooseDbVersionTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + VersionID: VersionIDColumn, + IsApplied: IsAppliedColumn, + Tstamp: TstampColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/h3_aggregation.go b/db/gen/nidus-sync/public/table/h3_aggregation.go new file mode 100644 index 00000000..8cd3c75c --- /dev/null +++ b/db/gen/nidus-sync/public/table/h3_aggregation.go @@ -0,0 +1,96 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var H3Aggregation = newH3AggregationTable("public", "h3_aggregation", "") + +type h3AggregationTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + Cell postgres.ColumnString + Count postgres.ColumnInteger + Geometry postgres.ColumnGeometry + OrganizationID postgres.ColumnInteger + Resolution postgres.ColumnInteger + Type postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type H3AggregationTable struct { + h3AggregationTable + + EXCLUDED h3AggregationTable +} + +// AS creates new H3AggregationTable with assigned alias +func (a H3AggregationTable) AS(alias string) *H3AggregationTable { + return newH3AggregationTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new H3AggregationTable with assigned schema name +func (a H3AggregationTable) FromSchema(schemaName string) *H3AggregationTable { + return newH3AggregationTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new H3AggregationTable with assigned table prefix +func (a H3AggregationTable) WithPrefix(prefix string) *H3AggregationTable { + return newH3AggregationTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new H3AggregationTable with assigned table suffix +func (a H3AggregationTable) WithSuffix(suffix string) *H3AggregationTable { + return newH3AggregationTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newH3AggregationTable(schemaName, tableName, alias string) *H3AggregationTable { + return &H3AggregationTable{ + h3AggregationTable: newH3AggregationTableImpl(schemaName, tableName, alias), + EXCLUDED: newH3AggregationTableImpl("", "excluded", ""), + } +} + +func newH3AggregationTableImpl(schemaName, tableName, alias string) h3AggregationTable { + var ( + IDColumn = postgres.IntegerColumn("id") + CellColumn = postgres.StringColumn("cell") + CountColumn = postgres.IntegerColumn("count_") + GeometryColumn = postgres.GeometryColumn("geometry") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + ResolutionColumn = postgres.IntegerColumn("resolution") + TypeColumn = postgres.StringColumn("type_") + allColumns = postgres.ColumnList{IDColumn, CellColumn, CountColumn, GeometryColumn, OrganizationIDColumn, ResolutionColumn, TypeColumn} + mutableColumns = postgres.ColumnList{CellColumn, CountColumn, GeometryColumn, OrganizationIDColumn, ResolutionColumn, TypeColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return h3AggregationTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + Cell: CellColumn, + Count: CountColumn, + Geometry: GeometryColumn, + OrganizationID: OrganizationIDColumn, + Resolution: ResolutionColumn, + Type: TypeColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/job.go b/db/gen/nidus-sync/public/table/job.go new file mode 100644 index 00000000..02e1016c --- /dev/null +++ b/db/gen/nidus-sync/public/table/job.go @@ -0,0 +1,88 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Job = newJobTable("public", "job", "") + +// A temporary holding place for jobs that are pushed to backend workers. Once work is completed the job should be deleted +type jobTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + ID postgres.ColumnInteger + Type postgres.ColumnString + RowID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type JobTable struct { + jobTable + + EXCLUDED jobTable +} + +// AS creates new JobTable with assigned alias +func (a JobTable) AS(alias string) *JobTable { + return newJobTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new JobTable with assigned schema name +func (a JobTable) FromSchema(schemaName string) *JobTable { + return newJobTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new JobTable with assigned table prefix +func (a JobTable) WithPrefix(prefix string) *JobTable { + return newJobTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new JobTable with assigned table suffix +func (a JobTable) WithSuffix(suffix string) *JobTable { + return newJobTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newJobTable(schemaName, tableName, alias string) *JobTable { + return &JobTable{ + jobTable: newJobTableImpl(schemaName, tableName, alias), + EXCLUDED: newJobTableImpl("", "excluded", ""), + } +} + +func newJobTableImpl(schemaName, tableName, alias string) jobTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + IDColumn = postgres.IntegerColumn("id") + TypeColumn = postgres.StringColumn("type_") + RowIDColumn = postgres.IntegerColumn("row_id") + allColumns = postgres.ColumnList{CreatedColumn, IDColumn, TypeColumn, RowIDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, TypeColumn, RowIDColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return jobTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + ID: IDColumn, + Type: TypeColumn, + RowID: RowIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/lead.go b/db/gen/nidus-sync/public/table/lead.go new file mode 100644 index 00000000..48c5d9ca --- /dev/null +++ b/db/gen/nidus-sync/public/table/lead.go @@ -0,0 +1,93 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Lead = newLeadTable("public", "lead", "") + +type leadTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Creator postgres.ColumnInteger + ID postgres.ColumnInteger + OrganizationID postgres.ColumnInteger + SiteID postgres.ColumnInteger + Type postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type LeadTable struct { + leadTable + + EXCLUDED leadTable +} + +// AS creates new LeadTable with assigned alias +func (a LeadTable) AS(alias string) *LeadTable { + return newLeadTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new LeadTable with assigned schema name +func (a LeadTable) FromSchema(schemaName string) *LeadTable { + return newLeadTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new LeadTable with assigned table prefix +func (a LeadTable) WithPrefix(prefix string) *LeadTable { + return newLeadTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new LeadTable with assigned table suffix +func (a LeadTable) WithSuffix(suffix string) *LeadTable { + return newLeadTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newLeadTable(schemaName, tableName, alias string) *LeadTable { + return &LeadTable{ + leadTable: newLeadTableImpl(schemaName, tableName, alias), + EXCLUDED: newLeadTableImpl("", "excluded", ""), + } +} + +func newLeadTableImpl(schemaName, tableName, alias string) leadTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + CreatorColumn = postgres.IntegerColumn("creator") + IDColumn = postgres.IntegerColumn("id") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + SiteIDColumn = postgres.IntegerColumn("site_id") + TypeColumn = postgres.StringColumn("type_") + allColumns = postgres.ColumnList{CreatedColumn, CreatorColumn, IDColumn, OrganizationIDColumn, SiteIDColumn, TypeColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, CreatorColumn, OrganizationIDColumn, SiteIDColumn, TypeColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return leadTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Creator: CreatorColumn, + ID: IDColumn, + OrganizationID: OrganizationIDColumn, + SiteID: SiteIDColumn, + Type: TypeColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/log_impersonation.go b/db/gen/nidus-sync/public/table/log_impersonation.go new file mode 100644 index 00000000..674f4235 --- /dev/null +++ b/db/gen/nidus-sync/public/table/log_impersonation.go @@ -0,0 +1,90 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var LogImpersonation = newLogImpersonationTable("public", "log_impersonation", "") + +type logImpersonationTable struct { + postgres.Table + + // Columns + BeginAt postgres.ColumnTimestamp + EndAt postgres.ColumnTimestamp + ID postgres.ColumnInteger + ImpersonatorID postgres.ColumnInteger + TargetID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type LogImpersonationTable struct { + logImpersonationTable + + EXCLUDED logImpersonationTable +} + +// AS creates new LogImpersonationTable with assigned alias +func (a LogImpersonationTable) AS(alias string) *LogImpersonationTable { + return newLogImpersonationTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new LogImpersonationTable with assigned schema name +func (a LogImpersonationTable) FromSchema(schemaName string) *LogImpersonationTable { + return newLogImpersonationTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new LogImpersonationTable with assigned table prefix +func (a LogImpersonationTable) WithPrefix(prefix string) *LogImpersonationTable { + return newLogImpersonationTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new LogImpersonationTable with assigned table suffix +func (a LogImpersonationTable) WithSuffix(suffix string) *LogImpersonationTable { + return newLogImpersonationTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newLogImpersonationTable(schemaName, tableName, alias string) *LogImpersonationTable { + return &LogImpersonationTable{ + logImpersonationTable: newLogImpersonationTableImpl(schemaName, tableName, alias), + EXCLUDED: newLogImpersonationTableImpl("", "excluded", ""), + } +} + +func newLogImpersonationTableImpl(schemaName, tableName, alias string) logImpersonationTable { + var ( + BeginAtColumn = postgres.TimestampColumn("begin_at") + EndAtColumn = postgres.TimestampColumn("end_at") + IDColumn = postgres.IntegerColumn("id") + ImpersonatorIDColumn = postgres.IntegerColumn("impersonator_id") + TargetIDColumn = postgres.IntegerColumn("target_id") + allColumns = postgres.ColumnList{BeginAtColumn, EndAtColumn, IDColumn, ImpersonatorIDColumn, TargetIDColumn} + mutableColumns = postgres.ColumnList{BeginAtColumn, EndAtColumn, ImpersonatorIDColumn, TargetIDColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return logImpersonationTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + BeginAt: BeginAtColumn, + EndAt: EndAtColumn, + ID: IDColumn, + ImpersonatorID: ImpersonatorIDColumn, + TargetID: TargetIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/note_audio.go b/db/gen/nidus-sync/public/table/note_audio.go new file mode 100644 index 00000000..ee308da4 --- /dev/null +++ b/db/gen/nidus-sync/public/table/note_audio.go @@ -0,0 +1,108 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NoteAudio = newNoteAudioTable("public", "note_audio", "") + +type noteAudioTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + CreatorID postgres.ColumnInteger + Deleted postgres.ColumnTimestamp + DeletorID postgres.ColumnInteger + Duration postgres.ColumnFloat + OrganizationID postgres.ColumnInteger + Transcription postgres.ColumnString + TranscriptionUserEdited postgres.ColumnBool + Version postgres.ColumnInteger + UUID postgres.ColumnString + ID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NoteAudioTable struct { + noteAudioTable + + EXCLUDED noteAudioTable +} + +// AS creates new NoteAudioTable with assigned alias +func (a NoteAudioTable) AS(alias string) *NoteAudioTable { + return newNoteAudioTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NoteAudioTable with assigned schema name +func (a NoteAudioTable) FromSchema(schemaName string) *NoteAudioTable { + return newNoteAudioTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NoteAudioTable with assigned table prefix +func (a NoteAudioTable) WithPrefix(prefix string) *NoteAudioTable { + return newNoteAudioTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NoteAudioTable with assigned table suffix +func (a NoteAudioTable) WithSuffix(suffix string) *NoteAudioTable { + return newNoteAudioTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNoteAudioTable(schemaName, tableName, alias string) *NoteAudioTable { + return &NoteAudioTable{ + noteAudioTable: newNoteAudioTableImpl(schemaName, tableName, alias), + EXCLUDED: newNoteAudioTableImpl("", "excluded", ""), + } +} + +func newNoteAudioTableImpl(schemaName, tableName, alias string) noteAudioTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + CreatorIDColumn = postgres.IntegerColumn("creator_id") + DeletedColumn = postgres.TimestampColumn("deleted") + DeletorIDColumn = postgres.IntegerColumn("deletor_id") + DurationColumn = postgres.FloatColumn("duration") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + TranscriptionColumn = postgres.StringColumn("transcription") + TranscriptionUserEditedColumn = postgres.BoolColumn("transcription_user_edited") + VersionColumn = postgres.IntegerColumn("version") + UUIDColumn = postgres.StringColumn("uuid") + IDColumn = postgres.IntegerColumn("id") + allColumns = postgres.ColumnList{CreatedColumn, CreatorIDColumn, DeletedColumn, DeletorIDColumn, DurationColumn, OrganizationIDColumn, TranscriptionColumn, TranscriptionUserEditedColumn, VersionColumn, UUIDColumn, IDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, CreatorIDColumn, DeletedColumn, DeletorIDColumn, DurationColumn, OrganizationIDColumn, TranscriptionColumn, TranscriptionUserEditedColumn, IDColumn} + defaultColumns = postgres.ColumnList{} + ) + + return noteAudioTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + CreatorID: CreatorIDColumn, + Deleted: DeletedColumn, + DeletorID: DeletorIDColumn, + Duration: DurationColumn, + OrganizationID: OrganizationIDColumn, + Transcription: TranscriptionColumn, + TranscriptionUserEdited: TranscriptionUserEditedColumn, + Version: VersionColumn, + UUID: UUIDColumn, + ID: IDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/note_audio_breadcrumb.go b/db/gen/nidus-sync/public/table/note_audio_breadcrumb.go new file mode 100644 index 00000000..7feb2e91 --- /dev/null +++ b/db/gen/nidus-sync/public/table/note_audio_breadcrumb.go @@ -0,0 +1,93 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NoteAudioBreadcrumb = newNoteAudioBreadcrumbTable("public", "note_audio_breadcrumb", "") + +type noteAudioBreadcrumbTable struct { + postgres.Table + + // Columns + Cell postgres.ColumnString + Created postgres.ColumnTimestamp + ManuallySelected postgres.ColumnBool + NoteAudioVersion postgres.ColumnInteger + NoteAudioUUID postgres.ColumnString + Position postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NoteAudioBreadcrumbTable struct { + noteAudioBreadcrumbTable + + EXCLUDED noteAudioBreadcrumbTable +} + +// AS creates new NoteAudioBreadcrumbTable with assigned alias +func (a NoteAudioBreadcrumbTable) AS(alias string) *NoteAudioBreadcrumbTable { + return newNoteAudioBreadcrumbTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NoteAudioBreadcrumbTable with assigned schema name +func (a NoteAudioBreadcrumbTable) FromSchema(schemaName string) *NoteAudioBreadcrumbTable { + return newNoteAudioBreadcrumbTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NoteAudioBreadcrumbTable with assigned table prefix +func (a NoteAudioBreadcrumbTable) WithPrefix(prefix string) *NoteAudioBreadcrumbTable { + return newNoteAudioBreadcrumbTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NoteAudioBreadcrumbTable with assigned table suffix +func (a NoteAudioBreadcrumbTable) WithSuffix(suffix string) *NoteAudioBreadcrumbTable { + return newNoteAudioBreadcrumbTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNoteAudioBreadcrumbTable(schemaName, tableName, alias string) *NoteAudioBreadcrumbTable { + return &NoteAudioBreadcrumbTable{ + noteAudioBreadcrumbTable: newNoteAudioBreadcrumbTableImpl(schemaName, tableName, alias), + EXCLUDED: newNoteAudioBreadcrumbTableImpl("", "excluded", ""), + } +} + +func newNoteAudioBreadcrumbTableImpl(schemaName, tableName, alias string) noteAudioBreadcrumbTable { + var ( + CellColumn = postgres.StringColumn("cell") + CreatedColumn = postgres.TimestampColumn("created") + ManuallySelectedColumn = postgres.BoolColumn("manually_selected") + NoteAudioVersionColumn = postgres.IntegerColumn("note_audio_version") + NoteAudioUUIDColumn = postgres.StringColumn("note_audio_uuid") + PositionColumn = postgres.IntegerColumn("position") + allColumns = postgres.ColumnList{CellColumn, CreatedColumn, ManuallySelectedColumn, NoteAudioVersionColumn, NoteAudioUUIDColumn, PositionColumn} + mutableColumns = postgres.ColumnList{CellColumn, CreatedColumn, ManuallySelectedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return noteAudioBreadcrumbTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Cell: CellColumn, + Created: CreatedColumn, + ManuallySelected: ManuallySelectedColumn, + NoteAudioVersion: NoteAudioVersionColumn, + NoteAudioUUID: NoteAudioUUIDColumn, + Position: PositionColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/note_audio_data.go b/db/gen/nidus-sync/public/table/note_audio_data.go new file mode 100644 index 00000000..59962140 --- /dev/null +++ b/db/gen/nidus-sync/public/table/note_audio_data.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NoteAudioData = newNoteAudioDataTable("public", "note_audio_data", "") + +type noteAudioDataTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + NoteAudioVersion postgres.ColumnInteger + NoteAudioUUID postgres.ColumnString + Type postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NoteAudioDataTable struct { + noteAudioDataTable + + EXCLUDED noteAudioDataTable +} + +// AS creates new NoteAudioDataTable with assigned alias +func (a NoteAudioDataTable) AS(alias string) *NoteAudioDataTable { + return newNoteAudioDataTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NoteAudioDataTable with assigned schema name +func (a NoteAudioDataTable) FromSchema(schemaName string) *NoteAudioDataTable { + return newNoteAudioDataTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NoteAudioDataTable with assigned table prefix +func (a NoteAudioDataTable) WithPrefix(prefix string) *NoteAudioDataTable { + return newNoteAudioDataTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NoteAudioDataTable with assigned table suffix +func (a NoteAudioDataTable) WithSuffix(suffix string) *NoteAudioDataTable { + return newNoteAudioDataTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNoteAudioDataTable(schemaName, tableName, alias string) *NoteAudioDataTable { + return &NoteAudioDataTable{ + noteAudioDataTable: newNoteAudioDataTableImpl(schemaName, tableName, alias), + EXCLUDED: newNoteAudioDataTableImpl("", "excluded", ""), + } +} + +func newNoteAudioDataTableImpl(schemaName, tableName, alias string) noteAudioDataTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + NoteAudioVersionColumn = postgres.IntegerColumn("note_audio_version") + NoteAudioUUIDColumn = postgres.StringColumn("note_audio_uuid") + TypeColumn = postgres.StringColumn("type_") + allColumns = postgres.ColumnList{CreatedColumn, NoteAudioVersionColumn, NoteAudioUUIDColumn, TypeColumn} + mutableColumns = postgres.ColumnList{CreatedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return noteAudioDataTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + NoteAudioVersion: NoteAudioVersionColumn, + NoteAudioUUID: NoteAudioUUIDColumn, + Type: TypeColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/note_image.go b/db/gen/nidus-sync/public/table/note_image.go new file mode 100644 index 00000000..d04aab06 --- /dev/null +++ b/db/gen/nidus-sync/public/table/note_image.go @@ -0,0 +1,99 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NoteImage = newNoteImageTable("public", "note_image", "") + +type noteImageTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + CreatorID postgres.ColumnInteger + Deleted postgres.ColumnTimestamp + DeletorID postgres.ColumnInteger + OrganizationID postgres.ColumnInteger + Version postgres.ColumnInteger + UUID postgres.ColumnString + ID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NoteImageTable struct { + noteImageTable + + EXCLUDED noteImageTable +} + +// AS creates new NoteImageTable with assigned alias +func (a NoteImageTable) AS(alias string) *NoteImageTable { + return newNoteImageTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NoteImageTable with assigned schema name +func (a NoteImageTable) FromSchema(schemaName string) *NoteImageTable { + return newNoteImageTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NoteImageTable with assigned table prefix +func (a NoteImageTable) WithPrefix(prefix string) *NoteImageTable { + return newNoteImageTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NoteImageTable with assigned table suffix +func (a NoteImageTable) WithSuffix(suffix string) *NoteImageTable { + return newNoteImageTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNoteImageTable(schemaName, tableName, alias string) *NoteImageTable { + return &NoteImageTable{ + noteImageTable: newNoteImageTableImpl(schemaName, tableName, alias), + EXCLUDED: newNoteImageTableImpl("", "excluded", ""), + } +} + +func newNoteImageTableImpl(schemaName, tableName, alias string) noteImageTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + CreatorIDColumn = postgres.IntegerColumn("creator_id") + DeletedColumn = postgres.TimestampColumn("deleted") + DeletorIDColumn = postgres.IntegerColumn("deletor_id") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + VersionColumn = postgres.IntegerColumn("version") + UUIDColumn = postgres.StringColumn("uuid") + IDColumn = postgres.IntegerColumn("id") + allColumns = postgres.ColumnList{CreatedColumn, CreatorIDColumn, DeletedColumn, DeletorIDColumn, OrganizationIDColumn, VersionColumn, UUIDColumn, IDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, CreatorIDColumn, DeletedColumn, DeletorIDColumn, OrganizationIDColumn, IDColumn} + defaultColumns = postgres.ColumnList{} + ) + + return noteImageTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + CreatorID: CreatorIDColumn, + Deleted: DeletedColumn, + DeletorID: DeletorIDColumn, + OrganizationID: OrganizationIDColumn, + Version: VersionColumn, + UUID: UUIDColumn, + ID: IDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/note_image_breadcrumb.go b/db/gen/nidus-sync/public/table/note_image_breadcrumb.go new file mode 100644 index 00000000..cbf6cd66 --- /dev/null +++ b/db/gen/nidus-sync/public/table/note_image_breadcrumb.go @@ -0,0 +1,93 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NoteImageBreadcrumb = newNoteImageBreadcrumbTable("public", "note_image_breadcrumb", "") + +type noteImageBreadcrumbTable struct { + postgres.Table + + // Columns + Cell postgres.ColumnString + Created postgres.ColumnTimestamp + ManuallySelected postgres.ColumnBool + NoteImageVersion postgres.ColumnInteger + NoteImageUUID postgres.ColumnString + Position postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NoteImageBreadcrumbTable struct { + noteImageBreadcrumbTable + + EXCLUDED noteImageBreadcrumbTable +} + +// AS creates new NoteImageBreadcrumbTable with assigned alias +func (a NoteImageBreadcrumbTable) AS(alias string) *NoteImageBreadcrumbTable { + return newNoteImageBreadcrumbTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NoteImageBreadcrumbTable with assigned schema name +func (a NoteImageBreadcrumbTable) FromSchema(schemaName string) *NoteImageBreadcrumbTable { + return newNoteImageBreadcrumbTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NoteImageBreadcrumbTable with assigned table prefix +func (a NoteImageBreadcrumbTable) WithPrefix(prefix string) *NoteImageBreadcrumbTable { + return newNoteImageBreadcrumbTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NoteImageBreadcrumbTable with assigned table suffix +func (a NoteImageBreadcrumbTable) WithSuffix(suffix string) *NoteImageBreadcrumbTable { + return newNoteImageBreadcrumbTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNoteImageBreadcrumbTable(schemaName, tableName, alias string) *NoteImageBreadcrumbTable { + return &NoteImageBreadcrumbTable{ + noteImageBreadcrumbTable: newNoteImageBreadcrumbTableImpl(schemaName, tableName, alias), + EXCLUDED: newNoteImageBreadcrumbTableImpl("", "excluded", ""), + } +} + +func newNoteImageBreadcrumbTableImpl(schemaName, tableName, alias string) noteImageBreadcrumbTable { + var ( + CellColumn = postgres.StringColumn("cell") + CreatedColumn = postgres.TimestampColumn("created") + ManuallySelectedColumn = postgres.BoolColumn("manually_selected") + NoteImageVersionColumn = postgres.IntegerColumn("note_image_version") + NoteImageUUIDColumn = postgres.StringColumn("note_image_uuid") + PositionColumn = postgres.IntegerColumn("position") + allColumns = postgres.ColumnList{CellColumn, CreatedColumn, ManuallySelectedColumn, NoteImageVersionColumn, NoteImageUUIDColumn, PositionColumn} + mutableColumns = postgres.ColumnList{CellColumn, CreatedColumn, ManuallySelectedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return noteImageBreadcrumbTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Cell: CellColumn, + Created: CreatedColumn, + ManuallySelected: ManuallySelectedColumn, + NoteImageVersion: NoteImageVersionColumn, + NoteImageUUID: NoteImageUUIDColumn, + Position: PositionColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/note_image_data.go b/db/gen/nidus-sync/public/table/note_image_data.go new file mode 100644 index 00000000..ffe5bd5f --- /dev/null +++ b/db/gen/nidus-sync/public/table/note_image_data.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NoteImageData = newNoteImageDataTable("public", "note_image_data", "") + +type noteImageDataTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + NoteImageVersion postgres.ColumnInteger + NoteImageUUID postgres.ColumnString + Type postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NoteImageDataTable struct { + noteImageDataTable + + EXCLUDED noteImageDataTable +} + +// AS creates new NoteImageDataTable with assigned alias +func (a NoteImageDataTable) AS(alias string) *NoteImageDataTable { + return newNoteImageDataTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NoteImageDataTable with assigned schema name +func (a NoteImageDataTable) FromSchema(schemaName string) *NoteImageDataTable { + return newNoteImageDataTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NoteImageDataTable with assigned table prefix +func (a NoteImageDataTable) WithPrefix(prefix string) *NoteImageDataTable { + return newNoteImageDataTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NoteImageDataTable with assigned table suffix +func (a NoteImageDataTable) WithSuffix(suffix string) *NoteImageDataTable { + return newNoteImageDataTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNoteImageDataTable(schemaName, tableName, alias string) *NoteImageDataTable { + return &NoteImageDataTable{ + noteImageDataTable: newNoteImageDataTableImpl(schemaName, tableName, alias), + EXCLUDED: newNoteImageDataTableImpl("", "excluded", ""), + } +} + +func newNoteImageDataTableImpl(schemaName, tableName, alias string) noteImageDataTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + NoteImageVersionColumn = postgres.IntegerColumn("note_image_version") + NoteImageUUIDColumn = postgres.StringColumn("note_image_uuid") + TypeColumn = postgres.StringColumn("type_") + allColumns = postgres.ColumnList{CreatedColumn, NoteImageVersionColumn, NoteImageUUIDColumn, TypeColumn} + mutableColumns = postgres.ColumnList{CreatedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return noteImageDataTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + NoteImageVersion: NoteImageVersionColumn, + NoteImageUUID: NoteImageUUIDColumn, + Type: TypeColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/notification.go b/db/gen/nidus-sync/public/table/notification.go new file mode 100644 index 00000000..96e03ab5 --- /dev/null +++ b/db/gen/nidus-sync/public/table/notification.go @@ -0,0 +1,96 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Notification = newNotificationTable("public", "notification", "") + +type notificationTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + Created postgres.ColumnTimestamp + Link postgres.ColumnString + Message postgres.ColumnString + Type postgres.ColumnString + UserID postgres.ColumnInteger + ResolvedAt postgres.ColumnTimestamp + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NotificationTable struct { + notificationTable + + EXCLUDED notificationTable +} + +// AS creates new NotificationTable with assigned alias +func (a NotificationTable) AS(alias string) *NotificationTable { + return newNotificationTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NotificationTable with assigned schema name +func (a NotificationTable) FromSchema(schemaName string) *NotificationTable { + return newNotificationTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NotificationTable with assigned table prefix +func (a NotificationTable) WithPrefix(prefix string) *NotificationTable { + return newNotificationTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NotificationTable with assigned table suffix +func (a NotificationTable) WithSuffix(suffix string) *NotificationTable { + return newNotificationTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNotificationTable(schemaName, tableName, alias string) *NotificationTable { + return &NotificationTable{ + notificationTable: newNotificationTableImpl(schemaName, tableName, alias), + EXCLUDED: newNotificationTableImpl("", "excluded", ""), + } +} + +func newNotificationTableImpl(schemaName, tableName, alias string) notificationTable { + var ( + IDColumn = postgres.IntegerColumn("id") + CreatedColumn = postgres.TimestampColumn("created") + LinkColumn = postgres.StringColumn("link") + MessageColumn = postgres.StringColumn("message") + TypeColumn = postgres.StringColumn("type") + UserIDColumn = postgres.IntegerColumn("user_id") + ResolvedAtColumn = postgres.TimestampColumn("resolved_at") + allColumns = postgres.ColumnList{IDColumn, CreatedColumn, LinkColumn, MessageColumn, TypeColumn, UserIDColumn, ResolvedAtColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, LinkColumn, MessageColumn, TypeColumn, UserIDColumn, ResolvedAtColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return notificationTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + Created: CreatedColumn, + Link: LinkColumn, + Message: MessageColumn, + Type: TypeColumn, + UserID: UserIDColumn, + ResolvedAt: ResolvedAtColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/organization.go b/db/gen/nidus-sync/public/table/organization.go new file mode 100644 index 00000000..6f80586b --- /dev/null +++ b/db/gen/nidus-sync/public/table/organization.go @@ -0,0 +1,180 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Organization = newOrganizationTable("public", "organization", "") + +type organizationTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + Name postgres.ColumnString + ImportDistrictGid postgres.ColumnInteger + Website postgres.ColumnString + LogoUUID postgres.ColumnString + Slug postgres.ColumnString + GeneralManagerName postgres.ColumnString + MailingAddressCity postgres.ColumnString + MailingAddressPostalCode postgres.ColumnString + MailingAddressStreet postgres.ColumnString + OfficeAddressCity postgres.ColumnString + OfficeAddressPostalCode postgres.ColumnString + OfficeAddressStreet postgres.ColumnString + ServiceAreaGeometry postgres.ColumnGeometry + ServiceAreaSquareMeters postgres.ColumnFloat + ServiceAreaCentroid postgres.ColumnGeometry + ServiceAreaExtent postgres.ColumnGeometry + OfficeFax postgres.ColumnString + OfficePhone postgres.ColumnString + ServiceAreaXmin postgres.ColumnFloat + ServiceAreaYmin postgres.ColumnFloat + ServiceAreaXmax postgres.ColumnFloat + ServiceAreaYmax postgres.ColumnFloat + ServiceAreaCentroidGeojson postgres.ColumnString + ServiceAreaCentroidX postgres.ColumnFloat + ServiceAreaCentroidY postgres.ColumnFloat + MailingAddressCountry postgres.ColumnString + MailingAddressState postgres.ColumnString + OfficeAddressCountry postgres.ColumnString + OfficeAddressState postgres.ColumnString + ArcgisAccountID postgres.ColumnString + FieldseekerServiceFeatureItemID postgres.ColumnString + ArcgisMapServiceID postgres.ColumnString + IsCatchall postgres.ColumnBool + LobAddressID postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type OrganizationTable struct { + organizationTable + + EXCLUDED organizationTable +} + +// AS creates new OrganizationTable with assigned alias +func (a OrganizationTable) AS(alias string) *OrganizationTable { + return newOrganizationTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new OrganizationTable with assigned schema name +func (a OrganizationTable) FromSchema(schemaName string) *OrganizationTable { + return newOrganizationTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new OrganizationTable with assigned table prefix +func (a OrganizationTable) WithPrefix(prefix string) *OrganizationTable { + return newOrganizationTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new OrganizationTable with assigned table suffix +func (a OrganizationTable) WithSuffix(suffix string) *OrganizationTable { + return newOrganizationTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newOrganizationTable(schemaName, tableName, alias string) *OrganizationTable { + return &OrganizationTable{ + organizationTable: newOrganizationTableImpl(schemaName, tableName, alias), + EXCLUDED: newOrganizationTableImpl("", "excluded", ""), + } +} + +func newOrganizationTableImpl(schemaName, tableName, alias string) organizationTable { + var ( + IDColumn = postgres.IntegerColumn("id") + NameColumn = postgres.StringColumn("name") + ImportDistrictGidColumn = postgres.IntegerColumn("import_district_gid") + WebsiteColumn = postgres.StringColumn("website") + LogoUUIDColumn = postgres.StringColumn("logo_uuid") + SlugColumn = postgres.StringColumn("slug") + GeneralManagerNameColumn = postgres.StringColumn("general_manager_name") + MailingAddressCityColumn = postgres.StringColumn("mailing_address_city") + MailingAddressPostalCodeColumn = postgres.StringColumn("mailing_address_postal_code") + MailingAddressStreetColumn = postgres.StringColumn("mailing_address_street") + OfficeAddressCityColumn = postgres.StringColumn("office_address_city") + OfficeAddressPostalCodeColumn = postgres.StringColumn("office_address_postal_code") + OfficeAddressStreetColumn = postgres.StringColumn("office_address_street") + ServiceAreaGeometryColumn = postgres.GeometryColumn("service_area_geometry") + ServiceAreaSquareMetersColumn = postgres.FloatColumn("service_area_square_meters") + ServiceAreaCentroidColumn = postgres.GeometryColumn("service_area_centroid") + ServiceAreaExtentColumn = postgres.GeometryColumn("service_area_extent") + OfficeFaxColumn = postgres.StringColumn("office_fax") + OfficePhoneColumn = postgres.StringColumn("office_phone") + ServiceAreaXminColumn = postgres.FloatColumn("service_area_xmin") + ServiceAreaYminColumn = postgres.FloatColumn("service_area_ymin") + ServiceAreaXmaxColumn = postgres.FloatColumn("service_area_xmax") + ServiceAreaYmaxColumn = postgres.FloatColumn("service_area_ymax") + ServiceAreaCentroidGeojsonColumn = postgres.StringColumn("service_area_centroid_geojson") + ServiceAreaCentroidXColumn = postgres.FloatColumn("service_area_centroid_x") + ServiceAreaCentroidYColumn = postgres.FloatColumn("service_area_centroid_y") + MailingAddressCountryColumn = postgres.StringColumn("mailing_address_country") + MailingAddressStateColumn = postgres.StringColumn("mailing_address_state") + OfficeAddressCountryColumn = postgres.StringColumn("office_address_country") + OfficeAddressStateColumn = postgres.StringColumn("office_address_state") + ArcgisAccountIDColumn = postgres.StringColumn("arcgis_account_id") + FieldseekerServiceFeatureItemIDColumn = postgres.StringColumn("fieldseeker_service_feature_item_id") + ArcgisMapServiceIDColumn = postgres.StringColumn("arcgis_map_service_id") + IsCatchallColumn = postgres.BoolColumn("is_catchall") + LobAddressIDColumn = postgres.StringColumn("lob_address_id") + allColumns = postgres.ColumnList{IDColumn, NameColumn, ImportDistrictGidColumn, WebsiteColumn, LogoUUIDColumn, SlugColumn, GeneralManagerNameColumn, MailingAddressCityColumn, MailingAddressPostalCodeColumn, MailingAddressStreetColumn, OfficeAddressCityColumn, OfficeAddressPostalCodeColumn, OfficeAddressStreetColumn, ServiceAreaGeometryColumn, ServiceAreaSquareMetersColumn, ServiceAreaCentroidColumn, ServiceAreaExtentColumn, OfficeFaxColumn, OfficePhoneColumn, ServiceAreaXminColumn, ServiceAreaYminColumn, ServiceAreaXmaxColumn, ServiceAreaYmaxColumn, ServiceAreaCentroidGeojsonColumn, ServiceAreaCentroidXColumn, ServiceAreaCentroidYColumn, MailingAddressCountryColumn, MailingAddressStateColumn, OfficeAddressCountryColumn, OfficeAddressStateColumn, ArcgisAccountIDColumn, FieldseekerServiceFeatureItemIDColumn, ArcgisMapServiceIDColumn, IsCatchallColumn, LobAddressIDColumn} + mutableColumns = postgres.ColumnList{NameColumn, ImportDistrictGidColumn, WebsiteColumn, LogoUUIDColumn, SlugColumn, GeneralManagerNameColumn, MailingAddressCityColumn, MailingAddressPostalCodeColumn, MailingAddressStreetColumn, OfficeAddressCityColumn, OfficeAddressPostalCodeColumn, OfficeAddressStreetColumn, ServiceAreaGeometryColumn, OfficeFaxColumn, OfficePhoneColumn, MailingAddressCountryColumn, MailingAddressStateColumn, OfficeAddressCountryColumn, OfficeAddressStateColumn, ArcgisAccountIDColumn, FieldseekerServiceFeatureItemIDColumn, ArcgisMapServiceIDColumn, IsCatchallColumn, LobAddressIDColumn} + defaultColumns = postgres.ColumnList{IDColumn, ServiceAreaSquareMetersColumn, ServiceAreaCentroidColumn, ServiceAreaExtentColumn, ServiceAreaXminColumn, ServiceAreaYminColumn, ServiceAreaXmaxColumn, ServiceAreaYmaxColumn, ServiceAreaCentroidGeojsonColumn, ServiceAreaCentroidXColumn, ServiceAreaCentroidYColumn} + ) + + return organizationTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + Name: NameColumn, + ImportDistrictGid: ImportDistrictGidColumn, + Website: WebsiteColumn, + LogoUUID: LogoUUIDColumn, + Slug: SlugColumn, + GeneralManagerName: GeneralManagerNameColumn, + MailingAddressCity: MailingAddressCityColumn, + MailingAddressPostalCode: MailingAddressPostalCodeColumn, + MailingAddressStreet: MailingAddressStreetColumn, + OfficeAddressCity: OfficeAddressCityColumn, + OfficeAddressPostalCode: OfficeAddressPostalCodeColumn, + OfficeAddressStreet: OfficeAddressStreetColumn, + ServiceAreaGeometry: ServiceAreaGeometryColumn, + ServiceAreaSquareMeters: ServiceAreaSquareMetersColumn, + ServiceAreaCentroid: ServiceAreaCentroidColumn, + ServiceAreaExtent: ServiceAreaExtentColumn, + OfficeFax: OfficeFaxColumn, + OfficePhone: OfficePhoneColumn, + ServiceAreaXmin: ServiceAreaXminColumn, + ServiceAreaYmin: ServiceAreaYminColumn, + ServiceAreaXmax: ServiceAreaXmaxColumn, + ServiceAreaYmax: ServiceAreaYmaxColumn, + ServiceAreaCentroidGeojson: ServiceAreaCentroidGeojsonColumn, + ServiceAreaCentroidX: ServiceAreaCentroidXColumn, + ServiceAreaCentroidY: ServiceAreaCentroidYColumn, + MailingAddressCountry: MailingAddressCountryColumn, + MailingAddressState: MailingAddressStateColumn, + OfficeAddressCountry: OfficeAddressCountryColumn, + OfficeAddressState: OfficeAddressStateColumn, + ArcgisAccountID: ArcgisAccountIDColumn, + FieldseekerServiceFeatureItemID: FieldseekerServiceFeatureItemIDColumn, + ArcgisMapServiceID: ArcgisMapServiceIDColumn, + IsCatchall: IsCatchallColumn, + LobAddressID: LobAddressIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/parcel.go b/db/gen/nidus-sync/public/table/parcel.go new file mode 100644 index 00000000..f09ed16b --- /dev/null +++ b/db/gen/nidus-sync/public/table/parcel.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Parcel = newParcelTable("public", "parcel", "") + +type parcelTable struct { + postgres.Table + + // Columns + Apn postgres.ColumnString + Description postgres.ColumnString + ID postgres.ColumnInteger + Geometry postgres.ColumnGeometry + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ParcelTable struct { + parcelTable + + EXCLUDED parcelTable +} + +// AS creates new ParcelTable with assigned alias +func (a ParcelTable) AS(alias string) *ParcelTable { + return newParcelTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ParcelTable with assigned schema name +func (a ParcelTable) FromSchema(schemaName string) *ParcelTable { + return newParcelTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ParcelTable with assigned table prefix +func (a ParcelTable) WithPrefix(prefix string) *ParcelTable { + return newParcelTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ParcelTable with assigned table suffix +func (a ParcelTable) WithSuffix(suffix string) *ParcelTable { + return newParcelTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newParcelTable(schemaName, tableName, alias string) *ParcelTable { + return &ParcelTable{ + parcelTable: newParcelTableImpl(schemaName, tableName, alias), + EXCLUDED: newParcelTableImpl("", "excluded", ""), + } +} + +func newParcelTableImpl(schemaName, tableName, alias string) parcelTable { + var ( + ApnColumn = postgres.StringColumn("apn") + DescriptionColumn = postgres.StringColumn("description") + IDColumn = postgres.IntegerColumn("id") + GeometryColumn = postgres.GeometryColumn("geometry") + allColumns = postgres.ColumnList{ApnColumn, DescriptionColumn, IDColumn, GeometryColumn} + mutableColumns = postgres.ColumnList{ApnColumn, DescriptionColumn, GeometryColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return parcelTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Apn: ApnColumn, + Description: DescriptionColumn, + ID: IDColumn, + Geometry: GeometryColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/report_text.go b/db/gen/nidus-sync/public/table/report_text.go new file mode 100644 index 00000000..80c84881 --- /dev/null +++ b/db/gen/nidus-sync/public/table/report_text.go @@ -0,0 +1,84 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ReportText = newReportTextTable("public", "report_text", "") + +type reportTextTable struct { + postgres.Table + + // Columns + CreatorID postgres.ColumnInteger + ReportID postgres.ColumnInteger + TextLogID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ReportTextTable struct { + reportTextTable + + EXCLUDED reportTextTable +} + +// AS creates new ReportTextTable with assigned alias +func (a ReportTextTable) AS(alias string) *ReportTextTable { + return newReportTextTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ReportTextTable with assigned schema name +func (a ReportTextTable) FromSchema(schemaName string) *ReportTextTable { + return newReportTextTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ReportTextTable with assigned table prefix +func (a ReportTextTable) WithPrefix(prefix string) *ReportTextTable { + return newReportTextTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ReportTextTable with assigned table suffix +func (a ReportTextTable) WithSuffix(suffix string) *ReportTextTable { + return newReportTextTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newReportTextTable(schemaName, tableName, alias string) *ReportTextTable { + return &ReportTextTable{ + reportTextTable: newReportTextTableImpl(schemaName, tableName, alias), + EXCLUDED: newReportTextTableImpl("", "excluded", ""), + } +} + +func newReportTextTableImpl(schemaName, tableName, alias string) reportTextTable { + var ( + CreatorIDColumn = postgres.IntegerColumn("creator_id") + ReportIDColumn = postgres.IntegerColumn("report_id") + TextLogIDColumn = postgres.IntegerColumn("text_log_id") + allColumns = postgres.ColumnList{CreatorIDColumn, ReportIDColumn, TextLogIDColumn} + mutableColumns = postgres.ColumnList{} + defaultColumns = postgres.ColumnList{} + ) + + return reportTextTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + CreatorID: CreatorIDColumn, + ReportID: ReportIDColumn, + TextLogID: TextLogIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/resident.go b/db/gen/nidus-sync/public/table/resident.go new file mode 100644 index 00000000..387b58d1 --- /dev/null +++ b/db/gen/nidus-sync/public/table/resident.go @@ -0,0 +1,96 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Resident = newResidentTable("public", "resident", "") + +type residentTable struct { + postgres.Table + + // Columns + AddressID postgres.ColumnInteger + Created postgres.ColumnTimestamp + Creator postgres.ColumnInteger + ID postgres.ColumnInteger + Name postgres.ColumnString + PhoneMobile postgres.ColumnString + SiteID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ResidentTable struct { + residentTable + + EXCLUDED residentTable +} + +// AS creates new ResidentTable with assigned alias +func (a ResidentTable) AS(alias string) *ResidentTable { + return newResidentTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ResidentTable with assigned schema name +func (a ResidentTable) FromSchema(schemaName string) *ResidentTable { + return newResidentTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ResidentTable with assigned table prefix +func (a ResidentTable) WithPrefix(prefix string) *ResidentTable { + return newResidentTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ResidentTable with assigned table suffix +func (a ResidentTable) WithSuffix(suffix string) *ResidentTable { + return newResidentTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newResidentTable(schemaName, tableName, alias string) *ResidentTable { + return &ResidentTable{ + residentTable: newResidentTableImpl(schemaName, tableName, alias), + EXCLUDED: newResidentTableImpl("", "excluded", ""), + } +} + +func newResidentTableImpl(schemaName, tableName, alias string) residentTable { + var ( + AddressIDColumn = postgres.IntegerColumn("address_id") + CreatedColumn = postgres.TimestampColumn("created") + CreatorColumn = postgres.IntegerColumn("creator") + IDColumn = postgres.IntegerColumn("id") + NameColumn = postgres.StringColumn("name") + PhoneMobileColumn = postgres.StringColumn("phone_mobile") + SiteIDColumn = postgres.IntegerColumn("site_id") + allColumns = postgres.ColumnList{AddressIDColumn, CreatedColumn, CreatorColumn, IDColumn, NameColumn, PhoneMobileColumn, SiteIDColumn} + mutableColumns = postgres.ColumnList{AddressIDColumn, CreatedColumn, CreatorColumn, NameColumn, PhoneMobileColumn, SiteIDColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return residentTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + AddressID: AddressIDColumn, + Created: CreatedColumn, + Creator: CreatorColumn, + ID: IDColumn, + Name: NameColumn, + PhoneMobile: PhoneMobileColumn, + SiteID: SiteIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/review_task.go b/db/gen/nidus-sync/public/table/review_task.go new file mode 100644 index 00000000..229331ab --- /dev/null +++ b/db/gen/nidus-sync/public/table/review_task.go @@ -0,0 +1,96 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ReviewTask = newReviewTaskTable("public", "review_task", "") + +type reviewTaskTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + CreatorID postgres.ColumnInteger + ID postgres.ColumnInteger + OrganizationID postgres.ColumnInteger + Reviewed postgres.ColumnTimestamp + ReviewerID postgres.ColumnInteger + Resolution postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ReviewTaskTable struct { + reviewTaskTable + + EXCLUDED reviewTaskTable +} + +// AS creates new ReviewTaskTable with assigned alias +func (a ReviewTaskTable) AS(alias string) *ReviewTaskTable { + return newReviewTaskTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ReviewTaskTable with assigned schema name +func (a ReviewTaskTable) FromSchema(schemaName string) *ReviewTaskTable { + return newReviewTaskTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ReviewTaskTable with assigned table prefix +func (a ReviewTaskTable) WithPrefix(prefix string) *ReviewTaskTable { + return newReviewTaskTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ReviewTaskTable with assigned table suffix +func (a ReviewTaskTable) WithSuffix(suffix string) *ReviewTaskTable { + return newReviewTaskTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newReviewTaskTable(schemaName, tableName, alias string) *ReviewTaskTable { + return &ReviewTaskTable{ + reviewTaskTable: newReviewTaskTableImpl(schemaName, tableName, alias), + EXCLUDED: newReviewTaskTableImpl("", "excluded", ""), + } +} + +func newReviewTaskTableImpl(schemaName, tableName, alias string) reviewTaskTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + CreatorIDColumn = postgres.IntegerColumn("creator_id") + IDColumn = postgres.IntegerColumn("id") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + ReviewedColumn = postgres.TimestampColumn("reviewed") + ReviewerIDColumn = postgres.IntegerColumn("reviewer_id") + ResolutionColumn = postgres.StringColumn("resolution") + allColumns = postgres.ColumnList{CreatedColumn, CreatorIDColumn, IDColumn, OrganizationIDColumn, ReviewedColumn, ReviewerIDColumn, ResolutionColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, CreatorIDColumn, OrganizationIDColumn, ReviewedColumn, ReviewerIDColumn, ResolutionColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return reviewTaskTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + CreatorID: CreatorIDColumn, + ID: IDColumn, + OrganizationID: OrganizationIDColumn, + Reviewed: ReviewedColumn, + ReviewerID: ReviewerIDColumn, + Resolution: ResolutionColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/review_task_pool.go b/db/gen/nidus-sync/public/table/review_task_pool.go new file mode 100644 index 00000000..343edc79 --- /dev/null +++ b/db/gen/nidus-sync/public/table/review_task_pool.go @@ -0,0 +1,90 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ReviewTaskPool = newReviewTaskPoolTable("public", "review_task_pool", "") + +type reviewTaskPoolTable struct { + postgres.Table + + // Columns + FeaturePoolID postgres.ColumnInteger + Location postgres.ColumnGeometry + Geometry postgres.ColumnGeometry + ReviewTaskID postgres.ColumnInteger + Condition postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ReviewTaskPoolTable struct { + reviewTaskPoolTable + + EXCLUDED reviewTaskPoolTable +} + +// AS creates new ReviewTaskPoolTable with assigned alias +func (a ReviewTaskPoolTable) AS(alias string) *ReviewTaskPoolTable { + return newReviewTaskPoolTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ReviewTaskPoolTable with assigned schema name +func (a ReviewTaskPoolTable) FromSchema(schemaName string) *ReviewTaskPoolTable { + return newReviewTaskPoolTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ReviewTaskPoolTable with assigned table prefix +func (a ReviewTaskPoolTable) WithPrefix(prefix string) *ReviewTaskPoolTable { + return newReviewTaskPoolTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ReviewTaskPoolTable with assigned table suffix +func (a ReviewTaskPoolTable) WithSuffix(suffix string) *ReviewTaskPoolTable { + return newReviewTaskPoolTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newReviewTaskPoolTable(schemaName, tableName, alias string) *ReviewTaskPoolTable { + return &ReviewTaskPoolTable{ + reviewTaskPoolTable: newReviewTaskPoolTableImpl(schemaName, tableName, alias), + EXCLUDED: newReviewTaskPoolTableImpl("", "excluded", ""), + } +} + +func newReviewTaskPoolTableImpl(schemaName, tableName, alias string) reviewTaskPoolTable { + var ( + FeaturePoolIDColumn = postgres.IntegerColumn("feature_pool_id") + LocationColumn = postgres.GeometryColumn("location") + GeometryColumn = postgres.GeometryColumn("geometry") + ReviewTaskIDColumn = postgres.IntegerColumn("review_task_id") + ConditionColumn = postgres.StringColumn("condition") + allColumns = postgres.ColumnList{FeaturePoolIDColumn, LocationColumn, GeometryColumn, ReviewTaskIDColumn, ConditionColumn} + mutableColumns = postgres.ColumnList{FeaturePoolIDColumn, LocationColumn, GeometryColumn, ConditionColumn} + defaultColumns = postgres.ColumnList{} + ) + + return reviewTaskPoolTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + FeaturePoolID: FeaturePoolIDColumn, + Location: LocationColumn, + Geometry: GeometryColumn, + ReviewTaskID: ReviewTaskIDColumn, + Condition: ConditionColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/sessions.go b/db/gen/nidus-sync/public/table/sessions.go new file mode 100644 index 00000000..79157ce1 --- /dev/null +++ b/db/gen/nidus-sync/public/table/sessions.go @@ -0,0 +1,84 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Sessions = newSessionsTable("public", "sessions", "") + +type sessionsTable struct { + postgres.Table + + // Columns + Token postgres.ColumnString + Data postgres.ColumnBytea + Expiry postgres.ColumnTimestampz + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type SessionsTable struct { + sessionsTable + + EXCLUDED sessionsTable +} + +// AS creates new SessionsTable with assigned alias +func (a SessionsTable) AS(alias string) *SessionsTable { + return newSessionsTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new SessionsTable with assigned schema name +func (a SessionsTable) FromSchema(schemaName string) *SessionsTable { + return newSessionsTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new SessionsTable with assigned table prefix +func (a SessionsTable) WithPrefix(prefix string) *SessionsTable { + return newSessionsTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new SessionsTable with assigned table suffix +func (a SessionsTable) WithSuffix(suffix string) *SessionsTable { + return newSessionsTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newSessionsTable(schemaName, tableName, alias string) *SessionsTable { + return &SessionsTable{ + sessionsTable: newSessionsTableImpl(schemaName, tableName, alias), + EXCLUDED: newSessionsTableImpl("", "excluded", ""), + } +} + +func newSessionsTableImpl(schemaName, tableName, alias string) sessionsTable { + var ( + TokenColumn = postgres.StringColumn("token") + DataColumn = postgres.ByteaColumn("data") + ExpiryColumn = postgres.TimestampzColumn("expiry") + allColumns = postgres.ColumnList{TokenColumn, DataColumn, ExpiryColumn} + mutableColumns = postgres.ColumnList{DataColumn, ExpiryColumn} + defaultColumns = postgres.ColumnList{} + ) + + return sessionsTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Token: TokenColumn, + Data: DataColumn, + Expiry: ExpiryColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/signal.go b/db/gen/nidus-sync/public/table/signal.go new file mode 100644 index 00000000..2b7f3d9e --- /dev/null +++ b/db/gen/nidus-sync/public/table/signal.go @@ -0,0 +1,111 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Signal = newSignalTable("public", "signal", "") + +type signalTable struct { + postgres.Table + + // Columns + Addressed postgres.ColumnTimestamp + Addressor postgres.ColumnInteger + Created postgres.ColumnTimestamp + Creator postgres.ColumnInteger + ID postgres.ColumnInteger + OrganizationID postgres.ColumnInteger + Species postgres.ColumnString + Type postgres.ColumnString + SiteID postgres.ColumnInteger + Location postgres.ColumnGeometry + FeaturePoolFeatureID postgres.ColumnInteger + ReportID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type SignalTable struct { + signalTable + + EXCLUDED signalTable +} + +// AS creates new SignalTable with assigned alias +func (a SignalTable) AS(alias string) *SignalTable { + return newSignalTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new SignalTable with assigned schema name +func (a SignalTable) FromSchema(schemaName string) *SignalTable { + return newSignalTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new SignalTable with assigned table prefix +func (a SignalTable) WithPrefix(prefix string) *SignalTable { + return newSignalTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new SignalTable with assigned table suffix +func (a SignalTable) WithSuffix(suffix string) *SignalTable { + return newSignalTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newSignalTable(schemaName, tableName, alias string) *SignalTable { + return &SignalTable{ + signalTable: newSignalTableImpl(schemaName, tableName, alias), + EXCLUDED: newSignalTableImpl("", "excluded", ""), + } +} + +func newSignalTableImpl(schemaName, tableName, alias string) signalTable { + var ( + AddressedColumn = postgres.TimestampColumn("addressed") + AddressorColumn = postgres.IntegerColumn("addressor") + CreatedColumn = postgres.TimestampColumn("created") + CreatorColumn = postgres.IntegerColumn("creator") + IDColumn = postgres.IntegerColumn("id") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + SpeciesColumn = postgres.StringColumn("species") + TypeColumn = postgres.StringColumn("type_") + SiteIDColumn = postgres.IntegerColumn("site_id") + LocationColumn = postgres.GeometryColumn("location") + FeaturePoolFeatureIDColumn = postgres.IntegerColumn("feature_pool_feature_id") + ReportIDColumn = postgres.IntegerColumn("report_id") + allColumns = postgres.ColumnList{AddressedColumn, AddressorColumn, CreatedColumn, CreatorColumn, IDColumn, OrganizationIDColumn, SpeciesColumn, TypeColumn, SiteIDColumn, LocationColumn, FeaturePoolFeatureIDColumn, ReportIDColumn} + mutableColumns = postgres.ColumnList{AddressedColumn, AddressorColumn, CreatedColumn, CreatorColumn, OrganizationIDColumn, SpeciesColumn, TypeColumn, SiteIDColumn, LocationColumn, FeaturePoolFeatureIDColumn, ReportIDColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return signalTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Addressed: AddressedColumn, + Addressor: AddressorColumn, + Created: CreatedColumn, + Creator: CreatorColumn, + ID: IDColumn, + OrganizationID: OrganizationIDColumn, + Species: SpeciesColumn, + Type: TypeColumn, + SiteID: SiteIDColumn, + Location: LocationColumn, + FeaturePoolFeatureID: FeaturePoolFeatureIDColumn, + ReportID: ReportIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/site.go b/db/gen/nidus-sync/public/table/site.go new file mode 100644 index 00000000..42aee401 --- /dev/null +++ b/db/gen/nidus-sync/public/table/site.go @@ -0,0 +1,114 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Site = newSiteTable("public", "site", "") + +type siteTable struct { + postgres.Table + + // Columns + AddressID postgres.ColumnInteger + Created postgres.ColumnTimestamp + CreatorID postgres.ColumnInteger + FileID postgres.ColumnInteger + ID postgres.ColumnInteger + Notes postgres.ColumnString + OrganizationID postgres.ColumnInteger + OwnerName postgres.ColumnString + OwnerPhoneE164 postgres.ColumnString + ParcelID postgres.ColumnInteger + ResidentOwned postgres.ColumnBool + Tags postgres.ColumnString + Version postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type SiteTable struct { + siteTable + + EXCLUDED siteTable +} + +// AS creates new SiteTable with assigned alias +func (a SiteTable) AS(alias string) *SiteTable { + return newSiteTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new SiteTable with assigned schema name +func (a SiteTable) FromSchema(schemaName string) *SiteTable { + return newSiteTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new SiteTable with assigned table prefix +func (a SiteTable) WithPrefix(prefix string) *SiteTable { + return newSiteTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new SiteTable with assigned table suffix +func (a SiteTable) WithSuffix(suffix string) *SiteTable { + return newSiteTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newSiteTable(schemaName, tableName, alias string) *SiteTable { + return &SiteTable{ + siteTable: newSiteTableImpl(schemaName, tableName, alias), + EXCLUDED: newSiteTableImpl("", "excluded", ""), + } +} + +func newSiteTableImpl(schemaName, tableName, alias string) siteTable { + var ( + AddressIDColumn = postgres.IntegerColumn("address_id") + CreatedColumn = postgres.TimestampColumn("created") + CreatorIDColumn = postgres.IntegerColumn("creator_id") + FileIDColumn = postgres.IntegerColumn("file_id") + IDColumn = postgres.IntegerColumn("id") + NotesColumn = postgres.StringColumn("notes") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + OwnerNameColumn = postgres.StringColumn("owner_name") + OwnerPhoneE164Column = postgres.StringColumn("owner_phone_e164") + ParcelIDColumn = postgres.IntegerColumn("parcel_id") + ResidentOwnedColumn = postgres.BoolColumn("resident_owned") + TagsColumn = postgres.StringColumn("tags") + VersionColumn = postgres.IntegerColumn("version") + allColumns = postgres.ColumnList{AddressIDColumn, CreatedColumn, CreatorIDColumn, FileIDColumn, IDColumn, NotesColumn, OrganizationIDColumn, OwnerNameColumn, OwnerPhoneE164Column, ParcelIDColumn, ResidentOwnedColumn, TagsColumn, VersionColumn} + mutableColumns = postgres.ColumnList{AddressIDColumn, CreatedColumn, CreatorIDColumn, FileIDColumn, NotesColumn, OrganizationIDColumn, OwnerNameColumn, OwnerPhoneE164Column, ParcelIDColumn, ResidentOwnedColumn, TagsColumn, VersionColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return siteTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + AddressID: AddressIDColumn, + Created: CreatedColumn, + CreatorID: CreatorIDColumn, + FileID: FileIDColumn, + ID: IDColumn, + Notes: NotesColumn, + OrganizationID: OrganizationIDColumn, + OwnerName: OwnerNameColumn, + OwnerPhoneE164: OwnerPhoneE164Column, + ParcelID: ParcelIDColumn, + ResidentOwned: ResidentOwnedColumn, + Tags: TagsColumn, + Version: VersionColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/spatial_ref_sys.go b/db/gen/nidus-sync/public/table/spatial_ref_sys.go new file mode 100644 index 00000000..cbd3fb9c --- /dev/null +++ b/db/gen/nidus-sync/public/table/spatial_ref_sys.go @@ -0,0 +1,90 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var SpatialRefSys = newSpatialRefSysTable("public", "spatial_ref_sys", "") + +type spatialRefSysTable struct { + postgres.Table + + // Columns + Srid postgres.ColumnInteger + AuthName postgres.ColumnString + AuthSrid postgres.ColumnInteger + Srtext postgres.ColumnString + Proj4text postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type SpatialRefSysTable struct { + spatialRefSysTable + + EXCLUDED spatialRefSysTable +} + +// AS creates new SpatialRefSysTable with assigned alias +func (a SpatialRefSysTable) AS(alias string) *SpatialRefSysTable { + return newSpatialRefSysTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new SpatialRefSysTable with assigned schema name +func (a SpatialRefSysTable) FromSchema(schemaName string) *SpatialRefSysTable { + return newSpatialRefSysTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new SpatialRefSysTable with assigned table prefix +func (a SpatialRefSysTable) WithPrefix(prefix string) *SpatialRefSysTable { + return newSpatialRefSysTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new SpatialRefSysTable with assigned table suffix +func (a SpatialRefSysTable) WithSuffix(suffix string) *SpatialRefSysTable { + return newSpatialRefSysTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newSpatialRefSysTable(schemaName, tableName, alias string) *SpatialRefSysTable { + return &SpatialRefSysTable{ + spatialRefSysTable: newSpatialRefSysTableImpl(schemaName, tableName, alias), + EXCLUDED: newSpatialRefSysTableImpl("", "excluded", ""), + } +} + +func newSpatialRefSysTableImpl(schemaName, tableName, alias string) spatialRefSysTable { + var ( + SridColumn = postgres.IntegerColumn("srid") + AuthNameColumn = postgres.StringColumn("auth_name") + AuthSridColumn = postgres.IntegerColumn("auth_srid") + SrtextColumn = postgres.StringColumn("srtext") + Proj4textColumn = postgres.StringColumn("proj4text") + allColumns = postgres.ColumnList{SridColumn, AuthNameColumn, AuthSridColumn, SrtextColumn, Proj4textColumn} + mutableColumns = postgres.ColumnList{AuthNameColumn, AuthSridColumn, SrtextColumn, Proj4textColumn} + defaultColumns = postgres.ColumnList{} + ) + + return spatialRefSysTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Srid: SridColumn, + AuthName: AuthNameColumn, + AuthSrid: AuthSridColumn, + Srtext: SrtextColumn, + Proj4text: Proj4textColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/table/table_use_schema.go b/db/gen/nidus-sync/public/table/table_use_schema.go new file mode 100644 index 00000000..ebf9685d --- /dev/null +++ b/db/gen/nidus-sync/public/table/table_use_schema.go @@ -0,0 +1,46 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +// UseSchema sets a new schema name for all generated table SQL builder types. It is recommended to invoke +// this method only once at the beginning of the program. +func UseSchema(schema string) { + Address = Address.FromSchema(schema) + Communication = Communication.FromSchema(schema) + CommunicationLogEntry = CommunicationLogEntry.FromSchema(schema) + ComplianceReportRequest = ComplianceReportRequest.FromSchema(schema) + ComplianceReportRequestMailer = ComplianceReportRequestMailer.FromSchema(schema) + DistrictSubscriptionEmail = DistrictSubscriptionEmail.FromSchema(schema) + DistrictSubscriptionPhone = DistrictSubscriptionPhone.FromSchema(schema) + Feature = Feature.FromSchema(schema) + FeaturePool = FeaturePool.FromSchema(schema) + FieldseekerSync = FieldseekerSync.FromSchema(schema) + GooseDbVersion = GooseDbVersion.FromSchema(schema) + H3Aggregation = H3Aggregation.FromSchema(schema) + Job = Job.FromSchema(schema) + Lead = Lead.FromSchema(schema) + LogImpersonation = LogImpersonation.FromSchema(schema) + NoteAudio = NoteAudio.FromSchema(schema) + NoteAudioBreadcrumb = NoteAudioBreadcrumb.FromSchema(schema) + NoteAudioData = NoteAudioData.FromSchema(schema) + NoteImage = NoteImage.FromSchema(schema) + NoteImageBreadcrumb = NoteImageBreadcrumb.FromSchema(schema) + NoteImageData = NoteImageData.FromSchema(schema) + Notification = Notification.FromSchema(schema) + Organization = Organization.FromSchema(schema) + Parcel = Parcel.FromSchema(schema) + ReportText = ReportText.FromSchema(schema) + Resident = Resident.FromSchema(schema) + ReviewTask = ReviewTask.FromSchema(schema) + ReviewTaskPool = ReviewTaskPool.FromSchema(schema) + Sessions = Sessions.FromSchema(schema) + Signal = Signal.FromSchema(schema) + Site = Site.FromSchema(schema) + SpatialRefSys = SpatialRefSys.FromSchema(schema) + User = User.FromSchema(schema) +} diff --git a/db/gen/nidus-sync/public/table/user_.go b/db/gen/nidus-sync/public/table/user_.go new file mode 100644 index 00000000..7191565d --- /dev/null +++ b/db/gen/nidus-sync/public/table/user_.go @@ -0,0 +1,126 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var User = newUserTable("public", "user_", "") + +type userTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + ArcgisAccessToken postgres.ColumnString + ArcgisLicense postgres.ColumnString + ArcgisRefreshToken postgres.ColumnString + ArcgisRefreshTokenExpires postgres.ColumnTimestamp + ArcgisRole postgres.ColumnString + DisplayName postgres.ColumnString + Email postgres.ColumnString + OrganizationID postgres.ColumnInteger + Username postgres.ColumnString + PasswordHashType postgres.ColumnString + PasswordHash postgres.ColumnString + Role postgres.ColumnString + Avatar postgres.ColumnString + IsActive postgres.ColumnBool + IsDronePilot postgres.ColumnBool + IsWarrant postgres.ColumnBool + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type UserTable struct { + userTable + + EXCLUDED userTable +} + +// AS creates new UserTable with assigned alias +func (a UserTable) AS(alias string) *UserTable { + return newUserTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new UserTable with assigned schema name +func (a UserTable) FromSchema(schemaName string) *UserTable { + return newUserTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new UserTable with assigned table prefix +func (a UserTable) WithPrefix(prefix string) *UserTable { + return newUserTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new UserTable with assigned table suffix +func (a UserTable) WithSuffix(suffix string) *UserTable { + return newUserTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newUserTable(schemaName, tableName, alias string) *UserTable { + return &UserTable{ + userTable: newUserTableImpl(schemaName, tableName, alias), + EXCLUDED: newUserTableImpl("", "excluded", ""), + } +} + +func newUserTableImpl(schemaName, tableName, alias string) userTable { + var ( + IDColumn = postgres.IntegerColumn("id") + ArcgisAccessTokenColumn = postgres.StringColumn("arcgis_access_token") + ArcgisLicenseColumn = postgres.StringColumn("arcgis_license") + ArcgisRefreshTokenColumn = postgres.StringColumn("arcgis_refresh_token") + ArcgisRefreshTokenExpiresColumn = postgres.TimestampColumn("arcgis_refresh_token_expires") + ArcgisRoleColumn = postgres.StringColumn("arcgis_role") + DisplayNameColumn = postgres.StringColumn("display_name") + EmailColumn = postgres.StringColumn("email") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + UsernameColumn = postgres.StringColumn("username") + PasswordHashTypeColumn = postgres.StringColumn("password_hash_type") + PasswordHashColumn = postgres.StringColumn("password_hash") + RoleColumn = postgres.StringColumn("role") + AvatarColumn = postgres.StringColumn("avatar") + IsActiveColumn = postgres.BoolColumn("is_active") + IsDronePilotColumn = postgres.BoolColumn("is_drone_pilot") + IsWarrantColumn = postgres.BoolColumn("is_warrant") + allColumns = postgres.ColumnList{IDColumn, ArcgisAccessTokenColumn, ArcgisLicenseColumn, ArcgisRefreshTokenColumn, ArcgisRefreshTokenExpiresColumn, ArcgisRoleColumn, DisplayNameColumn, EmailColumn, OrganizationIDColumn, UsernameColumn, PasswordHashTypeColumn, PasswordHashColumn, RoleColumn, AvatarColumn, IsActiveColumn, IsDronePilotColumn, IsWarrantColumn} + mutableColumns = postgres.ColumnList{ArcgisAccessTokenColumn, ArcgisLicenseColumn, ArcgisRefreshTokenColumn, ArcgisRefreshTokenExpiresColumn, ArcgisRoleColumn, DisplayNameColumn, EmailColumn, OrganizationIDColumn, UsernameColumn, PasswordHashTypeColumn, PasswordHashColumn, RoleColumn, AvatarColumn, IsActiveColumn, IsDronePilotColumn, IsWarrantColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return userTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + ArcgisAccessToken: ArcgisAccessTokenColumn, + ArcgisLicense: ArcgisLicenseColumn, + ArcgisRefreshToken: ArcgisRefreshTokenColumn, + ArcgisRefreshTokenExpires: ArcgisRefreshTokenExpiresColumn, + ArcgisRole: ArcgisRoleColumn, + DisplayName: DisplayNameColumn, + Email: EmailColumn, + OrganizationID: OrganizationIDColumn, + Username: UsernameColumn, + PasswordHashType: PasswordHashTypeColumn, + PasswordHash: PasswordHashColumn, + Role: RoleColumn, + Avatar: AvatarColumn, + IsActive: IsActiveColumn, + IsDronePilot: IsDronePilotColumn, + IsWarrant: IsWarrantColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/view/geography_columns.go b/db/gen/nidus-sync/public/view/geography_columns.go new file mode 100644 index 00000000..bcb31d21 --- /dev/null +++ b/db/gen/nidus-sync/public/view/geography_columns.go @@ -0,0 +1,96 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package view + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var GeographyColumns = newGeographyColumnsTable("public", "geography_columns", "") + +type geographyColumnsTable struct { + postgres.Table + + // Columns + FTableCatalog postgres.ColumnString + FTableSchema postgres.ColumnString + FTableName postgres.ColumnString + FGeographyColumn postgres.ColumnString + CoordDimension postgres.ColumnInteger + Srid postgres.ColumnInteger + Type postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type GeographyColumnsTable struct { + geographyColumnsTable + + EXCLUDED geographyColumnsTable +} + +// AS creates new GeographyColumnsTable with assigned alias +func (a GeographyColumnsTable) AS(alias string) *GeographyColumnsTable { + return newGeographyColumnsTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new GeographyColumnsTable with assigned schema name +func (a GeographyColumnsTable) FromSchema(schemaName string) *GeographyColumnsTable { + return newGeographyColumnsTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new GeographyColumnsTable with assigned table prefix +func (a GeographyColumnsTable) WithPrefix(prefix string) *GeographyColumnsTable { + return newGeographyColumnsTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new GeographyColumnsTable with assigned table suffix +func (a GeographyColumnsTable) WithSuffix(suffix string) *GeographyColumnsTable { + return newGeographyColumnsTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newGeographyColumnsTable(schemaName, tableName, alias string) *GeographyColumnsTable { + return &GeographyColumnsTable{ + geographyColumnsTable: newGeographyColumnsTableImpl(schemaName, tableName, alias), + EXCLUDED: newGeographyColumnsTableImpl("", "excluded", ""), + } +} + +func newGeographyColumnsTableImpl(schemaName, tableName, alias string) geographyColumnsTable { + var ( + FTableCatalogColumn = postgres.StringColumn("f_table_catalog") + FTableSchemaColumn = postgres.StringColumn("f_table_schema") + FTableNameColumn = postgres.StringColumn("f_table_name") + FGeographyColumnColumn = postgres.StringColumn("f_geography_column") + CoordDimensionColumn = postgres.IntegerColumn("coord_dimension") + SridColumn = postgres.IntegerColumn("srid") + TypeColumn = postgres.StringColumn("type") + allColumns = postgres.ColumnList{FTableCatalogColumn, FTableSchemaColumn, FTableNameColumn, FGeographyColumnColumn, CoordDimensionColumn, SridColumn, TypeColumn} + mutableColumns = postgres.ColumnList{FTableCatalogColumn, FTableSchemaColumn, FTableNameColumn, FGeographyColumnColumn, CoordDimensionColumn, SridColumn, TypeColumn} + defaultColumns = postgres.ColumnList{} + ) + + return geographyColumnsTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + FTableCatalog: FTableCatalogColumn, + FTableSchema: FTableSchemaColumn, + FTableName: FTableNameColumn, + FGeographyColumn: FGeographyColumnColumn, + CoordDimension: CoordDimensionColumn, + Srid: SridColumn, + Type: TypeColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/view/geometry_columns.go b/db/gen/nidus-sync/public/view/geometry_columns.go new file mode 100644 index 00000000..da897a08 --- /dev/null +++ b/db/gen/nidus-sync/public/view/geometry_columns.go @@ -0,0 +1,96 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package view + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var GeometryColumns = newGeometryColumnsTable("public", "geometry_columns", "") + +type geometryColumnsTable struct { + postgres.Table + + // Columns + FTableCatalog postgres.ColumnString + FTableSchema postgres.ColumnString + FTableName postgres.ColumnString + FGeometryColumn postgres.ColumnString + CoordDimension postgres.ColumnInteger + Srid postgres.ColumnInteger + Type postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type GeometryColumnsTable struct { + geometryColumnsTable + + EXCLUDED geometryColumnsTable +} + +// AS creates new GeometryColumnsTable with assigned alias +func (a GeometryColumnsTable) AS(alias string) *GeometryColumnsTable { + return newGeometryColumnsTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new GeometryColumnsTable with assigned schema name +func (a GeometryColumnsTable) FromSchema(schemaName string) *GeometryColumnsTable { + return newGeometryColumnsTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new GeometryColumnsTable with assigned table prefix +func (a GeometryColumnsTable) WithPrefix(prefix string) *GeometryColumnsTable { + return newGeometryColumnsTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new GeometryColumnsTable with assigned table suffix +func (a GeometryColumnsTable) WithSuffix(suffix string) *GeometryColumnsTable { + return newGeometryColumnsTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newGeometryColumnsTable(schemaName, tableName, alias string) *GeometryColumnsTable { + return &GeometryColumnsTable{ + geometryColumnsTable: newGeometryColumnsTableImpl(schemaName, tableName, alias), + EXCLUDED: newGeometryColumnsTableImpl("", "excluded", ""), + } +} + +func newGeometryColumnsTableImpl(schemaName, tableName, alias string) geometryColumnsTable { + var ( + FTableCatalogColumn = postgres.StringColumn("f_table_catalog") + FTableSchemaColumn = postgres.StringColumn("f_table_schema") + FTableNameColumn = postgres.StringColumn("f_table_name") + FGeometryColumnColumn = postgres.StringColumn("f_geometry_column") + CoordDimensionColumn = postgres.IntegerColumn("coord_dimension") + SridColumn = postgres.IntegerColumn("srid") + TypeColumn = postgres.StringColumn("type") + allColumns = postgres.ColumnList{FTableCatalogColumn, FTableSchemaColumn, FTableNameColumn, FGeometryColumnColumn, CoordDimensionColumn, SridColumn, TypeColumn} + mutableColumns = postgres.ColumnList{FTableCatalogColumn, FTableSchemaColumn, FTableNameColumn, FGeometryColumnColumn, CoordDimensionColumn, SridColumn, TypeColumn} + defaultColumns = postgres.ColumnList{} + ) + + return geometryColumnsTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + FTableCatalog: FTableCatalogColumn, + FTableSchema: FTableSchemaColumn, + FTableName: FTableNameColumn, + FGeometryColumn: FGeometryColumnColumn, + CoordDimension: CoordDimensionColumn, + Srid: SridColumn, + Type: TypeColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/view/raster_columns.go b/db/gen/nidus-sync/public/view/raster_columns.go new file mode 100644 index 00000000..1224332a --- /dev/null +++ b/db/gen/nidus-sync/public/view/raster_columns.go @@ -0,0 +1,126 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package view + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var RasterColumns = newRasterColumnsTable("public", "raster_columns", "") + +type rasterColumnsTable struct { + postgres.Table + + // Columns + RTableCatalog postgres.ColumnString + RTableSchema postgres.ColumnString + RTableName postgres.ColumnString + RRasterColumn postgres.ColumnString + Srid postgres.ColumnInteger + ScaleX postgres.ColumnFloat + ScaleY postgres.ColumnFloat + BlocksizeX postgres.ColumnInteger + BlocksizeY postgres.ColumnInteger + SameAlignment postgres.ColumnBool + RegularBlocking postgres.ColumnBool + NumBands postgres.ColumnInteger + PixelTypes postgres.ColumnStringArray + NodataValues postgres.ColumnFloatArray + OutDb postgres.ColumnBoolArray + Extent postgres.ColumnGeometry + SpatialIndex postgres.ColumnBool + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type RasterColumnsTable struct { + rasterColumnsTable + + EXCLUDED rasterColumnsTable +} + +// AS creates new RasterColumnsTable with assigned alias +func (a RasterColumnsTable) AS(alias string) *RasterColumnsTable { + return newRasterColumnsTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new RasterColumnsTable with assigned schema name +func (a RasterColumnsTable) FromSchema(schemaName string) *RasterColumnsTable { + return newRasterColumnsTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new RasterColumnsTable with assigned table prefix +func (a RasterColumnsTable) WithPrefix(prefix string) *RasterColumnsTable { + return newRasterColumnsTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new RasterColumnsTable with assigned table suffix +func (a RasterColumnsTable) WithSuffix(suffix string) *RasterColumnsTable { + return newRasterColumnsTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newRasterColumnsTable(schemaName, tableName, alias string) *RasterColumnsTable { + return &RasterColumnsTable{ + rasterColumnsTable: newRasterColumnsTableImpl(schemaName, tableName, alias), + EXCLUDED: newRasterColumnsTableImpl("", "excluded", ""), + } +} + +func newRasterColumnsTableImpl(schemaName, tableName, alias string) rasterColumnsTable { + var ( + RTableCatalogColumn = postgres.StringColumn("r_table_catalog") + RTableSchemaColumn = postgres.StringColumn("r_table_schema") + RTableNameColumn = postgres.StringColumn("r_table_name") + RRasterColumnColumn = postgres.StringColumn("r_raster_column") + SridColumn = postgres.IntegerColumn("srid") + ScaleXColumn = postgres.FloatColumn("scale_x") + ScaleYColumn = postgres.FloatColumn("scale_y") + BlocksizeXColumn = postgres.IntegerColumn("blocksize_x") + BlocksizeYColumn = postgres.IntegerColumn("blocksize_y") + SameAlignmentColumn = postgres.BoolColumn("same_alignment") + RegularBlockingColumn = postgres.BoolColumn("regular_blocking") + NumBandsColumn = postgres.IntegerColumn("num_bands") + PixelTypesColumn = postgres.StringArrayColumn("pixel_types") + NodataValuesColumn = postgres.FloatArrayColumn("nodata_values") + OutDbColumn = postgres.BoolArrayColumn("out_db") + ExtentColumn = postgres.GeometryColumn("extent") + SpatialIndexColumn = postgres.BoolColumn("spatial_index") + allColumns = postgres.ColumnList{RTableCatalogColumn, RTableSchemaColumn, RTableNameColumn, RRasterColumnColumn, SridColumn, ScaleXColumn, ScaleYColumn, BlocksizeXColumn, BlocksizeYColumn, SameAlignmentColumn, RegularBlockingColumn, NumBandsColumn, PixelTypesColumn, NodataValuesColumn, OutDbColumn, ExtentColumn, SpatialIndexColumn} + mutableColumns = postgres.ColumnList{RTableCatalogColumn, RTableSchemaColumn, RTableNameColumn, RRasterColumnColumn, SridColumn, ScaleXColumn, ScaleYColumn, BlocksizeXColumn, BlocksizeYColumn, SameAlignmentColumn, RegularBlockingColumn, NumBandsColumn, PixelTypesColumn, NodataValuesColumn, OutDbColumn, ExtentColumn, SpatialIndexColumn} + defaultColumns = postgres.ColumnList{} + ) + + return rasterColumnsTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + RTableCatalog: RTableCatalogColumn, + RTableSchema: RTableSchemaColumn, + RTableName: RTableNameColumn, + RRasterColumn: RRasterColumnColumn, + Srid: SridColumn, + ScaleX: ScaleXColumn, + ScaleY: ScaleYColumn, + BlocksizeX: BlocksizeXColumn, + BlocksizeY: BlocksizeYColumn, + SameAlignment: SameAlignmentColumn, + RegularBlocking: RegularBlockingColumn, + NumBands: NumBandsColumn, + PixelTypes: PixelTypesColumn, + NodataValues: NodataValuesColumn, + OutDb: OutDbColumn, + Extent: ExtentColumn, + SpatialIndex: SpatialIndexColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/view/raster_overviews.go b/db/gen/nidus-sync/public/view/raster_overviews.go new file mode 100644 index 00000000..60306eb1 --- /dev/null +++ b/db/gen/nidus-sync/public/view/raster_overviews.go @@ -0,0 +1,102 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package view + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var RasterOverviews = newRasterOverviewsTable("public", "raster_overviews", "") + +type rasterOverviewsTable struct { + postgres.Table + + // Columns + OTableCatalog postgres.ColumnString + OTableSchema postgres.ColumnString + OTableName postgres.ColumnString + ORasterColumn postgres.ColumnString + RTableCatalog postgres.ColumnString + RTableSchema postgres.ColumnString + RTableName postgres.ColumnString + RRasterColumn postgres.ColumnString + OverviewFactor postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type RasterOverviewsTable struct { + rasterOverviewsTable + + EXCLUDED rasterOverviewsTable +} + +// AS creates new RasterOverviewsTable with assigned alias +func (a RasterOverviewsTable) AS(alias string) *RasterOverviewsTable { + return newRasterOverviewsTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new RasterOverviewsTable with assigned schema name +func (a RasterOverviewsTable) FromSchema(schemaName string) *RasterOverviewsTable { + return newRasterOverviewsTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new RasterOverviewsTable with assigned table prefix +func (a RasterOverviewsTable) WithPrefix(prefix string) *RasterOverviewsTable { + return newRasterOverviewsTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new RasterOverviewsTable with assigned table suffix +func (a RasterOverviewsTable) WithSuffix(suffix string) *RasterOverviewsTable { + return newRasterOverviewsTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newRasterOverviewsTable(schemaName, tableName, alias string) *RasterOverviewsTable { + return &RasterOverviewsTable{ + rasterOverviewsTable: newRasterOverviewsTableImpl(schemaName, tableName, alias), + EXCLUDED: newRasterOverviewsTableImpl("", "excluded", ""), + } +} + +func newRasterOverviewsTableImpl(schemaName, tableName, alias string) rasterOverviewsTable { + var ( + OTableCatalogColumn = postgres.StringColumn("o_table_catalog") + OTableSchemaColumn = postgres.StringColumn("o_table_schema") + OTableNameColumn = postgres.StringColumn("o_table_name") + ORasterColumnColumn = postgres.StringColumn("o_raster_column") + RTableCatalogColumn = postgres.StringColumn("r_table_catalog") + RTableSchemaColumn = postgres.StringColumn("r_table_schema") + RTableNameColumn = postgres.StringColumn("r_table_name") + RRasterColumnColumn = postgres.StringColumn("r_raster_column") + OverviewFactorColumn = postgres.IntegerColumn("overview_factor") + allColumns = postgres.ColumnList{OTableCatalogColumn, OTableSchemaColumn, OTableNameColumn, ORasterColumnColumn, RTableCatalogColumn, RTableSchemaColumn, RTableNameColumn, RRasterColumnColumn, OverviewFactorColumn} + mutableColumns = postgres.ColumnList{OTableCatalogColumn, OTableSchemaColumn, OTableNameColumn, ORasterColumnColumn, RTableCatalogColumn, RTableSchemaColumn, RTableNameColumn, RRasterColumnColumn, OverviewFactorColumn} + defaultColumns = postgres.ColumnList{} + ) + + return rasterOverviewsTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + OTableCatalog: OTableCatalogColumn, + OTableSchema: OTableSchemaColumn, + OTableName: OTableNameColumn, + ORasterColumn: ORasterColumnColumn, + RTableCatalog: RTableCatalogColumn, + RTableSchema: RTableSchemaColumn, + RTableName: RTableNameColumn, + RRasterColumn: RRasterColumnColumn, + OverviewFactor: OverviewFactorColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/public/view/view_use_schema.go b/db/gen/nidus-sync/public/view/view_use_schema.go new file mode 100644 index 00000000..874ad5da --- /dev/null +++ b/db/gen/nidus-sync/public/view/view_use_schema.go @@ -0,0 +1,17 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package view + +// UseSchema sets a new schema name for all generated view SQL builder types. It is recommended to invoke +// this method only once at the beginning of the program. +func UseSchema(schema string) { + GeographyColumns = GeographyColumns.FromSchema(schema) + GeometryColumns = GeometryColumns.FromSchema(schema) + RasterColumns = RasterColumns.FromSchema(schema) + RasterOverviews = RasterOverviews.FromSchema(schema) +} diff --git a/db/gen/nidus-sync/publicreport/enum/accuracytype.go b/db/gen/nidus-sync/publicreport/enum/accuracytype.go new file mode 100644 index 00000000..483204c3 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/enum/accuracytype.go @@ -0,0 +1,33 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +// most volues are determined by our geocoding API provider, mapbox. You can read more details at https://docs.mapbox.com/api/search/geocoding/#point-accuracy-for-address-features. +var Accuracytype = &struct { + Rooftop postgres.StringExpression + Parcel postgres.StringExpression + Point postgres.StringExpression + Interpolated postgres.StringExpression + Approximate postgres.StringExpression + Intersection postgres.StringExpression + Centroid postgres.StringExpression + Browser postgres.StringExpression + None postgres.StringExpression +}{ + Rooftop: postgres.NewEnumValue("rooftop"), + Parcel: postgres.NewEnumValue("parcel"), + Point: postgres.NewEnumValue("point"), + Interpolated: postgres.NewEnumValue("interpolated"), + Approximate: postgres.NewEnumValue("approximate"), + Intersection: postgres.NewEnumValue("intersection"), + Centroid: postgres.NewEnumValue("centroid"), + Browser: postgres.NewEnumValue("browser"), + None: postgres.NewEnumValue("none"), +} diff --git a/db/gen/nidus-sync/publicreport/enum/nuisancedurationtype.go b/db/gen/nidus-sync/publicreport/enum/nuisancedurationtype.go new file mode 100644 index 00000000..4f1d83d5 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/enum/nuisancedurationtype.go @@ -0,0 +1,28 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Nuisancedurationtype = &struct { + None postgres.StringExpression + JustNoticed postgres.StringExpression + FewDays postgres.StringExpression + Nuisancedurationtype12Weeks postgres.StringExpression + Nuisancedurationtype24Weeks postgres.StringExpression + Nuisancedurationtype13Months postgres.StringExpression + Seasonal postgres.StringExpression +}{ + None: postgres.NewEnumValue("none"), + JustNoticed: postgres.NewEnumValue("just-noticed"), + FewDays: postgres.NewEnumValue("few-days"), + Nuisancedurationtype12Weeks: postgres.NewEnumValue("1-2-weeks"), + Nuisancedurationtype24Weeks: postgres.NewEnumValue("2-4-weeks"), + Nuisancedurationtype13Months: postgres.NewEnumValue("1-3-months"), + Seasonal: postgres.NewEnumValue("seasonal"), +} diff --git a/db/gen/nidus-sync/publicreport/enum/permissionaccess.go b/db/gen/nidus-sync/publicreport/enum/permissionaccess.go new file mode 100644 index 00000000..41161b89 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/enum/permissionaccess.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Permissionaccess = &struct { + Denied postgres.StringExpression + Granted postgres.StringExpression + Unselected postgres.StringExpression + WithOwner postgres.StringExpression +}{ + Denied: postgres.NewEnumValue("denied"), + Granted: postgres.NewEnumValue("granted"), + Unselected: postgres.NewEnumValue("unselected"), + WithOwner: postgres.NewEnumValue("with-owner"), +} diff --git a/db/gen/nidus-sync/publicreport/enum/poolsourceduration.go b/db/gen/nidus-sync/publicreport/enum/poolsourceduration.go new file mode 100644 index 00000000..224a6468 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/enum/poolsourceduration.go @@ -0,0 +1,26 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Poolsourceduration = &struct { + None postgres.StringExpression + LessThanWeek postgres.StringExpression + Poolsourceduration12Weeks postgres.StringExpression + Poolsourceduration24Weeks postgres.StringExpression + Poolsourceduration13Months postgres.StringExpression + MoreThan3Months postgres.StringExpression +}{ + None: postgres.NewEnumValue("none"), + LessThanWeek: postgres.NewEnumValue("less-than-week"), + Poolsourceduration12Weeks: postgres.NewEnumValue("1-2-weeks"), + Poolsourceduration24Weeks: postgres.NewEnumValue("2-4-weeks"), + Poolsourceduration13Months: postgres.NewEnumValue("1-3-months"), + MoreThan3Months: postgres.NewEnumValue("more-than-3-months"), +} diff --git a/db/gen/nidus-sync/publicreport/enum/reportlogtype.go b/db/gen/nidus-sync/publicreport/enum/reportlogtype.go new file mode 100644 index 00000000..bfe63ff8 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/enum/reportlogtype.go @@ -0,0 +1,28 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Reportlogtype = &struct { + Created postgres.StringExpression + Invalidated postgres.StringExpression + MessageEmail postgres.StringExpression + MessageText postgres.StringExpression + Reviewed postgres.StringExpression + Scheduled postgres.StringExpression + Treated postgres.StringExpression +}{ + Created: postgres.NewEnumValue("created"), + Invalidated: postgres.NewEnumValue("invalidated"), + MessageEmail: postgres.NewEnumValue("message-email"), + MessageText: postgres.NewEnumValue("message-text"), + Reviewed: postgres.NewEnumValue("reviewed"), + Scheduled: postgres.NewEnumValue("scheduled"), + Treated: postgres.NewEnumValue("treated"), +} diff --git a/db/gen/nidus-sync/publicreport/enum/reportstatustype.go b/db/gen/nidus-sync/publicreport/enum/reportstatustype.go new file mode 100644 index 00000000..ef08dd9f --- /dev/null +++ b/db/gen/nidus-sync/publicreport/enum/reportstatustype.go @@ -0,0 +1,24 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Reportstatustype = &struct { + Reported postgres.StringExpression + Reviewed postgres.StringExpression + Scheduled postgres.StringExpression + Treated postgres.StringExpression + Invalidated postgres.StringExpression +}{ + Reported: postgres.NewEnumValue("reported"), + Reviewed: postgres.NewEnumValue("reviewed"), + Scheduled: postgres.NewEnumValue("scheduled"), + Treated: postgres.NewEnumValue("treated"), + Invalidated: postgres.NewEnumValue("invalidated"), +} diff --git a/db/gen/nidus-sync/publicreport/enum/reporttype.go b/db/gen/nidus-sync/publicreport/enum/reporttype.go new file mode 100644 index 00000000..95bd3892 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/enum/reporttype.go @@ -0,0 +1,20 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package enum + +import "github.com/Gleipnir-Technology/jet/postgres" + +var Reporttype = &struct { + Nuisance postgres.StringExpression + Water postgres.StringExpression + Compliance postgres.StringExpression +}{ + Nuisance: postgres.NewEnumValue("nuisance"), + Water: postgres.NewEnumValue("water"), + Compliance: postgres.NewEnumValue("compliance"), +} diff --git a/db/gen/nidus-sync/publicreport/model/accuracytype.go b/db/gen/nidus-sync/publicreport/model/accuracytype.go new file mode 100644 index 00000000..00822fb7 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/accuracytype.go @@ -0,0 +1,78 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +// most volues are determined by our geocoding API provider, mapbox. You can read more details at https://docs.mapbox.com/api/search/geocoding/#point-accuracy-for-address-features. +type Accuracytype string + +const ( + Accuracytype_Rooftop Accuracytype = "rooftop" + Accuracytype_Parcel Accuracytype = "parcel" + Accuracytype_Point Accuracytype = "point" + Accuracytype_Interpolated Accuracytype = "interpolated" + Accuracytype_Approximate Accuracytype = "approximate" + Accuracytype_Intersection Accuracytype = "intersection" + Accuracytype_Centroid Accuracytype = "centroid" + Accuracytype_Browser Accuracytype = "browser" + Accuracytype_None Accuracytype = "none" +) + +var AccuracytypeAllValues = []Accuracytype{ + Accuracytype_Rooftop, + Accuracytype_Parcel, + Accuracytype_Point, + Accuracytype_Interpolated, + Accuracytype_Approximate, + Accuracytype_Intersection, + Accuracytype_Centroid, + Accuracytype_Browser, + Accuracytype_None, +} + +func (e *Accuracytype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "rooftop": + *e = Accuracytype_Rooftop + case "parcel": + *e = Accuracytype_Parcel + case "point": + *e = Accuracytype_Point + case "interpolated": + *e = Accuracytype_Interpolated + case "approximate": + *e = Accuracytype_Approximate + case "intersection": + *e = Accuracytype_Intersection + case "centroid": + *e = Accuracytype_Centroid + case "browser": + *e = Accuracytype_Browser + case "none": + *e = Accuracytype_None + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Accuracytype enum") + } + + return nil +} + +func (e Accuracytype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/publicreport/model/client.go b/db/gen/nidus-sync/publicreport/model/client.go new file mode 100644 index 00000000..5570e091 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/client.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "time" +) + +type Client struct { + Created time.Time + UserAgent string + UUID uuid.UUID `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/compliance.go b/db/gen/nidus-sync/publicreport/model/compliance.go new file mode 100644 index 00000000..c8c58d79 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/compliance.go @@ -0,0 +1,25 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type Compliance struct { + AccessInstructions string + AvailabilityNotes string + Comments string + GateCode string + HasDog *bool + PermissionType Permissionaccess + ReportID int32 `sql:"primary_key"` + ReportPhoneCanText *bool + WantsScheduled *bool + Submitted *time.Time +} diff --git a/db/gen/nidus-sync/publicreport/model/image.go b/db/gen/nidus-sync/publicreport/model/image.go new file mode 100644 index 00000000..3cebdd74 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/image.go @@ -0,0 +1,26 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "github.com/twpayne/go-geom" + "time" +) + +type Image struct { + ID int32 `sql:"primary_key"` + ContentType string + Created time.Time + ResolutionX int32 + ResolutionY int32 + StorageUUID uuid.UUID + StorageSize int64 + UploadedFilename string + Location *geom.T +} diff --git a/db/gen/nidus-sync/publicreport/model/image_exif.go b/db/gen/nidus-sync/publicreport/model/image_exif.go new file mode 100644 index 00000000..0f20862d --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/image_exif.go @@ -0,0 +1,14 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type ImageExif struct { + ImageID int32 `sql:"primary_key"` + Name string `sql:"primary_key"` + Value string `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/notify_email.go b/db/gen/nidus-sync/publicreport/model/notify_email.go new file mode 100644 index 00000000..5816dbcb --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/notify_email.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type NotifyEmail struct { + Created time.Time + Deleted *time.Time + EmailAddress string `sql:"primary_key"` + ReportID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/notify_email_nuisance_old.go b/db/gen/nidus-sync/publicreport/model/notify_email_nuisance_old.go new file mode 100644 index 00000000..c77fa31c --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/notify_email_nuisance_old.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type NotifyEmailNuisanceOld struct { + Created time.Time + Deleted *time.Time + NuisanceID int32 `sql:"primary_key"` + EmailAddress string `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/notify_email_water_old.go b/db/gen/nidus-sync/publicreport/model/notify_email_water_old.go new file mode 100644 index 00000000..aeeb5bbd --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/notify_email_water_old.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type NotifyEmailWaterOld struct { + Created time.Time + Deleted *time.Time + WaterID int32 `sql:"primary_key"` + EmailAddress string `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/notify_phone.go b/db/gen/nidus-sync/publicreport/model/notify_phone.go new file mode 100644 index 00000000..bb8c6d40 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/notify_phone.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type NotifyPhone struct { + Created time.Time + Deleted *time.Time + PhoneE164 string `sql:"primary_key"` + ReportID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/notify_phone_nuisance_old.go b/db/gen/nidus-sync/publicreport/model/notify_phone_nuisance_old.go new file mode 100644 index 00000000..9837ed72 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/notify_phone_nuisance_old.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type NotifyPhoneNuisanceOld struct { + Created time.Time + Deleted *time.Time + NuisanceID int32 `sql:"primary_key"` + PhoneE164 string `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/notify_phone_water_old.go b/db/gen/nidus-sync/publicreport/model/notify_phone_water_old.go new file mode 100644 index 00000000..2edd8920 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/notify_phone_water_old.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type NotifyPhoneWaterOld struct { + Created time.Time + Deleted *time.Time + PhoneE164 string `sql:"primary_key"` + WaterID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/nuisance.go b/db/gen/nidus-sync/publicreport/model/nuisance.go new file mode 100644 index 00000000..1e4d909d --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/nuisance.go @@ -0,0 +1,27 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type Nuisance struct { + AdditionalInfo string + Duration Nuisancedurationtype + IsLocationBackyard bool + IsLocationFrontyard bool + IsLocationGarden bool + IsLocationOther bool + IsLocationPool bool + ReportID int32 `sql:"primary_key"` + SourceContainer bool + SourceDescription string + SourceStagnant bool + SourceGutter bool + TodEarly bool + TodDay bool + TodEvening bool + TodNight bool +} diff --git a/db/gen/nidus-sync/publicreport/model/nuisance_image_old.go b/db/gen/nidus-sync/publicreport/model/nuisance_image_old.go new file mode 100644 index 00000000..88636a39 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/nuisance_image_old.go @@ -0,0 +1,13 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type NuisanceImageOld struct { + ImageID int32 `sql:"primary_key"` + NuisanceID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/nuisance_old.go b/db/gen/nidus-sync/publicreport/model/nuisance_old.go new file mode 100644 index 00000000..8a303b80 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/nuisance_old.go @@ -0,0 +1,55 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" + "time" +) + +type NuisanceOld struct { + ID int32 `sql:"primary_key"` + AdditionalInfo string + Created time.Time + Duration Nuisancedurationtype + SourceContainer bool + SourceDescription string + SourceStagnant bool + PublicID string + ReporterEmail *string + ReporterName *string + ReporterPhone *string + AddressRaw string + Status Reportstatustype + OrganizationID int32 + SourceGutter bool + H3cell *string + AddressCountry string + AddressLocality string + AddressPostalCode string + AddressRegion string + AddressStreet string + IsLocationBackyard bool + IsLocationFrontyard bool + IsLocationGarden bool + IsLocationOther bool + IsLocationPool bool + MapZoom float32 + TodEarly bool + TodDay bool + TodEvening bool + TodNight bool + LatlngAccuracyType Accuracytype + LatlngAccuracyValue float32 + ReporterContactConsent *bool + Location *geom.T + AddressNumber string + AddressID *int32 + Reviewed *time.Time + ReviewerID *int32 +} diff --git a/db/gen/nidus-sync/publicreport/model/nuisancedurationtype.go b/db/gen/nidus-sync/publicreport/model/nuisancedurationtype.go new file mode 100644 index 00000000..0113902f --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/nuisancedurationtype.go @@ -0,0 +1,69 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Nuisancedurationtype string + +const ( + Nuisancedurationtype_None Nuisancedurationtype = "none" + Nuisancedurationtype_JustNoticed Nuisancedurationtype = "just-noticed" + Nuisancedurationtype_FewDays Nuisancedurationtype = "few-days" + Nuisancedurationtype_12Weeks Nuisancedurationtype = "1-2-weeks" + Nuisancedurationtype_24Weeks Nuisancedurationtype = "2-4-weeks" + Nuisancedurationtype_13Months Nuisancedurationtype = "1-3-months" + Nuisancedurationtype_Seasonal Nuisancedurationtype = "seasonal" +) + +var NuisancedurationtypeAllValues = []Nuisancedurationtype{ + Nuisancedurationtype_None, + Nuisancedurationtype_JustNoticed, + Nuisancedurationtype_FewDays, + Nuisancedurationtype_12Weeks, + Nuisancedurationtype_24Weeks, + Nuisancedurationtype_13Months, + Nuisancedurationtype_Seasonal, +} + +func (e *Nuisancedurationtype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "none": + *e = Nuisancedurationtype_None + case "just-noticed": + *e = Nuisancedurationtype_JustNoticed + case "few-days": + *e = Nuisancedurationtype_FewDays + case "1-2-weeks": + *e = Nuisancedurationtype_12Weeks + case "2-4-weeks": + *e = Nuisancedurationtype_24Weeks + case "1-3-months": + *e = Nuisancedurationtype_13Months + case "seasonal": + *e = Nuisancedurationtype_Seasonal + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Nuisancedurationtype enum") + } + + return nil +} + +func (e Nuisancedurationtype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/publicreport/model/organization_report_count.go b/db/gen/nidus-sync/publicreport/model/organization_report_count.go new file mode 100644 index 00000000..7b0f71d0 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/organization_report_count.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type OrganizationReportCount struct { + OrganizationID *int32 + NuisanceReported *int64 + NuisanceReviewed *int64 + NuisanceScheduled *int64 + NuisanceTreated *int64 + NuisanceInvalidated *int64 + WaterReported *int64 + WaterReviewed *int64 + WaterScheduled *int64 + WaterTreated *int64 + WaterInvalidated *int64 +} diff --git a/db/gen/nidus-sync/publicreport/model/permissionaccess.go b/db/gen/nidus-sync/publicreport/model/permissionaccess.go new file mode 100644 index 00000000..ee8543d5 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/permissionaccess.go @@ -0,0 +1,57 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Permissionaccess string + +const ( + Permissionaccess_Denied Permissionaccess = "denied" + Permissionaccess_Granted Permissionaccess = "granted" + Permissionaccess_Unselected Permissionaccess = "unselected" + Permissionaccess_WithOwner Permissionaccess = "with-owner" +) + +var PermissionaccessAllValues = []Permissionaccess{ + Permissionaccess_Denied, + Permissionaccess_Granted, + Permissionaccess_Unselected, + Permissionaccess_WithOwner, +} + +func (e *Permissionaccess) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "denied": + *e = Permissionaccess_Denied + case "granted": + *e = Permissionaccess_Granted + case "unselected": + *e = Permissionaccess_Unselected + case "with-owner": + *e = Permissionaccess_WithOwner + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Permissionaccess enum") + } + + return nil +} + +func (e Permissionaccess) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/publicreport/model/poolsourceduration.go b/db/gen/nidus-sync/publicreport/model/poolsourceduration.go new file mode 100644 index 00000000..e5f100c3 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/poolsourceduration.go @@ -0,0 +1,65 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Poolsourceduration string + +const ( + Poolsourceduration_None Poolsourceduration = "none" + Poolsourceduration_LessThanWeek Poolsourceduration = "less-than-week" + Poolsourceduration_12Weeks Poolsourceduration = "1-2-weeks" + Poolsourceduration_24Weeks Poolsourceduration = "2-4-weeks" + Poolsourceduration_13Months Poolsourceduration = "1-3-months" + Poolsourceduration_MoreThan3Months Poolsourceduration = "more-than-3-months" +) + +var PoolsourcedurationAllValues = []Poolsourceduration{ + Poolsourceduration_None, + Poolsourceduration_LessThanWeek, + Poolsourceduration_12Weeks, + Poolsourceduration_24Weeks, + Poolsourceduration_13Months, + Poolsourceduration_MoreThan3Months, +} + +func (e *Poolsourceduration) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "none": + *e = Poolsourceduration_None + case "less-than-week": + *e = Poolsourceduration_LessThanWeek + case "1-2-weeks": + *e = Poolsourceduration_12Weeks + case "2-4-weeks": + *e = Poolsourceduration_24Weeks + case "1-3-months": + *e = Poolsourceduration_13Months + case "more-than-3-months": + *e = Poolsourceduration_MoreThan3Months + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Poolsourceduration enum") + } + + return nil +} + +func (e Poolsourceduration) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/publicreport/model/report.go b/db/gen/nidus-sync/publicreport/model/report.go new file mode 100644 index 00000000..1265ae09 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/report.go @@ -0,0 +1,39 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/google/uuid" + "github.com/twpayne/go-geom" + "time" +) + +type Report struct { + AddressRaw string + AddressID *int32 + Created time.Time + Location *geom.T + H3cell *string + ID int32 `sql:"primary_key"` + LatlngAccuracyType Accuracytype + LatlngAccuracyValue float32 + MapZoom float32 + OrganizationID int32 + PublicID string + ReporterName string + ReporterEmail string + ReporterPhone string + ReporterContactConsent *bool + ReportType Reporttype + Reviewed *time.Time + ReviewerID *int32 + Status Reportstatustype + AddressGid string + ClientUUID *uuid.UUID + ReporterPhoneCanSms bool +} diff --git a/db/gen/nidus-sync/publicreport/model/report_image.go b/db/gen/nidus-sync/publicreport/model/report_image.go new file mode 100644 index 00000000..aff8d7e3 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/report_image.go @@ -0,0 +1,13 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type ReportImage struct { + ImageID int32 `sql:"primary_key"` + ReportID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/report_log.go b/db/gen/nidus-sync/publicreport/model/report_log.go new file mode 100644 index 00000000..8de92d08 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/report_log.go @@ -0,0 +1,22 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type ReportLog struct { + Created time.Time + EmailLogID *int32 + ID int32 `sql:"primary_key"` + ReportID int32 + TextLogID *int32 + Type Reportlogtype + UserID *int32 +} diff --git a/db/gen/nidus-sync/publicreport/model/reportlogtype.go b/db/gen/nidus-sync/publicreport/model/reportlogtype.go new file mode 100644 index 00000000..2dba7b18 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/reportlogtype.go @@ -0,0 +1,69 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Reportlogtype string + +const ( + Reportlogtype_Created Reportlogtype = "created" + Reportlogtype_Invalidated Reportlogtype = "invalidated" + Reportlogtype_MessageEmail Reportlogtype = "message-email" + Reportlogtype_MessageText Reportlogtype = "message-text" + Reportlogtype_Reviewed Reportlogtype = "reviewed" + Reportlogtype_Scheduled Reportlogtype = "scheduled" + Reportlogtype_Treated Reportlogtype = "treated" +) + +var ReportlogtypeAllValues = []Reportlogtype{ + Reportlogtype_Created, + Reportlogtype_Invalidated, + Reportlogtype_MessageEmail, + Reportlogtype_MessageText, + Reportlogtype_Reviewed, + Reportlogtype_Scheduled, + Reportlogtype_Treated, +} + +func (e *Reportlogtype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "created": + *e = Reportlogtype_Created + case "invalidated": + *e = Reportlogtype_Invalidated + case "message-email": + *e = Reportlogtype_MessageEmail + case "message-text": + *e = Reportlogtype_MessageText + case "reviewed": + *e = Reportlogtype_Reviewed + case "scheduled": + *e = Reportlogtype_Scheduled + case "treated": + *e = Reportlogtype_Treated + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Reportlogtype enum") + } + + return nil +} + +func (e Reportlogtype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/publicreport/model/reportstatustype.go b/db/gen/nidus-sync/publicreport/model/reportstatustype.go new file mode 100644 index 00000000..60723847 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/reportstatustype.go @@ -0,0 +1,61 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Reportstatustype string + +const ( + Reportstatustype_Reported Reportstatustype = "reported" + Reportstatustype_Reviewed Reportstatustype = "reviewed" + Reportstatustype_Scheduled Reportstatustype = "scheduled" + Reportstatustype_Treated Reportstatustype = "treated" + Reportstatustype_Invalidated Reportstatustype = "invalidated" +) + +var ReportstatustypeAllValues = []Reportstatustype{ + Reportstatustype_Reported, + Reportstatustype_Reviewed, + Reportstatustype_Scheduled, + Reportstatustype_Treated, + Reportstatustype_Invalidated, +} + +func (e *Reportstatustype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "reported": + *e = Reportstatustype_Reported + case "reviewed": + *e = Reportstatustype_Reviewed + case "scheduled": + *e = Reportstatustype_Scheduled + case "treated": + *e = Reportstatustype_Treated + case "invalidated": + *e = Reportstatustype_Invalidated + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Reportstatustype enum") + } + + return nil +} + +func (e Reportstatustype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/publicreport/model/reporttype.go b/db/gen/nidus-sync/publicreport/model/reporttype.go new file mode 100644 index 00000000..589fbaa1 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/reporttype.go @@ -0,0 +1,53 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import "errors" + +type Reporttype string + +const ( + Reporttype_Nuisance Reporttype = "nuisance" + Reporttype_Water Reporttype = "water" + Reporttype_Compliance Reporttype = "compliance" +) + +var ReporttypeAllValues = []Reporttype{ + Reporttype_Nuisance, + Reporttype_Water, + Reporttype_Compliance, +} + +func (e *Reporttype) Scan(value interface{}) error { + var enumValue string + switch val := value.(type) { + case string: + enumValue = val + case []byte: + enumValue = string(val) + default: + return errors.New("jet: Invalid scan value for AllTypesEnum enum. Enum value has to be of type string or []byte") + } + + switch enumValue { + case "nuisance": + *e = Reporttype_Nuisance + case "water": + *e = Reporttype_Water + case "compliance": + *e = Reporttype_Compliance + default: + return errors.New("jet: Invalid scan value '" + enumValue + "' for Reporttype enum") + } + + return nil +} + +func (e Reporttype) String() string { + return string(e) +} diff --git a/db/gen/nidus-sync/publicreport/model/subscribe_email.go b/db/gen/nidus-sync/publicreport/model/subscribe_email.go new file mode 100644 index 00000000..9999d1fa --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/subscribe_email.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type SubscribeEmail struct { + Created time.Time + Deleted *time.Time + EmailAddress string + ID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/subscribe_phone.go b/db/gen/nidus-sync/publicreport/model/subscribe_phone.go new file mode 100644 index 00000000..c56a56ee --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/subscribe_phone.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type SubscribePhone struct { + Created time.Time + Deleted *time.Time + ID int32 `sql:"primary_key"` + PhoneE164 string +} diff --git a/db/gen/nidus-sync/publicreport/model/water.go b/db/gen/nidus-sync/publicreport/model/water.go new file mode 100644 index 00000000..7d9f3ce1 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/water.go @@ -0,0 +1,29 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type Water struct { + AccessComments string + AccessGate bool + AccessFence bool + AccessLocked bool + AccessDog bool + AccessOther bool + Comments string + IsReporterConfidential bool + IsReporterOwner bool + HasAdult bool + HasBackyardPermission bool + HasLarvae bool + HasPupae bool + OwnerEmail string + OwnerName string + OwnerPhone string + ReportID int32 `sql:"primary_key"` + Duration Nuisancedurationtype +} diff --git a/db/gen/nidus-sync/publicreport/model/water_image_old.go b/db/gen/nidus-sync/publicreport/model/water_image_old.go new file mode 100644 index 00000000..c7bf9cf1 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/water_image_old.go @@ -0,0 +1,13 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +type WaterImageOld struct { + ImageID int32 `sql:"primary_key"` + WaterID int32 `sql:"primary_key"` +} diff --git a/db/gen/nidus-sync/publicreport/model/water_old.go b/db/gen/nidus-sync/publicreport/model/water_old.go new file mode 100644 index 00000000..a9f85db0 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/model/water_old.go @@ -0,0 +1,54 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "github.com/twpayne/go-geom" + "time" +) + +type WaterOld struct { + ID int32 `sql:"primary_key"` + AccessComments string + AccessGate bool + AccessFence bool + AccessLocked bool + AccessDog bool + AccessOther bool + AddressRaw string + AddressCountry string + AddressPostalCode string + AddressLocality string + AddressStreet string + AddressRegion string + Comments string + Created time.Time + H3cell *string + HasAdult bool + HasLarvae bool + HasPupae bool + MapZoom float32 + OwnerEmail string + OwnerName string + OwnerPhone string + PublicID string + ReporterEmail string + ReporterName string + ReporterPhone string + Status Reportstatustype + OrganizationID int32 + HasBackyardPermission bool + IsReporterConfidential bool + IsReporterOwner bool + ReporterContactConsent *bool + Location *geom.T + AddressNumber string + AddressID *int32 + Reviewed *time.Time + ReviewerID *int32 +} diff --git a/db/gen/nidus-sync/publicreport/table/client.go b/db/gen/nidus-sync/publicreport/table/client.go new file mode 100644 index 00000000..d7e9dc99 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/client.go @@ -0,0 +1,84 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Client = newClientTable("publicreport", "client", "") + +type clientTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + UserAgent postgres.ColumnString + UUID postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ClientTable struct { + clientTable + + EXCLUDED clientTable +} + +// AS creates new ClientTable with assigned alias +func (a ClientTable) AS(alias string) *ClientTable { + return newClientTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ClientTable with assigned schema name +func (a ClientTable) FromSchema(schemaName string) *ClientTable { + return newClientTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ClientTable with assigned table prefix +func (a ClientTable) WithPrefix(prefix string) *ClientTable { + return newClientTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ClientTable with assigned table suffix +func (a ClientTable) WithSuffix(suffix string) *ClientTable { + return newClientTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newClientTable(schemaName, tableName, alias string) *ClientTable { + return &ClientTable{ + clientTable: newClientTableImpl(schemaName, tableName, alias), + EXCLUDED: newClientTableImpl("", "excluded", ""), + } +} + +func newClientTableImpl(schemaName, tableName, alias string) clientTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + UserAgentColumn = postgres.StringColumn("user_agent") + UUIDColumn = postgres.StringColumn("uuid") + allColumns = postgres.ColumnList{CreatedColumn, UserAgentColumn, UUIDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, UserAgentColumn} + defaultColumns = postgres.ColumnList{} + ) + + return clientTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + UserAgent: UserAgentColumn, + UUID: UUIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/compliance.go b/db/gen/nidus-sync/publicreport/table/compliance.go new file mode 100644 index 00000000..12e71b30 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/compliance.go @@ -0,0 +1,105 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Compliance = newComplianceTable("publicreport", "compliance", "") + +type complianceTable struct { + postgres.Table + + // Columns + AccessInstructions postgres.ColumnString + AvailabilityNotes postgres.ColumnString + Comments postgres.ColumnString + GateCode postgres.ColumnString + HasDog postgres.ColumnBool + PermissionType postgres.ColumnString + ReportID postgres.ColumnInteger + ReportPhoneCanText postgres.ColumnBool + WantsScheduled postgres.ColumnBool + Submitted postgres.ColumnTimestamp + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ComplianceTable struct { + complianceTable + + EXCLUDED complianceTable +} + +// AS creates new ComplianceTable with assigned alias +func (a ComplianceTable) AS(alias string) *ComplianceTable { + return newComplianceTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ComplianceTable with assigned schema name +func (a ComplianceTable) FromSchema(schemaName string) *ComplianceTable { + return newComplianceTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ComplianceTable with assigned table prefix +func (a ComplianceTable) WithPrefix(prefix string) *ComplianceTable { + return newComplianceTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ComplianceTable with assigned table suffix +func (a ComplianceTable) WithSuffix(suffix string) *ComplianceTable { + return newComplianceTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newComplianceTable(schemaName, tableName, alias string) *ComplianceTable { + return &ComplianceTable{ + complianceTable: newComplianceTableImpl(schemaName, tableName, alias), + EXCLUDED: newComplianceTableImpl("", "excluded", ""), + } +} + +func newComplianceTableImpl(schemaName, tableName, alias string) complianceTable { + var ( + AccessInstructionsColumn = postgres.StringColumn("access_instructions") + AvailabilityNotesColumn = postgres.StringColumn("availability_notes") + CommentsColumn = postgres.StringColumn("comments") + GateCodeColumn = postgres.StringColumn("gate_code") + HasDogColumn = postgres.BoolColumn("has_dog") + PermissionTypeColumn = postgres.StringColumn("permission_type") + ReportIDColumn = postgres.IntegerColumn("report_id") + ReportPhoneCanTextColumn = postgres.BoolColumn("report_phone_can_text") + WantsScheduledColumn = postgres.BoolColumn("wants_scheduled") + SubmittedColumn = postgres.TimestampColumn("submitted") + allColumns = postgres.ColumnList{AccessInstructionsColumn, AvailabilityNotesColumn, CommentsColumn, GateCodeColumn, HasDogColumn, PermissionTypeColumn, ReportIDColumn, ReportPhoneCanTextColumn, WantsScheduledColumn, SubmittedColumn} + mutableColumns = postgres.ColumnList{AccessInstructionsColumn, AvailabilityNotesColumn, CommentsColumn, GateCodeColumn, HasDogColumn, PermissionTypeColumn, ReportPhoneCanTextColumn, WantsScheduledColumn, SubmittedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return complianceTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + AccessInstructions: AccessInstructionsColumn, + AvailabilityNotes: AvailabilityNotesColumn, + Comments: CommentsColumn, + GateCode: GateCodeColumn, + HasDog: HasDogColumn, + PermissionType: PermissionTypeColumn, + ReportID: ReportIDColumn, + ReportPhoneCanText: ReportPhoneCanTextColumn, + WantsScheduled: WantsScheduledColumn, + Submitted: SubmittedColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/image.go b/db/gen/nidus-sync/publicreport/table/image.go new file mode 100644 index 00000000..15cb4f2d --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/image.go @@ -0,0 +1,102 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Image = newImageTable("publicreport", "image", "") + +type imageTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + ContentType postgres.ColumnString + Created postgres.ColumnTimestamp + ResolutionX postgres.ColumnInteger + ResolutionY postgres.ColumnInteger + StorageUUID postgres.ColumnString + StorageSize postgres.ColumnInteger + UploadedFilename postgres.ColumnString + Location postgres.ColumnGeometry + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ImageTable struct { + imageTable + + EXCLUDED imageTable +} + +// AS creates new ImageTable with assigned alias +func (a ImageTable) AS(alias string) *ImageTable { + return newImageTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ImageTable with assigned schema name +func (a ImageTable) FromSchema(schemaName string) *ImageTable { + return newImageTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ImageTable with assigned table prefix +func (a ImageTable) WithPrefix(prefix string) *ImageTable { + return newImageTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ImageTable with assigned table suffix +func (a ImageTable) WithSuffix(suffix string) *ImageTable { + return newImageTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newImageTable(schemaName, tableName, alias string) *ImageTable { + return &ImageTable{ + imageTable: newImageTableImpl(schemaName, tableName, alias), + EXCLUDED: newImageTableImpl("", "excluded", ""), + } +} + +func newImageTableImpl(schemaName, tableName, alias string) imageTable { + var ( + IDColumn = postgres.IntegerColumn("id") + ContentTypeColumn = postgres.StringColumn("content_type") + CreatedColumn = postgres.TimestampColumn("created") + ResolutionXColumn = postgres.IntegerColumn("resolution_x") + ResolutionYColumn = postgres.IntegerColumn("resolution_y") + StorageUUIDColumn = postgres.StringColumn("storage_uuid") + StorageSizeColumn = postgres.IntegerColumn("storage_size") + UploadedFilenameColumn = postgres.StringColumn("uploaded_filename") + LocationColumn = postgres.GeometryColumn("location") + allColumns = postgres.ColumnList{IDColumn, ContentTypeColumn, CreatedColumn, ResolutionXColumn, ResolutionYColumn, StorageUUIDColumn, StorageSizeColumn, UploadedFilenameColumn, LocationColumn} + mutableColumns = postgres.ColumnList{ContentTypeColumn, CreatedColumn, ResolutionXColumn, ResolutionYColumn, StorageUUIDColumn, StorageSizeColumn, UploadedFilenameColumn, LocationColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return imageTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + ContentType: ContentTypeColumn, + Created: CreatedColumn, + ResolutionX: ResolutionXColumn, + ResolutionY: ResolutionYColumn, + StorageUUID: StorageUUIDColumn, + StorageSize: StorageSizeColumn, + UploadedFilename: UploadedFilenameColumn, + Location: LocationColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/image_exif.go b/db/gen/nidus-sync/publicreport/table/image_exif.go new file mode 100644 index 00000000..66b48f7a --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/image_exif.go @@ -0,0 +1,84 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ImageExif = newImageExifTable("publicreport", "image_exif", "") + +type imageExifTable struct { + postgres.Table + + // Columns + ImageID postgres.ColumnInteger + Name postgres.ColumnString + Value postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ImageExifTable struct { + imageExifTable + + EXCLUDED imageExifTable +} + +// AS creates new ImageExifTable with assigned alias +func (a ImageExifTable) AS(alias string) *ImageExifTable { + return newImageExifTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ImageExifTable with assigned schema name +func (a ImageExifTable) FromSchema(schemaName string) *ImageExifTable { + return newImageExifTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ImageExifTable with assigned table prefix +func (a ImageExifTable) WithPrefix(prefix string) *ImageExifTable { + return newImageExifTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ImageExifTable with assigned table suffix +func (a ImageExifTable) WithSuffix(suffix string) *ImageExifTable { + return newImageExifTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newImageExifTable(schemaName, tableName, alias string) *ImageExifTable { + return &ImageExifTable{ + imageExifTable: newImageExifTableImpl(schemaName, tableName, alias), + EXCLUDED: newImageExifTableImpl("", "excluded", ""), + } +} + +func newImageExifTableImpl(schemaName, tableName, alias string) imageExifTable { + var ( + ImageIDColumn = postgres.IntegerColumn("image_id") + NameColumn = postgres.StringColumn("name") + ValueColumn = postgres.StringColumn("value") + allColumns = postgres.ColumnList{ImageIDColumn, NameColumn, ValueColumn} + mutableColumns = postgres.ColumnList{} + defaultColumns = postgres.ColumnList{} + ) + + return imageExifTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ImageID: ImageIDColumn, + Name: NameColumn, + Value: ValueColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/notify_email.go b/db/gen/nidus-sync/publicreport/table/notify_email.go new file mode 100644 index 00000000..9029c0a3 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/notify_email.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NotifyEmail = newNotifyEmailTable("publicreport", "notify_email", "") + +type notifyEmailTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Deleted postgres.ColumnTimestamp + EmailAddress postgres.ColumnString + ReportID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NotifyEmailTable struct { + notifyEmailTable + + EXCLUDED notifyEmailTable +} + +// AS creates new NotifyEmailTable with assigned alias +func (a NotifyEmailTable) AS(alias string) *NotifyEmailTable { + return newNotifyEmailTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NotifyEmailTable with assigned schema name +func (a NotifyEmailTable) FromSchema(schemaName string) *NotifyEmailTable { + return newNotifyEmailTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NotifyEmailTable with assigned table prefix +func (a NotifyEmailTable) WithPrefix(prefix string) *NotifyEmailTable { + return newNotifyEmailTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NotifyEmailTable with assigned table suffix +func (a NotifyEmailTable) WithSuffix(suffix string) *NotifyEmailTable { + return newNotifyEmailTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNotifyEmailTable(schemaName, tableName, alias string) *NotifyEmailTable { + return &NotifyEmailTable{ + notifyEmailTable: newNotifyEmailTableImpl(schemaName, tableName, alias), + EXCLUDED: newNotifyEmailTableImpl("", "excluded", ""), + } +} + +func newNotifyEmailTableImpl(schemaName, tableName, alias string) notifyEmailTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + DeletedColumn = postgres.TimestampColumn("deleted") + EmailAddressColumn = postgres.StringColumn("email_address") + ReportIDColumn = postgres.IntegerColumn("report_id") + allColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, EmailAddressColumn, ReportIDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, DeletedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return notifyEmailTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Deleted: DeletedColumn, + EmailAddress: EmailAddressColumn, + ReportID: ReportIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/notify_email_nuisance_old.go b/db/gen/nidus-sync/publicreport/table/notify_email_nuisance_old.go new file mode 100644 index 00000000..6a637462 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/notify_email_nuisance_old.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NotifyEmailNuisanceOld = newNotifyEmailNuisanceOldTable("publicreport", "notify_email_nuisance_old", "") + +type notifyEmailNuisanceOldTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Deleted postgres.ColumnTimestamp + NuisanceID postgres.ColumnInteger + EmailAddress postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NotifyEmailNuisanceOldTable struct { + notifyEmailNuisanceOldTable + + EXCLUDED notifyEmailNuisanceOldTable +} + +// AS creates new NotifyEmailNuisanceOldTable with assigned alias +func (a NotifyEmailNuisanceOldTable) AS(alias string) *NotifyEmailNuisanceOldTable { + return newNotifyEmailNuisanceOldTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NotifyEmailNuisanceOldTable with assigned schema name +func (a NotifyEmailNuisanceOldTable) FromSchema(schemaName string) *NotifyEmailNuisanceOldTable { + return newNotifyEmailNuisanceOldTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NotifyEmailNuisanceOldTable with assigned table prefix +func (a NotifyEmailNuisanceOldTable) WithPrefix(prefix string) *NotifyEmailNuisanceOldTable { + return newNotifyEmailNuisanceOldTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NotifyEmailNuisanceOldTable with assigned table suffix +func (a NotifyEmailNuisanceOldTable) WithSuffix(suffix string) *NotifyEmailNuisanceOldTable { + return newNotifyEmailNuisanceOldTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNotifyEmailNuisanceOldTable(schemaName, tableName, alias string) *NotifyEmailNuisanceOldTable { + return &NotifyEmailNuisanceOldTable{ + notifyEmailNuisanceOldTable: newNotifyEmailNuisanceOldTableImpl(schemaName, tableName, alias), + EXCLUDED: newNotifyEmailNuisanceOldTableImpl("", "excluded", ""), + } +} + +func newNotifyEmailNuisanceOldTableImpl(schemaName, tableName, alias string) notifyEmailNuisanceOldTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + DeletedColumn = postgres.TimestampColumn("deleted") + NuisanceIDColumn = postgres.IntegerColumn("nuisance_id") + EmailAddressColumn = postgres.StringColumn("email_address") + allColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, NuisanceIDColumn, EmailAddressColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, DeletedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return notifyEmailNuisanceOldTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Deleted: DeletedColumn, + NuisanceID: NuisanceIDColumn, + EmailAddress: EmailAddressColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/notify_email_water_old.go b/db/gen/nidus-sync/publicreport/table/notify_email_water_old.go new file mode 100644 index 00000000..c22a1420 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/notify_email_water_old.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NotifyEmailWaterOld = newNotifyEmailWaterOldTable("publicreport", "notify_email_water_old", "") + +type notifyEmailWaterOldTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Deleted postgres.ColumnTimestamp + WaterID postgres.ColumnInteger + EmailAddress postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NotifyEmailWaterOldTable struct { + notifyEmailWaterOldTable + + EXCLUDED notifyEmailWaterOldTable +} + +// AS creates new NotifyEmailWaterOldTable with assigned alias +func (a NotifyEmailWaterOldTable) AS(alias string) *NotifyEmailWaterOldTable { + return newNotifyEmailWaterOldTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NotifyEmailWaterOldTable with assigned schema name +func (a NotifyEmailWaterOldTable) FromSchema(schemaName string) *NotifyEmailWaterOldTable { + return newNotifyEmailWaterOldTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NotifyEmailWaterOldTable with assigned table prefix +func (a NotifyEmailWaterOldTable) WithPrefix(prefix string) *NotifyEmailWaterOldTable { + return newNotifyEmailWaterOldTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NotifyEmailWaterOldTable with assigned table suffix +func (a NotifyEmailWaterOldTable) WithSuffix(suffix string) *NotifyEmailWaterOldTable { + return newNotifyEmailWaterOldTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNotifyEmailWaterOldTable(schemaName, tableName, alias string) *NotifyEmailWaterOldTable { + return &NotifyEmailWaterOldTable{ + notifyEmailWaterOldTable: newNotifyEmailWaterOldTableImpl(schemaName, tableName, alias), + EXCLUDED: newNotifyEmailWaterOldTableImpl("", "excluded", ""), + } +} + +func newNotifyEmailWaterOldTableImpl(schemaName, tableName, alias string) notifyEmailWaterOldTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + DeletedColumn = postgres.TimestampColumn("deleted") + WaterIDColumn = postgres.IntegerColumn("water_id") + EmailAddressColumn = postgres.StringColumn("email_address") + allColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, WaterIDColumn, EmailAddressColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, DeletedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return notifyEmailWaterOldTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Deleted: DeletedColumn, + WaterID: WaterIDColumn, + EmailAddress: EmailAddressColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/notify_phone.go b/db/gen/nidus-sync/publicreport/table/notify_phone.go new file mode 100644 index 00000000..928469e7 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/notify_phone.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NotifyPhone = newNotifyPhoneTable("publicreport", "notify_phone", "") + +type notifyPhoneTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Deleted postgres.ColumnTimestamp + PhoneE164 postgres.ColumnString + ReportID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NotifyPhoneTable struct { + notifyPhoneTable + + EXCLUDED notifyPhoneTable +} + +// AS creates new NotifyPhoneTable with assigned alias +func (a NotifyPhoneTable) AS(alias string) *NotifyPhoneTable { + return newNotifyPhoneTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NotifyPhoneTable with assigned schema name +func (a NotifyPhoneTable) FromSchema(schemaName string) *NotifyPhoneTable { + return newNotifyPhoneTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NotifyPhoneTable with assigned table prefix +func (a NotifyPhoneTable) WithPrefix(prefix string) *NotifyPhoneTable { + return newNotifyPhoneTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NotifyPhoneTable with assigned table suffix +func (a NotifyPhoneTable) WithSuffix(suffix string) *NotifyPhoneTable { + return newNotifyPhoneTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNotifyPhoneTable(schemaName, tableName, alias string) *NotifyPhoneTable { + return &NotifyPhoneTable{ + notifyPhoneTable: newNotifyPhoneTableImpl(schemaName, tableName, alias), + EXCLUDED: newNotifyPhoneTableImpl("", "excluded", ""), + } +} + +func newNotifyPhoneTableImpl(schemaName, tableName, alias string) notifyPhoneTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + DeletedColumn = postgres.TimestampColumn("deleted") + PhoneE164Column = postgres.StringColumn("phone_e164") + ReportIDColumn = postgres.IntegerColumn("report_id") + allColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, PhoneE164Column, ReportIDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, DeletedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return notifyPhoneTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Deleted: DeletedColumn, + PhoneE164: PhoneE164Column, + ReportID: ReportIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/notify_phone_nuisance_old.go b/db/gen/nidus-sync/publicreport/table/notify_phone_nuisance_old.go new file mode 100644 index 00000000..a91a2309 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/notify_phone_nuisance_old.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NotifyPhoneNuisanceOld = newNotifyPhoneNuisanceOldTable("publicreport", "notify_phone_nuisance_old", "") + +type notifyPhoneNuisanceOldTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Deleted postgres.ColumnTimestamp + NuisanceID postgres.ColumnInteger + PhoneE164 postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NotifyPhoneNuisanceOldTable struct { + notifyPhoneNuisanceOldTable + + EXCLUDED notifyPhoneNuisanceOldTable +} + +// AS creates new NotifyPhoneNuisanceOldTable with assigned alias +func (a NotifyPhoneNuisanceOldTable) AS(alias string) *NotifyPhoneNuisanceOldTable { + return newNotifyPhoneNuisanceOldTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NotifyPhoneNuisanceOldTable with assigned schema name +func (a NotifyPhoneNuisanceOldTable) FromSchema(schemaName string) *NotifyPhoneNuisanceOldTable { + return newNotifyPhoneNuisanceOldTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NotifyPhoneNuisanceOldTable with assigned table prefix +func (a NotifyPhoneNuisanceOldTable) WithPrefix(prefix string) *NotifyPhoneNuisanceOldTable { + return newNotifyPhoneNuisanceOldTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NotifyPhoneNuisanceOldTable with assigned table suffix +func (a NotifyPhoneNuisanceOldTable) WithSuffix(suffix string) *NotifyPhoneNuisanceOldTable { + return newNotifyPhoneNuisanceOldTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNotifyPhoneNuisanceOldTable(schemaName, tableName, alias string) *NotifyPhoneNuisanceOldTable { + return &NotifyPhoneNuisanceOldTable{ + notifyPhoneNuisanceOldTable: newNotifyPhoneNuisanceOldTableImpl(schemaName, tableName, alias), + EXCLUDED: newNotifyPhoneNuisanceOldTableImpl("", "excluded", ""), + } +} + +func newNotifyPhoneNuisanceOldTableImpl(schemaName, tableName, alias string) notifyPhoneNuisanceOldTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + DeletedColumn = postgres.TimestampColumn("deleted") + NuisanceIDColumn = postgres.IntegerColumn("nuisance_id") + PhoneE164Column = postgres.StringColumn("phone_e164") + allColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, NuisanceIDColumn, PhoneE164Column} + mutableColumns = postgres.ColumnList{CreatedColumn, DeletedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return notifyPhoneNuisanceOldTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Deleted: DeletedColumn, + NuisanceID: NuisanceIDColumn, + PhoneE164: PhoneE164Column, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/notify_phone_water_old.go b/db/gen/nidus-sync/publicreport/table/notify_phone_water_old.go new file mode 100644 index 00000000..e94d46f5 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/notify_phone_water_old.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NotifyPhoneWaterOld = newNotifyPhoneWaterOldTable("publicreport", "notify_phone_water_old", "") + +type notifyPhoneWaterOldTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Deleted postgres.ColumnTimestamp + PhoneE164 postgres.ColumnString + WaterID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NotifyPhoneWaterOldTable struct { + notifyPhoneWaterOldTable + + EXCLUDED notifyPhoneWaterOldTable +} + +// AS creates new NotifyPhoneWaterOldTable with assigned alias +func (a NotifyPhoneWaterOldTable) AS(alias string) *NotifyPhoneWaterOldTable { + return newNotifyPhoneWaterOldTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NotifyPhoneWaterOldTable with assigned schema name +func (a NotifyPhoneWaterOldTable) FromSchema(schemaName string) *NotifyPhoneWaterOldTable { + return newNotifyPhoneWaterOldTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NotifyPhoneWaterOldTable with assigned table prefix +func (a NotifyPhoneWaterOldTable) WithPrefix(prefix string) *NotifyPhoneWaterOldTable { + return newNotifyPhoneWaterOldTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NotifyPhoneWaterOldTable with assigned table suffix +func (a NotifyPhoneWaterOldTable) WithSuffix(suffix string) *NotifyPhoneWaterOldTable { + return newNotifyPhoneWaterOldTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNotifyPhoneWaterOldTable(schemaName, tableName, alias string) *NotifyPhoneWaterOldTable { + return &NotifyPhoneWaterOldTable{ + notifyPhoneWaterOldTable: newNotifyPhoneWaterOldTableImpl(schemaName, tableName, alias), + EXCLUDED: newNotifyPhoneWaterOldTableImpl("", "excluded", ""), + } +} + +func newNotifyPhoneWaterOldTableImpl(schemaName, tableName, alias string) notifyPhoneWaterOldTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + DeletedColumn = postgres.TimestampColumn("deleted") + PhoneE164Column = postgres.StringColumn("phone_e164") + WaterIDColumn = postgres.IntegerColumn("water_id") + allColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, PhoneE164Column, WaterIDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, DeletedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return notifyPhoneWaterOldTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Deleted: DeletedColumn, + PhoneE164: PhoneE164Column, + WaterID: WaterIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/nuisance.go b/db/gen/nidus-sync/publicreport/table/nuisance.go new file mode 100644 index 00000000..9a5cefbc --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/nuisance.go @@ -0,0 +1,123 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Nuisance = newNuisanceTable("publicreport", "nuisance", "") + +type nuisanceTable struct { + postgres.Table + + // Columns + AdditionalInfo postgres.ColumnString + Duration postgres.ColumnString + IsLocationBackyard postgres.ColumnBool + IsLocationFrontyard postgres.ColumnBool + IsLocationGarden postgres.ColumnBool + IsLocationOther postgres.ColumnBool + IsLocationPool postgres.ColumnBool + ReportID postgres.ColumnInteger + SourceContainer postgres.ColumnBool + SourceDescription postgres.ColumnString + SourceStagnant postgres.ColumnBool + SourceGutter postgres.ColumnBool + TodEarly postgres.ColumnBool + TodDay postgres.ColumnBool + TodEvening postgres.ColumnBool + TodNight postgres.ColumnBool + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NuisanceTable struct { + nuisanceTable + + EXCLUDED nuisanceTable +} + +// AS creates new NuisanceTable with assigned alias +func (a NuisanceTable) AS(alias string) *NuisanceTable { + return newNuisanceTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NuisanceTable with assigned schema name +func (a NuisanceTable) FromSchema(schemaName string) *NuisanceTable { + return newNuisanceTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NuisanceTable with assigned table prefix +func (a NuisanceTable) WithPrefix(prefix string) *NuisanceTable { + return newNuisanceTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NuisanceTable with assigned table suffix +func (a NuisanceTable) WithSuffix(suffix string) *NuisanceTable { + return newNuisanceTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNuisanceTable(schemaName, tableName, alias string) *NuisanceTable { + return &NuisanceTable{ + nuisanceTable: newNuisanceTableImpl(schemaName, tableName, alias), + EXCLUDED: newNuisanceTableImpl("", "excluded", ""), + } +} + +func newNuisanceTableImpl(schemaName, tableName, alias string) nuisanceTable { + var ( + AdditionalInfoColumn = postgres.StringColumn("additional_info") + DurationColumn = postgres.StringColumn("duration") + IsLocationBackyardColumn = postgres.BoolColumn("is_location_backyard") + IsLocationFrontyardColumn = postgres.BoolColumn("is_location_frontyard") + IsLocationGardenColumn = postgres.BoolColumn("is_location_garden") + IsLocationOtherColumn = postgres.BoolColumn("is_location_other") + IsLocationPoolColumn = postgres.BoolColumn("is_location_pool") + ReportIDColumn = postgres.IntegerColumn("report_id") + SourceContainerColumn = postgres.BoolColumn("source_container") + SourceDescriptionColumn = postgres.StringColumn("source_description") + SourceStagnantColumn = postgres.BoolColumn("source_stagnant") + SourceGutterColumn = postgres.BoolColumn("source_gutter") + TodEarlyColumn = postgres.BoolColumn("tod_early") + TodDayColumn = postgres.BoolColumn("tod_day") + TodEveningColumn = postgres.BoolColumn("tod_evening") + TodNightColumn = postgres.BoolColumn("tod_night") + allColumns = postgres.ColumnList{AdditionalInfoColumn, DurationColumn, IsLocationBackyardColumn, IsLocationFrontyardColumn, IsLocationGardenColumn, IsLocationOtherColumn, IsLocationPoolColumn, ReportIDColumn, SourceContainerColumn, SourceDescriptionColumn, SourceStagnantColumn, SourceGutterColumn, TodEarlyColumn, TodDayColumn, TodEveningColumn, TodNightColumn} + mutableColumns = postgres.ColumnList{AdditionalInfoColumn, DurationColumn, IsLocationBackyardColumn, IsLocationFrontyardColumn, IsLocationGardenColumn, IsLocationOtherColumn, IsLocationPoolColumn, SourceContainerColumn, SourceDescriptionColumn, SourceStagnantColumn, SourceGutterColumn, TodEarlyColumn, TodDayColumn, TodEveningColumn, TodNightColumn} + defaultColumns = postgres.ColumnList{} + ) + + return nuisanceTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + AdditionalInfo: AdditionalInfoColumn, + Duration: DurationColumn, + IsLocationBackyard: IsLocationBackyardColumn, + IsLocationFrontyard: IsLocationFrontyardColumn, + IsLocationGarden: IsLocationGardenColumn, + IsLocationOther: IsLocationOtherColumn, + IsLocationPool: IsLocationPoolColumn, + ReportID: ReportIDColumn, + SourceContainer: SourceContainerColumn, + SourceDescription: SourceDescriptionColumn, + SourceStagnant: SourceStagnantColumn, + SourceGutter: SourceGutterColumn, + TodEarly: TodEarlyColumn, + TodDay: TodDayColumn, + TodEvening: TodEveningColumn, + TodNight: TodNightColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/nuisance_image_old.go b/db/gen/nidus-sync/publicreport/table/nuisance_image_old.go new file mode 100644 index 00000000..c002cfe4 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/nuisance_image_old.go @@ -0,0 +1,81 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NuisanceImageOld = newNuisanceImageOldTable("publicreport", "nuisance_image_old", "") + +type nuisanceImageOldTable struct { + postgres.Table + + // Columns + ImageID postgres.ColumnInteger + NuisanceID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NuisanceImageOldTable struct { + nuisanceImageOldTable + + EXCLUDED nuisanceImageOldTable +} + +// AS creates new NuisanceImageOldTable with assigned alias +func (a NuisanceImageOldTable) AS(alias string) *NuisanceImageOldTable { + return newNuisanceImageOldTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NuisanceImageOldTable with assigned schema name +func (a NuisanceImageOldTable) FromSchema(schemaName string) *NuisanceImageOldTable { + return newNuisanceImageOldTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NuisanceImageOldTable with assigned table prefix +func (a NuisanceImageOldTable) WithPrefix(prefix string) *NuisanceImageOldTable { + return newNuisanceImageOldTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NuisanceImageOldTable with assigned table suffix +func (a NuisanceImageOldTable) WithSuffix(suffix string) *NuisanceImageOldTable { + return newNuisanceImageOldTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNuisanceImageOldTable(schemaName, tableName, alias string) *NuisanceImageOldTable { + return &NuisanceImageOldTable{ + nuisanceImageOldTable: newNuisanceImageOldTableImpl(schemaName, tableName, alias), + EXCLUDED: newNuisanceImageOldTableImpl("", "excluded", ""), + } +} + +func newNuisanceImageOldTableImpl(schemaName, tableName, alias string) nuisanceImageOldTable { + var ( + ImageIDColumn = postgres.IntegerColumn("image_id") + NuisanceIDColumn = postgres.IntegerColumn("nuisance_id") + allColumns = postgres.ColumnList{ImageIDColumn, NuisanceIDColumn} + mutableColumns = postgres.ColumnList{} + defaultColumns = postgres.ColumnList{} + ) + + return nuisanceImageOldTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ImageID: ImageIDColumn, + NuisanceID: NuisanceIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/nuisance_old.go b/db/gen/nidus-sync/publicreport/table/nuisance_old.go new file mode 100644 index 00000000..3e9ffb79 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/nuisance_old.go @@ -0,0 +1,192 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var NuisanceOld = newNuisanceOldTable("publicreport", "nuisance_old", "") + +type nuisanceOldTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + AdditionalInfo postgres.ColumnString + Created postgres.ColumnTimestamp + Duration postgres.ColumnString + SourceContainer postgres.ColumnBool + SourceDescription postgres.ColumnString + SourceStagnant postgres.ColumnBool + PublicID postgres.ColumnString + ReporterEmail postgres.ColumnString + ReporterName postgres.ColumnString + ReporterPhone postgres.ColumnString + AddressRaw postgres.ColumnString + Status postgres.ColumnString + OrganizationID postgres.ColumnInteger + SourceGutter postgres.ColumnBool + H3cell postgres.ColumnString + AddressCountry postgres.ColumnString + AddressLocality postgres.ColumnString + AddressPostalCode postgres.ColumnString + AddressRegion postgres.ColumnString + AddressStreet postgres.ColumnString + IsLocationBackyard postgres.ColumnBool + IsLocationFrontyard postgres.ColumnBool + IsLocationGarden postgres.ColumnBool + IsLocationOther postgres.ColumnBool + IsLocationPool postgres.ColumnBool + MapZoom postgres.ColumnFloat + TodEarly postgres.ColumnBool + TodDay postgres.ColumnBool + TodEvening postgres.ColumnBool + TodNight postgres.ColumnBool + LatlngAccuracyType postgres.ColumnString + LatlngAccuracyValue postgres.ColumnFloat + ReporterContactConsent postgres.ColumnBool + Location postgres.ColumnGeometry + AddressNumber postgres.ColumnString + AddressID postgres.ColumnInteger + Reviewed postgres.ColumnTimestamp + ReviewerID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type NuisanceOldTable struct { + nuisanceOldTable + + EXCLUDED nuisanceOldTable +} + +// AS creates new NuisanceOldTable with assigned alias +func (a NuisanceOldTable) AS(alias string) *NuisanceOldTable { + return newNuisanceOldTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new NuisanceOldTable with assigned schema name +func (a NuisanceOldTable) FromSchema(schemaName string) *NuisanceOldTable { + return newNuisanceOldTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new NuisanceOldTable with assigned table prefix +func (a NuisanceOldTable) WithPrefix(prefix string) *NuisanceOldTable { + return newNuisanceOldTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new NuisanceOldTable with assigned table suffix +func (a NuisanceOldTable) WithSuffix(suffix string) *NuisanceOldTable { + return newNuisanceOldTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newNuisanceOldTable(schemaName, tableName, alias string) *NuisanceOldTable { + return &NuisanceOldTable{ + nuisanceOldTable: newNuisanceOldTableImpl(schemaName, tableName, alias), + EXCLUDED: newNuisanceOldTableImpl("", "excluded", ""), + } +} + +func newNuisanceOldTableImpl(schemaName, tableName, alias string) nuisanceOldTable { + var ( + IDColumn = postgres.IntegerColumn("id") + AdditionalInfoColumn = postgres.StringColumn("additional_info") + CreatedColumn = postgres.TimestampColumn("created") + DurationColumn = postgres.StringColumn("duration") + SourceContainerColumn = postgres.BoolColumn("source_container") + SourceDescriptionColumn = postgres.StringColumn("source_description") + SourceStagnantColumn = postgres.BoolColumn("source_stagnant") + PublicIDColumn = postgres.StringColumn("public_id") + ReporterEmailColumn = postgres.StringColumn("reporter_email") + ReporterNameColumn = postgres.StringColumn("reporter_name") + ReporterPhoneColumn = postgres.StringColumn("reporter_phone") + AddressRawColumn = postgres.StringColumn("address_raw") + StatusColumn = postgres.StringColumn("status") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + SourceGutterColumn = postgres.BoolColumn("source_gutter") + H3cellColumn = postgres.StringColumn("h3cell") + AddressCountryColumn = postgres.StringColumn("address_country") + AddressLocalityColumn = postgres.StringColumn("address_locality") + AddressPostalCodeColumn = postgres.StringColumn("address_postal_code") + AddressRegionColumn = postgres.StringColumn("address_region") + AddressStreetColumn = postgres.StringColumn("address_street") + IsLocationBackyardColumn = postgres.BoolColumn("is_location_backyard") + IsLocationFrontyardColumn = postgres.BoolColumn("is_location_frontyard") + IsLocationGardenColumn = postgres.BoolColumn("is_location_garden") + IsLocationOtherColumn = postgres.BoolColumn("is_location_other") + IsLocationPoolColumn = postgres.BoolColumn("is_location_pool") + MapZoomColumn = postgres.FloatColumn("map_zoom") + TodEarlyColumn = postgres.BoolColumn("tod_early") + TodDayColumn = postgres.BoolColumn("tod_day") + TodEveningColumn = postgres.BoolColumn("tod_evening") + TodNightColumn = postgres.BoolColumn("tod_night") + LatlngAccuracyTypeColumn = postgres.StringColumn("latlng_accuracy_type") + LatlngAccuracyValueColumn = postgres.FloatColumn("latlng_accuracy_value") + ReporterContactConsentColumn = postgres.BoolColumn("reporter_contact_consent") + LocationColumn = postgres.GeometryColumn("location") + AddressNumberColumn = postgres.StringColumn("address_number") + AddressIDColumn = postgres.IntegerColumn("address_id") + ReviewedColumn = postgres.TimestampColumn("reviewed") + ReviewerIDColumn = postgres.IntegerColumn("reviewer_id") + allColumns = postgres.ColumnList{IDColumn, AdditionalInfoColumn, CreatedColumn, DurationColumn, SourceContainerColumn, SourceDescriptionColumn, SourceStagnantColumn, PublicIDColumn, ReporterEmailColumn, ReporterNameColumn, ReporterPhoneColumn, AddressRawColumn, StatusColumn, OrganizationIDColumn, SourceGutterColumn, H3cellColumn, AddressCountryColumn, AddressLocalityColumn, AddressPostalCodeColumn, AddressRegionColumn, AddressStreetColumn, IsLocationBackyardColumn, IsLocationFrontyardColumn, IsLocationGardenColumn, IsLocationOtherColumn, IsLocationPoolColumn, MapZoomColumn, TodEarlyColumn, TodDayColumn, TodEveningColumn, TodNightColumn, LatlngAccuracyTypeColumn, LatlngAccuracyValueColumn, ReporterContactConsentColumn, LocationColumn, AddressNumberColumn, AddressIDColumn, ReviewedColumn, ReviewerIDColumn} + mutableColumns = postgres.ColumnList{AdditionalInfoColumn, CreatedColumn, DurationColumn, SourceContainerColumn, SourceDescriptionColumn, SourceStagnantColumn, PublicIDColumn, ReporterEmailColumn, ReporterNameColumn, ReporterPhoneColumn, AddressRawColumn, StatusColumn, OrganizationIDColumn, SourceGutterColumn, H3cellColumn, AddressCountryColumn, AddressLocalityColumn, AddressPostalCodeColumn, AddressRegionColumn, AddressStreetColumn, IsLocationBackyardColumn, IsLocationFrontyardColumn, IsLocationGardenColumn, IsLocationOtherColumn, IsLocationPoolColumn, MapZoomColumn, TodEarlyColumn, TodDayColumn, TodEveningColumn, TodNightColumn, LatlngAccuracyTypeColumn, LatlngAccuracyValueColumn, ReporterContactConsentColumn, LocationColumn, AddressNumberColumn, AddressIDColumn, ReviewedColumn, ReviewerIDColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return nuisanceOldTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + AdditionalInfo: AdditionalInfoColumn, + Created: CreatedColumn, + Duration: DurationColumn, + SourceContainer: SourceContainerColumn, + SourceDescription: SourceDescriptionColumn, + SourceStagnant: SourceStagnantColumn, + PublicID: PublicIDColumn, + ReporterEmail: ReporterEmailColumn, + ReporterName: ReporterNameColumn, + ReporterPhone: ReporterPhoneColumn, + AddressRaw: AddressRawColumn, + Status: StatusColumn, + OrganizationID: OrganizationIDColumn, + SourceGutter: SourceGutterColumn, + H3cell: H3cellColumn, + AddressCountry: AddressCountryColumn, + AddressLocality: AddressLocalityColumn, + AddressPostalCode: AddressPostalCodeColumn, + AddressRegion: AddressRegionColumn, + AddressStreet: AddressStreetColumn, + IsLocationBackyard: IsLocationBackyardColumn, + IsLocationFrontyard: IsLocationFrontyardColumn, + IsLocationGarden: IsLocationGardenColumn, + IsLocationOther: IsLocationOtherColumn, + IsLocationPool: IsLocationPoolColumn, + MapZoom: MapZoomColumn, + TodEarly: TodEarlyColumn, + TodDay: TodDayColumn, + TodEvening: TodEveningColumn, + TodNight: TodNightColumn, + LatlngAccuracyType: LatlngAccuracyTypeColumn, + LatlngAccuracyValue: LatlngAccuracyValueColumn, + ReporterContactConsent: ReporterContactConsentColumn, + Location: LocationColumn, + AddressNumber: AddressNumberColumn, + AddressID: AddressIDColumn, + Reviewed: ReviewedColumn, + ReviewerID: ReviewerIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/report.go b/db/gen/nidus-sync/publicreport/table/report.go new file mode 100644 index 00000000..bd04cf1f --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/report.go @@ -0,0 +1,141 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Report = newReportTable("publicreport", "report", "") + +type reportTable struct { + postgres.Table + + // Columns + AddressRaw postgres.ColumnString + AddressID postgres.ColumnInteger + Created postgres.ColumnTimestamp + Location postgres.ColumnGeometry + H3cell postgres.ColumnString + ID postgres.ColumnInteger + LatlngAccuracyType postgres.ColumnString + LatlngAccuracyValue postgres.ColumnFloat + MapZoom postgres.ColumnFloat + OrganizationID postgres.ColumnInteger + PublicID postgres.ColumnString + ReporterName postgres.ColumnString + ReporterEmail postgres.ColumnString + ReporterPhone postgres.ColumnString + ReporterContactConsent postgres.ColumnBool + ReportType postgres.ColumnString + Reviewed postgres.ColumnTimestamp + ReviewerID postgres.ColumnInteger + Status postgres.ColumnString + AddressGid postgres.ColumnString + ClientUUID postgres.ColumnString + ReporterPhoneCanSms postgres.ColumnBool + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ReportTable struct { + reportTable + + EXCLUDED reportTable +} + +// AS creates new ReportTable with assigned alias +func (a ReportTable) AS(alias string) *ReportTable { + return newReportTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ReportTable with assigned schema name +func (a ReportTable) FromSchema(schemaName string) *ReportTable { + return newReportTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ReportTable with assigned table prefix +func (a ReportTable) WithPrefix(prefix string) *ReportTable { + return newReportTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ReportTable with assigned table suffix +func (a ReportTable) WithSuffix(suffix string) *ReportTable { + return newReportTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newReportTable(schemaName, tableName, alias string) *ReportTable { + return &ReportTable{ + reportTable: newReportTableImpl(schemaName, tableName, alias), + EXCLUDED: newReportTableImpl("", "excluded", ""), + } +} + +func newReportTableImpl(schemaName, tableName, alias string) reportTable { + var ( + AddressRawColumn = postgres.StringColumn("address_raw") + AddressIDColumn = postgres.IntegerColumn("address_id") + CreatedColumn = postgres.TimestampColumn("created") + LocationColumn = postgres.GeometryColumn("location") + H3cellColumn = postgres.StringColumn("h3cell") + IDColumn = postgres.IntegerColumn("id") + LatlngAccuracyTypeColumn = postgres.StringColumn("latlng_accuracy_type") + LatlngAccuracyValueColumn = postgres.FloatColumn("latlng_accuracy_value") + MapZoomColumn = postgres.FloatColumn("map_zoom") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + PublicIDColumn = postgres.StringColumn("public_id") + ReporterNameColumn = postgres.StringColumn("reporter_name") + ReporterEmailColumn = postgres.StringColumn("reporter_email") + ReporterPhoneColumn = postgres.StringColumn("reporter_phone") + ReporterContactConsentColumn = postgres.BoolColumn("reporter_contact_consent") + ReportTypeColumn = postgres.StringColumn("report_type") + ReviewedColumn = postgres.TimestampColumn("reviewed") + ReviewerIDColumn = postgres.IntegerColumn("reviewer_id") + StatusColumn = postgres.StringColumn("status") + AddressGidColumn = postgres.StringColumn("address_gid") + ClientUUIDColumn = postgres.StringColumn("client_uuid") + ReporterPhoneCanSmsColumn = postgres.BoolColumn("reporter_phone_can_sms") + allColumns = postgres.ColumnList{AddressRawColumn, AddressIDColumn, CreatedColumn, LocationColumn, H3cellColumn, IDColumn, LatlngAccuracyTypeColumn, LatlngAccuracyValueColumn, MapZoomColumn, OrganizationIDColumn, PublicIDColumn, ReporterNameColumn, ReporterEmailColumn, ReporterPhoneColumn, ReporterContactConsentColumn, ReportTypeColumn, ReviewedColumn, ReviewerIDColumn, StatusColumn, AddressGidColumn, ClientUUIDColumn, ReporterPhoneCanSmsColumn} + mutableColumns = postgres.ColumnList{AddressRawColumn, AddressIDColumn, CreatedColumn, LocationColumn, H3cellColumn, LatlngAccuracyTypeColumn, LatlngAccuracyValueColumn, MapZoomColumn, OrganizationIDColumn, PublicIDColumn, ReporterNameColumn, ReporterEmailColumn, ReporterPhoneColumn, ReporterContactConsentColumn, ReportTypeColumn, ReviewedColumn, ReviewerIDColumn, StatusColumn, AddressGidColumn, ClientUUIDColumn, ReporterPhoneCanSmsColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return reportTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + AddressRaw: AddressRawColumn, + AddressID: AddressIDColumn, + Created: CreatedColumn, + Location: LocationColumn, + H3cell: H3cellColumn, + ID: IDColumn, + LatlngAccuracyType: LatlngAccuracyTypeColumn, + LatlngAccuracyValue: LatlngAccuracyValueColumn, + MapZoom: MapZoomColumn, + OrganizationID: OrganizationIDColumn, + PublicID: PublicIDColumn, + ReporterName: ReporterNameColumn, + ReporterEmail: ReporterEmailColumn, + ReporterPhone: ReporterPhoneColumn, + ReporterContactConsent: ReporterContactConsentColumn, + ReportType: ReportTypeColumn, + Reviewed: ReviewedColumn, + ReviewerID: ReviewerIDColumn, + Status: StatusColumn, + AddressGid: AddressGidColumn, + ClientUUID: ClientUUIDColumn, + ReporterPhoneCanSms: ReporterPhoneCanSmsColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/report_image.go b/db/gen/nidus-sync/publicreport/table/report_image.go new file mode 100644 index 00000000..4c79174b --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/report_image.go @@ -0,0 +1,81 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ReportImage = newReportImageTable("publicreport", "report_image", "") + +type reportImageTable struct { + postgres.Table + + // Columns + ImageID postgres.ColumnInteger + ReportID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ReportImageTable struct { + reportImageTable + + EXCLUDED reportImageTable +} + +// AS creates new ReportImageTable with assigned alias +func (a ReportImageTable) AS(alias string) *ReportImageTable { + return newReportImageTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ReportImageTable with assigned schema name +func (a ReportImageTable) FromSchema(schemaName string) *ReportImageTable { + return newReportImageTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ReportImageTable with assigned table prefix +func (a ReportImageTable) WithPrefix(prefix string) *ReportImageTable { + return newReportImageTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ReportImageTable with assigned table suffix +func (a ReportImageTable) WithSuffix(suffix string) *ReportImageTable { + return newReportImageTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newReportImageTable(schemaName, tableName, alias string) *ReportImageTable { + return &ReportImageTable{ + reportImageTable: newReportImageTableImpl(schemaName, tableName, alias), + EXCLUDED: newReportImageTableImpl("", "excluded", ""), + } +} + +func newReportImageTableImpl(schemaName, tableName, alias string) reportImageTable { + var ( + ImageIDColumn = postgres.IntegerColumn("image_id") + ReportIDColumn = postgres.IntegerColumn("report_id") + allColumns = postgres.ColumnList{ImageIDColumn, ReportIDColumn} + mutableColumns = postgres.ColumnList{} + defaultColumns = postgres.ColumnList{} + ) + + return reportImageTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ImageID: ImageIDColumn, + ReportID: ReportIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/report_log.go b/db/gen/nidus-sync/publicreport/table/report_log.go new file mode 100644 index 00000000..c638e9f8 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/report_log.go @@ -0,0 +1,96 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var ReportLog = newReportLogTable("publicreport", "report_log", "") + +type reportLogTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + EmailLogID postgres.ColumnInteger + ID postgres.ColumnInteger + ReportID postgres.ColumnInteger + TextLogID postgres.ColumnInteger + Type postgres.ColumnString + UserID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type ReportLogTable struct { + reportLogTable + + EXCLUDED reportLogTable +} + +// AS creates new ReportLogTable with assigned alias +func (a ReportLogTable) AS(alias string) *ReportLogTable { + return newReportLogTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new ReportLogTable with assigned schema name +func (a ReportLogTable) FromSchema(schemaName string) *ReportLogTable { + return newReportLogTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new ReportLogTable with assigned table prefix +func (a ReportLogTable) WithPrefix(prefix string) *ReportLogTable { + return newReportLogTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new ReportLogTable with assigned table suffix +func (a ReportLogTable) WithSuffix(suffix string) *ReportLogTable { + return newReportLogTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newReportLogTable(schemaName, tableName, alias string) *ReportLogTable { + return &ReportLogTable{ + reportLogTable: newReportLogTableImpl(schemaName, tableName, alias), + EXCLUDED: newReportLogTableImpl("", "excluded", ""), + } +} + +func newReportLogTableImpl(schemaName, tableName, alias string) reportLogTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + EmailLogIDColumn = postgres.IntegerColumn("email_log_id") + IDColumn = postgres.IntegerColumn("id") + ReportIDColumn = postgres.IntegerColumn("report_id") + TextLogIDColumn = postgres.IntegerColumn("text_log_id") + TypeColumn = postgres.StringColumn("type_") + UserIDColumn = postgres.IntegerColumn("user_id") + allColumns = postgres.ColumnList{CreatedColumn, EmailLogIDColumn, IDColumn, ReportIDColumn, TextLogIDColumn, TypeColumn, UserIDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, EmailLogIDColumn, ReportIDColumn, TextLogIDColumn, TypeColumn, UserIDColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return reportLogTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + EmailLogID: EmailLogIDColumn, + ID: IDColumn, + ReportID: ReportIDColumn, + TextLogID: TextLogIDColumn, + Type: TypeColumn, + UserID: UserIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/subscribe_email.go b/db/gen/nidus-sync/publicreport/table/subscribe_email.go new file mode 100644 index 00000000..cb964a15 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/subscribe_email.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var SubscribeEmail = newSubscribeEmailTable("publicreport", "subscribe_email", "") + +type subscribeEmailTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Deleted postgres.ColumnTimestamp + EmailAddress postgres.ColumnString + ID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type SubscribeEmailTable struct { + subscribeEmailTable + + EXCLUDED subscribeEmailTable +} + +// AS creates new SubscribeEmailTable with assigned alias +func (a SubscribeEmailTable) AS(alias string) *SubscribeEmailTable { + return newSubscribeEmailTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new SubscribeEmailTable with assigned schema name +func (a SubscribeEmailTable) FromSchema(schemaName string) *SubscribeEmailTable { + return newSubscribeEmailTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new SubscribeEmailTable with assigned table prefix +func (a SubscribeEmailTable) WithPrefix(prefix string) *SubscribeEmailTable { + return newSubscribeEmailTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new SubscribeEmailTable with assigned table suffix +func (a SubscribeEmailTable) WithSuffix(suffix string) *SubscribeEmailTable { + return newSubscribeEmailTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newSubscribeEmailTable(schemaName, tableName, alias string) *SubscribeEmailTable { + return &SubscribeEmailTable{ + subscribeEmailTable: newSubscribeEmailTableImpl(schemaName, tableName, alias), + EXCLUDED: newSubscribeEmailTableImpl("", "excluded", ""), + } +} + +func newSubscribeEmailTableImpl(schemaName, tableName, alias string) subscribeEmailTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + DeletedColumn = postgres.TimestampColumn("deleted") + EmailAddressColumn = postgres.StringColumn("email_address") + IDColumn = postgres.IntegerColumn("id") + allColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, EmailAddressColumn, IDColumn} + mutableColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, EmailAddressColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return subscribeEmailTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Deleted: DeletedColumn, + EmailAddress: EmailAddressColumn, + ID: IDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/subscribe_phone.go b/db/gen/nidus-sync/publicreport/table/subscribe_phone.go new file mode 100644 index 00000000..8233640a --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/subscribe_phone.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var SubscribePhone = newSubscribePhoneTable("publicreport", "subscribe_phone", "") + +type subscribePhoneTable struct { + postgres.Table + + // Columns + Created postgres.ColumnTimestamp + Deleted postgres.ColumnTimestamp + ID postgres.ColumnInteger + PhoneE164 postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type SubscribePhoneTable struct { + subscribePhoneTable + + EXCLUDED subscribePhoneTable +} + +// AS creates new SubscribePhoneTable with assigned alias +func (a SubscribePhoneTable) AS(alias string) *SubscribePhoneTable { + return newSubscribePhoneTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new SubscribePhoneTable with assigned schema name +func (a SubscribePhoneTable) FromSchema(schemaName string) *SubscribePhoneTable { + return newSubscribePhoneTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new SubscribePhoneTable with assigned table prefix +func (a SubscribePhoneTable) WithPrefix(prefix string) *SubscribePhoneTable { + return newSubscribePhoneTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new SubscribePhoneTable with assigned table suffix +func (a SubscribePhoneTable) WithSuffix(suffix string) *SubscribePhoneTable { + return newSubscribePhoneTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newSubscribePhoneTable(schemaName, tableName, alias string) *SubscribePhoneTable { + return &SubscribePhoneTable{ + subscribePhoneTable: newSubscribePhoneTableImpl(schemaName, tableName, alias), + EXCLUDED: newSubscribePhoneTableImpl("", "excluded", ""), + } +} + +func newSubscribePhoneTableImpl(schemaName, tableName, alias string) subscribePhoneTable { + var ( + CreatedColumn = postgres.TimestampColumn("created") + DeletedColumn = postgres.TimestampColumn("deleted") + IDColumn = postgres.IntegerColumn("id") + PhoneE164Column = postgres.StringColumn("phone_e164") + allColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, IDColumn, PhoneE164Column} + mutableColumns = postgres.ColumnList{CreatedColumn, DeletedColumn, PhoneE164Column} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return subscribePhoneTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + Created: CreatedColumn, + Deleted: DeletedColumn, + ID: IDColumn, + PhoneE164: PhoneE164Column, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/table_use_schema.go b/db/gen/nidus-sync/publicreport/table/table_use_schema.go new file mode 100644 index 00000000..32016f05 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/table_use_schema.go @@ -0,0 +1,34 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +// UseSchema sets a new schema name for all generated table SQL builder types. It is recommended to invoke +// this method only once at the beginning of the program. +func UseSchema(schema string) { + Client = Client.FromSchema(schema) + Compliance = Compliance.FromSchema(schema) + Image = Image.FromSchema(schema) + ImageExif = ImageExif.FromSchema(schema) + NotifyEmail = NotifyEmail.FromSchema(schema) + NotifyEmailNuisanceOld = NotifyEmailNuisanceOld.FromSchema(schema) + NotifyEmailWaterOld = NotifyEmailWaterOld.FromSchema(schema) + NotifyPhone = NotifyPhone.FromSchema(schema) + NotifyPhoneNuisanceOld = NotifyPhoneNuisanceOld.FromSchema(schema) + NotifyPhoneWaterOld = NotifyPhoneWaterOld.FromSchema(schema) + Nuisance = Nuisance.FromSchema(schema) + NuisanceImageOld = NuisanceImageOld.FromSchema(schema) + NuisanceOld = NuisanceOld.FromSchema(schema) + Report = Report.FromSchema(schema) + ReportImage = ReportImage.FromSchema(schema) + ReportLog = ReportLog.FromSchema(schema) + SubscribeEmail = SubscribeEmail.FromSchema(schema) + SubscribePhone = SubscribePhone.FromSchema(schema) + Water = Water.FromSchema(schema) + WaterImageOld = WaterImageOld.FromSchema(schema) + WaterOld = WaterOld.FromSchema(schema) +} diff --git a/db/gen/nidus-sync/publicreport/table/water.go b/db/gen/nidus-sync/publicreport/table/water.go new file mode 100644 index 00000000..acb89a03 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/water.go @@ -0,0 +1,129 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var Water = newWaterTable("publicreport", "water", "") + +type waterTable struct { + postgres.Table + + // Columns + AccessComments postgres.ColumnString + AccessGate postgres.ColumnBool + AccessFence postgres.ColumnBool + AccessLocked postgres.ColumnBool + AccessDog postgres.ColumnBool + AccessOther postgres.ColumnBool + Comments postgres.ColumnString + IsReporterConfidential postgres.ColumnBool + IsReporterOwner postgres.ColumnBool + HasAdult postgres.ColumnBool + HasBackyardPermission postgres.ColumnBool + HasLarvae postgres.ColumnBool + HasPupae postgres.ColumnBool + OwnerEmail postgres.ColumnString + OwnerName postgres.ColumnString + OwnerPhone postgres.ColumnString + ReportID postgres.ColumnInteger + Duration postgres.ColumnString + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type WaterTable struct { + waterTable + + EXCLUDED waterTable +} + +// AS creates new WaterTable with assigned alias +func (a WaterTable) AS(alias string) *WaterTable { + return newWaterTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new WaterTable with assigned schema name +func (a WaterTable) FromSchema(schemaName string) *WaterTable { + return newWaterTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new WaterTable with assigned table prefix +func (a WaterTable) WithPrefix(prefix string) *WaterTable { + return newWaterTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new WaterTable with assigned table suffix +func (a WaterTable) WithSuffix(suffix string) *WaterTable { + return newWaterTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newWaterTable(schemaName, tableName, alias string) *WaterTable { + return &WaterTable{ + waterTable: newWaterTableImpl(schemaName, tableName, alias), + EXCLUDED: newWaterTableImpl("", "excluded", ""), + } +} + +func newWaterTableImpl(schemaName, tableName, alias string) waterTable { + var ( + AccessCommentsColumn = postgres.StringColumn("access_comments") + AccessGateColumn = postgres.BoolColumn("access_gate") + AccessFenceColumn = postgres.BoolColumn("access_fence") + AccessLockedColumn = postgres.BoolColumn("access_locked") + AccessDogColumn = postgres.BoolColumn("access_dog") + AccessOtherColumn = postgres.BoolColumn("access_other") + CommentsColumn = postgres.StringColumn("comments") + IsReporterConfidentialColumn = postgres.BoolColumn("is_reporter_confidential") + IsReporterOwnerColumn = postgres.BoolColumn("is_reporter_owner") + HasAdultColumn = postgres.BoolColumn("has_adult") + HasBackyardPermissionColumn = postgres.BoolColumn("has_backyard_permission") + HasLarvaeColumn = postgres.BoolColumn("has_larvae") + HasPupaeColumn = postgres.BoolColumn("has_pupae") + OwnerEmailColumn = postgres.StringColumn("owner_email") + OwnerNameColumn = postgres.StringColumn("owner_name") + OwnerPhoneColumn = postgres.StringColumn("owner_phone") + ReportIDColumn = postgres.IntegerColumn("report_id") + DurationColumn = postgres.StringColumn("duration") + allColumns = postgres.ColumnList{AccessCommentsColumn, AccessGateColumn, AccessFenceColumn, AccessLockedColumn, AccessDogColumn, AccessOtherColumn, CommentsColumn, IsReporterConfidentialColumn, IsReporterOwnerColumn, HasAdultColumn, HasBackyardPermissionColumn, HasLarvaeColumn, HasPupaeColumn, OwnerEmailColumn, OwnerNameColumn, OwnerPhoneColumn, ReportIDColumn, DurationColumn} + mutableColumns = postgres.ColumnList{AccessCommentsColumn, AccessGateColumn, AccessFenceColumn, AccessLockedColumn, AccessDogColumn, AccessOtherColumn, CommentsColumn, IsReporterConfidentialColumn, IsReporterOwnerColumn, HasAdultColumn, HasBackyardPermissionColumn, HasLarvaeColumn, HasPupaeColumn, OwnerEmailColumn, OwnerNameColumn, OwnerPhoneColumn, DurationColumn} + defaultColumns = postgres.ColumnList{} + ) + + return waterTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + AccessComments: AccessCommentsColumn, + AccessGate: AccessGateColumn, + AccessFence: AccessFenceColumn, + AccessLocked: AccessLockedColumn, + AccessDog: AccessDogColumn, + AccessOther: AccessOtherColumn, + Comments: CommentsColumn, + IsReporterConfidential: IsReporterConfidentialColumn, + IsReporterOwner: IsReporterOwnerColumn, + HasAdult: HasAdultColumn, + HasBackyardPermission: HasBackyardPermissionColumn, + HasLarvae: HasLarvaeColumn, + HasPupae: HasPupaeColumn, + OwnerEmail: OwnerEmailColumn, + OwnerName: OwnerNameColumn, + OwnerPhone: OwnerPhoneColumn, + ReportID: ReportIDColumn, + Duration: DurationColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/water_image_old.go b/db/gen/nidus-sync/publicreport/table/water_image_old.go new file mode 100644 index 00000000..d8a1cf76 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/water_image_old.go @@ -0,0 +1,81 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var WaterImageOld = newWaterImageOldTable("publicreport", "water_image_old", "") + +type waterImageOldTable struct { + postgres.Table + + // Columns + ImageID postgres.ColumnInteger + WaterID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type WaterImageOldTable struct { + waterImageOldTable + + EXCLUDED waterImageOldTable +} + +// AS creates new WaterImageOldTable with assigned alias +func (a WaterImageOldTable) AS(alias string) *WaterImageOldTable { + return newWaterImageOldTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new WaterImageOldTable with assigned schema name +func (a WaterImageOldTable) FromSchema(schemaName string) *WaterImageOldTable { + return newWaterImageOldTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new WaterImageOldTable with assigned table prefix +func (a WaterImageOldTable) WithPrefix(prefix string) *WaterImageOldTable { + return newWaterImageOldTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new WaterImageOldTable with assigned table suffix +func (a WaterImageOldTable) WithSuffix(suffix string) *WaterImageOldTable { + return newWaterImageOldTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newWaterImageOldTable(schemaName, tableName, alias string) *WaterImageOldTable { + return &WaterImageOldTable{ + waterImageOldTable: newWaterImageOldTableImpl(schemaName, tableName, alias), + EXCLUDED: newWaterImageOldTableImpl("", "excluded", ""), + } +} + +func newWaterImageOldTableImpl(schemaName, tableName, alias string) waterImageOldTable { + var ( + ImageIDColumn = postgres.IntegerColumn("image_id") + WaterIDColumn = postgres.IntegerColumn("water_id") + allColumns = postgres.ColumnList{ImageIDColumn, WaterIDColumn} + mutableColumns = postgres.ColumnList{} + defaultColumns = postgres.ColumnList{} + ) + + return waterImageOldTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ImageID: ImageIDColumn, + WaterID: WaterIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/table/water_old.go b/db/gen/nidus-sync/publicreport/table/water_old.go new file mode 100644 index 00000000..312842f1 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/table/water_old.go @@ -0,0 +1,189 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var WaterOld = newWaterOldTable("publicreport", "water_old", "") + +type waterOldTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + AccessComments postgres.ColumnString + AccessGate postgres.ColumnBool + AccessFence postgres.ColumnBool + AccessLocked postgres.ColumnBool + AccessDog postgres.ColumnBool + AccessOther postgres.ColumnBool + AddressRaw postgres.ColumnString + AddressCountry postgres.ColumnString + AddressPostalCode postgres.ColumnString + AddressLocality postgres.ColumnString + AddressStreet postgres.ColumnString + AddressRegion postgres.ColumnString + Comments postgres.ColumnString + Created postgres.ColumnTimestamp + H3cell postgres.ColumnString + HasAdult postgres.ColumnBool + HasLarvae postgres.ColumnBool + HasPupae postgres.ColumnBool + MapZoom postgres.ColumnFloat + OwnerEmail postgres.ColumnString + OwnerName postgres.ColumnString + OwnerPhone postgres.ColumnString + PublicID postgres.ColumnString + ReporterEmail postgres.ColumnString + ReporterName postgres.ColumnString + ReporterPhone postgres.ColumnString + Status postgres.ColumnString + OrganizationID postgres.ColumnInteger + HasBackyardPermission postgres.ColumnBool + IsReporterConfidential postgres.ColumnBool + IsReporterOwner postgres.ColumnBool + ReporterContactConsent postgres.ColumnBool + Location postgres.ColumnGeometry + AddressNumber postgres.ColumnString + AddressID postgres.ColumnInteger + Reviewed postgres.ColumnTimestamp + ReviewerID postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type WaterOldTable struct { + waterOldTable + + EXCLUDED waterOldTable +} + +// AS creates new WaterOldTable with assigned alias +func (a WaterOldTable) AS(alias string) *WaterOldTable { + return newWaterOldTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new WaterOldTable with assigned schema name +func (a WaterOldTable) FromSchema(schemaName string) *WaterOldTable { + return newWaterOldTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new WaterOldTable with assigned table prefix +func (a WaterOldTable) WithPrefix(prefix string) *WaterOldTable { + return newWaterOldTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new WaterOldTable with assigned table suffix +func (a WaterOldTable) WithSuffix(suffix string) *WaterOldTable { + return newWaterOldTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newWaterOldTable(schemaName, tableName, alias string) *WaterOldTable { + return &WaterOldTable{ + waterOldTable: newWaterOldTableImpl(schemaName, tableName, alias), + EXCLUDED: newWaterOldTableImpl("", "excluded", ""), + } +} + +func newWaterOldTableImpl(schemaName, tableName, alias string) waterOldTable { + var ( + IDColumn = postgres.IntegerColumn("id") + AccessCommentsColumn = postgres.StringColumn("access_comments") + AccessGateColumn = postgres.BoolColumn("access_gate") + AccessFenceColumn = postgres.BoolColumn("access_fence") + AccessLockedColumn = postgres.BoolColumn("access_locked") + AccessDogColumn = postgres.BoolColumn("access_dog") + AccessOtherColumn = postgres.BoolColumn("access_other") + AddressRawColumn = postgres.StringColumn("address_raw") + AddressCountryColumn = postgres.StringColumn("address_country") + AddressPostalCodeColumn = postgres.StringColumn("address_postal_code") + AddressLocalityColumn = postgres.StringColumn("address_locality") + AddressStreetColumn = postgres.StringColumn("address_street") + AddressRegionColumn = postgres.StringColumn("address_region") + CommentsColumn = postgres.StringColumn("comments") + CreatedColumn = postgres.TimestampColumn("created") + H3cellColumn = postgres.StringColumn("h3cell") + HasAdultColumn = postgres.BoolColumn("has_adult") + HasLarvaeColumn = postgres.BoolColumn("has_larvae") + HasPupaeColumn = postgres.BoolColumn("has_pupae") + MapZoomColumn = postgres.FloatColumn("map_zoom") + OwnerEmailColumn = postgres.StringColumn("owner_email") + OwnerNameColumn = postgres.StringColumn("owner_name") + OwnerPhoneColumn = postgres.StringColumn("owner_phone") + PublicIDColumn = postgres.StringColumn("public_id") + ReporterEmailColumn = postgres.StringColumn("reporter_email") + ReporterNameColumn = postgres.StringColumn("reporter_name") + ReporterPhoneColumn = postgres.StringColumn("reporter_phone") + StatusColumn = postgres.StringColumn("status") + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + HasBackyardPermissionColumn = postgres.BoolColumn("has_backyard_permission") + IsReporterConfidentialColumn = postgres.BoolColumn("is_reporter_confidential") + IsReporterOwnerColumn = postgres.BoolColumn("is_reporter_owner") + ReporterContactConsentColumn = postgres.BoolColumn("reporter_contact_consent") + LocationColumn = postgres.GeometryColumn("location") + AddressNumberColumn = postgres.StringColumn("address_number") + AddressIDColumn = postgres.IntegerColumn("address_id") + ReviewedColumn = postgres.TimestampColumn("reviewed") + ReviewerIDColumn = postgres.IntegerColumn("reviewer_id") + allColumns = postgres.ColumnList{IDColumn, AccessCommentsColumn, AccessGateColumn, AccessFenceColumn, AccessLockedColumn, AccessDogColumn, AccessOtherColumn, AddressRawColumn, AddressCountryColumn, AddressPostalCodeColumn, AddressLocalityColumn, AddressStreetColumn, AddressRegionColumn, CommentsColumn, CreatedColumn, H3cellColumn, HasAdultColumn, HasLarvaeColumn, HasPupaeColumn, MapZoomColumn, OwnerEmailColumn, OwnerNameColumn, OwnerPhoneColumn, PublicIDColumn, ReporterEmailColumn, ReporterNameColumn, ReporterPhoneColumn, StatusColumn, OrganizationIDColumn, HasBackyardPermissionColumn, IsReporterConfidentialColumn, IsReporterOwnerColumn, ReporterContactConsentColumn, LocationColumn, AddressNumberColumn, AddressIDColumn, ReviewedColumn, ReviewerIDColumn} + mutableColumns = postgres.ColumnList{AccessCommentsColumn, AccessGateColumn, AccessFenceColumn, AccessLockedColumn, AccessDogColumn, AccessOtherColumn, AddressRawColumn, AddressCountryColumn, AddressPostalCodeColumn, AddressLocalityColumn, AddressStreetColumn, AddressRegionColumn, CommentsColumn, CreatedColumn, H3cellColumn, HasAdultColumn, HasLarvaeColumn, HasPupaeColumn, MapZoomColumn, OwnerEmailColumn, OwnerNameColumn, OwnerPhoneColumn, PublicIDColumn, ReporterEmailColumn, ReporterNameColumn, ReporterPhoneColumn, StatusColumn, OrganizationIDColumn, HasBackyardPermissionColumn, IsReporterConfidentialColumn, IsReporterOwnerColumn, ReporterContactConsentColumn, LocationColumn, AddressNumberColumn, AddressIDColumn, ReviewedColumn, ReviewerIDColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return waterOldTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + AccessComments: AccessCommentsColumn, + AccessGate: AccessGateColumn, + AccessFence: AccessFenceColumn, + AccessLocked: AccessLockedColumn, + AccessDog: AccessDogColumn, + AccessOther: AccessOtherColumn, + AddressRaw: AddressRawColumn, + AddressCountry: AddressCountryColumn, + AddressPostalCode: AddressPostalCodeColumn, + AddressLocality: AddressLocalityColumn, + AddressStreet: AddressStreetColumn, + AddressRegion: AddressRegionColumn, + Comments: CommentsColumn, + Created: CreatedColumn, + H3cell: H3cellColumn, + HasAdult: HasAdultColumn, + HasLarvae: HasLarvaeColumn, + HasPupae: HasPupaeColumn, + MapZoom: MapZoomColumn, + OwnerEmail: OwnerEmailColumn, + OwnerName: OwnerNameColumn, + OwnerPhone: OwnerPhoneColumn, + PublicID: PublicIDColumn, + ReporterEmail: ReporterEmailColumn, + ReporterName: ReporterNameColumn, + ReporterPhone: ReporterPhoneColumn, + Status: StatusColumn, + OrganizationID: OrganizationIDColumn, + HasBackyardPermission: HasBackyardPermissionColumn, + IsReporterConfidential: IsReporterConfidentialColumn, + IsReporterOwner: IsReporterOwnerColumn, + ReporterContactConsent: ReporterContactConsentColumn, + Location: LocationColumn, + AddressNumber: AddressNumberColumn, + AddressID: AddressIDColumn, + Reviewed: ReviewedColumn, + ReviewerID: ReviewerIDColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/view/organization_report_count.go b/db/gen/nidus-sync/publicreport/view/organization_report_count.go new file mode 100644 index 00000000..86a34876 --- /dev/null +++ b/db/gen/nidus-sync/publicreport/view/organization_report_count.go @@ -0,0 +1,108 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package view + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var OrganizationReportCount = newOrganizationReportCountTable("publicreport", "organization_report_count", "") + +type organizationReportCountTable struct { + postgres.Table + + // Columns + OrganizationID postgres.ColumnInteger + NuisanceReported postgres.ColumnInteger + NuisanceReviewed postgres.ColumnInteger + NuisanceScheduled postgres.ColumnInteger + NuisanceTreated postgres.ColumnInteger + NuisanceInvalidated postgres.ColumnInteger + WaterReported postgres.ColumnInteger + WaterReviewed postgres.ColumnInteger + WaterScheduled postgres.ColumnInteger + WaterTreated postgres.ColumnInteger + WaterInvalidated postgres.ColumnInteger + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type OrganizationReportCountTable struct { + organizationReportCountTable + + EXCLUDED organizationReportCountTable +} + +// AS creates new OrganizationReportCountTable with assigned alias +func (a OrganizationReportCountTable) AS(alias string) *OrganizationReportCountTable { + return newOrganizationReportCountTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new OrganizationReportCountTable with assigned schema name +func (a OrganizationReportCountTable) FromSchema(schemaName string) *OrganizationReportCountTable { + return newOrganizationReportCountTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new OrganizationReportCountTable with assigned table prefix +func (a OrganizationReportCountTable) WithPrefix(prefix string) *OrganizationReportCountTable { + return newOrganizationReportCountTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new OrganizationReportCountTable with assigned table suffix +func (a OrganizationReportCountTable) WithSuffix(suffix string) *OrganizationReportCountTable { + return newOrganizationReportCountTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newOrganizationReportCountTable(schemaName, tableName, alias string) *OrganizationReportCountTable { + return &OrganizationReportCountTable{ + organizationReportCountTable: newOrganizationReportCountTableImpl(schemaName, tableName, alias), + EXCLUDED: newOrganizationReportCountTableImpl("", "excluded", ""), + } +} + +func newOrganizationReportCountTableImpl(schemaName, tableName, alias string) organizationReportCountTable { + var ( + OrganizationIDColumn = postgres.IntegerColumn("organization_id") + NuisanceReportedColumn = postgres.IntegerColumn("nuisance_reported") + NuisanceReviewedColumn = postgres.IntegerColumn("nuisance_reviewed") + NuisanceScheduledColumn = postgres.IntegerColumn("nuisance_scheduled") + NuisanceTreatedColumn = postgres.IntegerColumn("nuisance_treated") + NuisanceInvalidatedColumn = postgres.IntegerColumn("nuisance_invalidated") + WaterReportedColumn = postgres.IntegerColumn("water_reported") + WaterReviewedColumn = postgres.IntegerColumn("water_reviewed") + WaterScheduledColumn = postgres.IntegerColumn("water_scheduled") + WaterTreatedColumn = postgres.IntegerColumn("water_treated") + WaterInvalidatedColumn = postgres.IntegerColumn("water_invalidated") + allColumns = postgres.ColumnList{OrganizationIDColumn, NuisanceReportedColumn, NuisanceReviewedColumn, NuisanceScheduledColumn, NuisanceTreatedColumn, NuisanceInvalidatedColumn, WaterReportedColumn, WaterReviewedColumn, WaterScheduledColumn, WaterTreatedColumn, WaterInvalidatedColumn} + mutableColumns = postgres.ColumnList{OrganizationIDColumn, NuisanceReportedColumn, NuisanceReviewedColumn, NuisanceScheduledColumn, NuisanceTreatedColumn, NuisanceInvalidatedColumn, WaterReportedColumn, WaterReviewedColumn, WaterScheduledColumn, WaterTreatedColumn, WaterInvalidatedColumn} + defaultColumns = postgres.ColumnList{} + ) + + return organizationReportCountTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + OrganizationID: OrganizationIDColumn, + NuisanceReported: NuisanceReportedColumn, + NuisanceReviewed: NuisanceReviewedColumn, + NuisanceScheduled: NuisanceScheduledColumn, + NuisanceTreated: NuisanceTreatedColumn, + NuisanceInvalidated: NuisanceInvalidatedColumn, + WaterReported: WaterReportedColumn, + WaterReviewed: WaterReviewedColumn, + WaterScheduled: WaterScheduledColumn, + WaterTreated: WaterTreatedColumn, + WaterInvalidated: WaterInvalidatedColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/publicreport/view/view_use_schema.go b/db/gen/nidus-sync/publicreport/view/view_use_schema.go new file mode 100644 index 00000000..11f0e07e --- /dev/null +++ b/db/gen/nidus-sync/publicreport/view/view_use_schema.go @@ -0,0 +1,14 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package view + +// UseSchema sets a new schema name for all generated view SQL builder types. It is recommended to invoke +// this method only once at the beginning of the program. +func UseSchema(schema string) { + OrganizationReportCount = OrganizationReportCount.FromSchema(schema) +} diff --git a/db/gen/nidus-sync/stadia/model/api_request.go b/db/gen/nidus-sync/stadia/model/api_request.go new file mode 100644 index 00000000..90fbdf4b --- /dev/null +++ b/db/gen/nidus-sync/stadia/model/api_request.go @@ -0,0 +1,19 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package model + +import ( + "time" +) + +type APIRequest struct { + ID int64 `sql:"primary_key"` + Request string + Response string + CreatedAt time.Time +} diff --git a/db/gen/nidus-sync/stadia/table/api_request.go b/db/gen/nidus-sync/stadia/table/api_request.go new file mode 100644 index 00000000..f77ecc58 --- /dev/null +++ b/db/gen/nidus-sync/stadia/table/api_request.go @@ -0,0 +1,87 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +import ( + "github.com/Gleipnir-Technology/jet/postgres" +) + +var APIRequest = newAPIRequestTable("stadia", "api_request", "") + +type aPIRequestTable struct { + postgres.Table + + // Columns + ID postgres.ColumnInteger + Request postgres.ColumnString + Response postgres.ColumnString + CreatedAt postgres.ColumnTimestamp + + AllColumns postgres.ColumnList + MutableColumns postgres.ColumnList + DefaultColumns postgres.ColumnList +} + +type APIRequestTable struct { + aPIRequestTable + + EXCLUDED aPIRequestTable +} + +// AS creates new APIRequestTable with assigned alias +func (a APIRequestTable) AS(alias string) *APIRequestTable { + return newAPIRequestTable(a.SchemaName(), a.TableName(), alias) +} + +// Schema creates new APIRequestTable with assigned schema name +func (a APIRequestTable) FromSchema(schemaName string) *APIRequestTable { + return newAPIRequestTable(schemaName, a.TableName(), a.Alias()) +} + +// WithPrefix creates new APIRequestTable with assigned table prefix +func (a APIRequestTable) WithPrefix(prefix string) *APIRequestTable { + return newAPIRequestTable(a.SchemaName(), prefix+a.TableName(), a.TableName()) +} + +// WithSuffix creates new APIRequestTable with assigned table suffix +func (a APIRequestTable) WithSuffix(suffix string) *APIRequestTable { + return newAPIRequestTable(a.SchemaName(), a.TableName()+suffix, a.TableName()) +} + +func newAPIRequestTable(schemaName, tableName, alias string) *APIRequestTable { + return &APIRequestTable{ + aPIRequestTable: newAPIRequestTableImpl(schemaName, tableName, alias), + EXCLUDED: newAPIRequestTableImpl("", "excluded", ""), + } +} + +func newAPIRequestTableImpl(schemaName, tableName, alias string) aPIRequestTable { + var ( + IDColumn = postgres.IntegerColumn("id") + RequestColumn = postgres.StringColumn("request") + ResponseColumn = postgres.StringColumn("response") + CreatedAtColumn = postgres.TimestampColumn("created_at") + allColumns = postgres.ColumnList{IDColumn, RequestColumn, ResponseColumn, CreatedAtColumn} + mutableColumns = postgres.ColumnList{RequestColumn, ResponseColumn, CreatedAtColumn} + defaultColumns = postgres.ColumnList{IDColumn} + ) + + return aPIRequestTable{ + Table: postgres.NewTable(schemaName, tableName, alias, allColumns...), + + //Columns + ID: IDColumn, + Request: RequestColumn, + Response: ResponseColumn, + CreatedAt: CreatedAtColumn, + + AllColumns: allColumns, + MutableColumns: mutableColumns, + DefaultColumns: defaultColumns, + } +} diff --git a/db/gen/nidus-sync/stadia/table/table_use_schema.go b/db/gen/nidus-sync/stadia/table/table_use_schema.go new file mode 100644 index 00000000..1aeaa596 --- /dev/null +++ b/db/gen/nidus-sync/stadia/table/table_use_schema.go @@ -0,0 +1,14 @@ +// +// Code generated by go-jet DO NOT EDIT. +// +// WARNING: Changes to this file may cause incorrect behavior +// and will be lost if the code is regenerated +// + +package table + +// UseSchema sets a new schema name for all generated table SQL builder types. It is recommended to invoke +// this method only once at the beginning of the program. +func UseSchema(schema string) { + APIRequest = APIRequest.FromSchema(schema) +}