Mercurial > gemma

comparison pkg/controllers/manualimports.go @ 2025:070ac9dd61a1 unify_imports

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Bring manual imports to new import modeling.
author Sascha L. Teichmann <sascha.teichmann@intevation.de>
date Thu, 24 Jan 2019 18:19:43 +0100
parents 9c65153bb56e
children 6b9f0fe741dc
comparison
equal deleted inserted replaced
2024:6d9fbc62c5a6 2025:070ac9dd61a1
24 "gemma.intevation.de/gemma/pkg/common" 24 "gemma.intevation.de/gemma/pkg/common"
25 "gemma.intevation.de/gemma/pkg/imports" 25 "gemma.intevation.de/gemma/pkg/imports"
26 "gemma.intevation.de/gemma/pkg/models" 26 "gemma.intevation.de/gemma/pkg/models"
27 ) 27 )
28 28
29 func importBottleneck(input interface{}) (interface{}, common.Attributes, bool) { 29 func importBottleneck(input interface{}) interface{} {
30 bi := input.(*models.BottleneckImport) 30 bi := input.(*models.BottleneckImport)
31 bn := &imports.Bottleneck{ 31 return &imports.Bottleneck{
32 URL: bi.URL, 32 URL: bi.URL,
33 Insecure: bi.Insecure, 33 Insecure: bi.Insecure,
34 } 34 }
35 return bn, bi.Attributes, bi.SendEmail 35 }
36 } 36
37 37 func importGaugeMeasurement(input interface{}) interface{} {
38 func importGaugeMeasurement(input interface{}) (interface{}, common.Attributes, bool) {
39 gi := input.(*models.GaugeMeasurementImport) 38 gi := input.(*models.GaugeMeasurementImport)
40 gm := &imports.GaugeMeasurement{ 39 return &imports.GaugeMeasurement{
41 URL: gi.URL, 40 URL: gi.URL,
42 Insecure: gi.Insecure, 41 Insecure: gi.Insecure,
43 } 42 }
44 return gm, gi.Attributes, gi.SendEmail 43 }
45 } 44
46 45 func importFairwayAvailability(input interface{}) interface{} {
47 func importFairwayAvailability(input interface{}) (interface{}, common.Attributes, bool) {
48 fai := input.(*models.FairwayAvailabilityImport) 46 fai := input.(*models.FairwayAvailabilityImport)
49 fa := &imports.FairwayAvailability{ 47 return &imports.FairwayAvailability{
50 URL: fai.URL, 48 URL: fai.URL,
51 Insecure: fai.Insecure, 49 Insecure: fai.Insecure,
52 } 50 }
53 return fa, fai.Attributes, fai.SendEmail 51 }
54 } 52
55 53 func importWaterwayAxis(input interface{}) interface{} {
56 func importWaterwayAxis(input interface{}) (interface{}, common.Attributes, bool) {
57 wxi := input.(*models.WaterwayAxisImport) 54 wxi := input.(*models.WaterwayAxisImport)
58 wx := &imports.WaterwayAxis{ 55 return &imports.WaterwayAxis{
59 URL: wxi.URL, 56 URL: wxi.URL,
60 FeatureType: wxi.FeatureType, 57 FeatureType: wxi.FeatureType,
61 SortBy: wxi.SortBy, 58 SortBy: wxi.SortBy,
62 } 59 }
63 return wx, wxi.Attributes, wxi.SendEmail 60 }
64 } 61
65 62 func importWaterwayArea(input interface{}) interface{} {
66 func importWaterwayArea(input interface{}) (interface{}, common.Attributes, bool) {
67 wai := input.(*models.WaterwayAreaImport) 63 wai := input.(*models.WaterwayAreaImport)
68 wa := &imports.WaterwayArea{ 64 return &imports.WaterwayArea{
69 URL: wai.URL, 65 URL: wai.URL,
70 FeatureType: wai.FeatureType, 66 FeatureType: wai.FeatureType,
71 SortBy: wai.SortBy, 67 SortBy: wai.SortBy,
72 } 68 }
73 return wa, wai.Attributes, wai.SendEmail 69 }
74 } 70
75 71 func importWaterwayGauge(input interface{}) interface{} {
76 func importWaterwayGauge(input interface{}) (interface{}, common.Attributes, bool) {
77 wgi := input.(*models.WaterwayGaugeImport) 72 wgi := input.(*models.WaterwayGaugeImport)
78 username, _ := wgi.Attributes.Get("username") 73 return &imports.WaterwayGauge{
79 password, _ := wgi.Attributes.Get("password") 74 Username: nilString(wgi.User),
80 insecure := wgi.Attributes.Bool("insecure") 75 Password: nilString(wgi.Password),
81 wg := &imports.WaterwayGauge{ 76 Insecure: wgi.Insecure,
82 URL: wgi.URL, 77 }
83 Username: username, 78 }
84 Password: password, 79
85 Insecure: insecure, 80 func importDistancemarksVirtual(input interface{}) interface{} {
86 }
87 return wg, wgi.Attributes, wgi.SendEmail
88 }
89
90 func importDistancemarksVirtual(input interface{}) (interface{}, common.Attributes, bool) {
91 dmvi := input.(*models.DistanceMarksVirtualImport) 81 dmvi := input.(*models.DistanceMarksVirtualImport)
92 username, _ := dmvi.Attributes.Get("username") 82 return &imports.DistanceMarksVirtual{
93 password, _ := dmvi.Attributes.Get("password")
94 insecure := dmvi.Attributes.Bool("insecure")
95 wg := &imports.DistanceMarksVirtual{
96 URL: dmvi.URL, 83 URL: dmvi.URL,
97 Username: username, 84 Username: nilString(dmvi.User),
98 Password: password, 85 Password: nilString(dmvi.Password),
99 Insecure: insecure, 86 Insecure: dmvi.Insecure,
100 } 87 }
101 return wg, dmvi.Attributes, dmvi.SendEmail 88 }
102 } 89
103 90 func importFairwayDimension(input interface{}) interface{} {
104 func importFairwayDimension(input interface{}) (interface{}, common.Attributes, bool) {
105 fdi := input.(*models.FairwayDimensionImport) 91 fdi := input.(*models.FairwayDimensionImport)
106 fd := &imports.FairwayDimension{ 92 return &imports.FairwayDimension{
107 URL: fdi.URL, 93 URL: fdi.URL,
108 FeatureType: fdi.FeatureType, 94 FeatureType: fdi.FeatureType,
109 SortBy: fdi.SortBy, 95 SortBy: fdi.SortBy,
110 LOS: fdi.LOS, 96 LOS: fdi.LOS,
111 MinWidth: fdi.MinWidth, 97 MinWidth: fdi.MinWidth,
112 MaxWidth: fdi.MaxWidth, 98 MaxWidth: fdi.MaxWidth,
113 Depth: fdi.Depth, 99 Depth: fdi.Depth,
114 SourceOrganization: fdi.SourceOrganization, 100 SourceOrganization: fdi.SourceOrganization,
115 } 101 }
116 return fd, fdi.Attributes, fdi.SendEmail 102 }
117 } 103
118 104 func importDistanceMarksAshore(input interface{}) interface{} {
119 func importDistanceMarksAshore(input interface{}) (interface{}, common.Attributes, bool) {
120 dmai := input.(*models.DistanceMarksAshoreImport) 105 dmai := input.(*models.DistanceMarksAshoreImport)
121 dma := &imports.DistanceMarksAshore{ 106 return &imports.DistanceMarksAshore{
122 URL: dmai.URL, 107 URL: dmai.URL,
123 FeatureType: dmai.FeatureType, 108 FeatureType: dmai.FeatureType,
124 SortBy: dmai.SortBy, 109 SortBy: dmai.SortBy,
125 } 110 }
126 return dma, dmai.Attributes, dmai.SendEmail 111 }
127 } 112
128 113 func importStretch(input interface{}) interface{} {
129 func importStretch(input interface{}) (interface{}, common.Attributes, bool) {
130 sti := input.(*models.StretchImport) 114 sti := input.(*models.StretchImport)
131 st := &imports.Stretch{ 115 return &imports.Stretch{
132 Name: sti.Name, 116 Name: sti.Name,
133 From: sti.From, 117 From: sti.From,
134 To: sti.To, 118 To: sti.To,
135 ObjNam: sti.ObjNam, 119 ObjNam: sti.ObjNam,
136 NObjNam: sti.NObjNam, 120 NObjNam: sti.NObjNam,
137 Source: sti.Source, 121 Source: sti.Source,
138 Date: sti.Date, 122 Date: sti.Date,
139 Countries: sti.Countries, 123 Countries: sti.Countries,
140 } 124 }
141 return st, sti.Attributes, sti.SendEmail
142 } 125 }
143 126
144 func retry(a common.Attributes) (time.Time, *int, *time.Duration) { 127 func retry(a common.Attributes) (time.Time, *int, *time.Duration) {
145 due, _ := a.Time("due") 128 due, _ := a.Time("due")
146 ret, ok := a.Int("retries") 129 ret, ok := a.Int("retries")
154 duration = &dur 137 duration = &dur
155 } 138 }
156 return due, retries, duration 139 return due, retries, duration
157 } 140 }
158 141
142 func nilString(s *string) string {
143 if s != nil {
144 return *s
145 }
146 return ""
147 }
148
159 func manualImport( 149 func manualImport(
160 kind imports.JobKind, 150 kind imports.JobKind,
161 setup func(interface{}) (interface{}, common.Attributes, bool), 151 setup func(interface{}) interface{},
162 ) func(interface{}, *http.Request, *sql.Conn) (JSONResult, error) { 152 ) func(interface{}, *http.Request, *sql.Conn) (JSONResult, error) {
163 153
164 return func(input interface{}, req *http.Request, _ *sql.Conn) ( 154 return func(input interface{}, req *http.Request, _ *sql.Conn) (
165 jr JSONResult, err error) { 155 jr JSONResult, err error) {
166 156
167 what, attrs, sendEmail := setup(input) 157 what := setup(input)
168
169 due, retries, waitRetry := retry(attrs)
170
171 var serialized string 158 var serialized string
172 if serialized, err = common.ToJSONString(what); err != nil { 159 if serialized, err = common.ToJSONString(what); err != nil {
173 return 160 return
161 }
162
163 var (
164 due time.Time
165 trys *int
166 waitRetry *time.Duration
167 email bool
168 )
169
170 if qctg, ok := input.(models.QueueConfigurationGetter); ok {
171 qct := qctg.GetQueueConfiguration()
172 if qct.Due != nil {
173 due = *qct.Due
174 }
175 trys = qct.Trys
176 waitRetry = qct.WaitRetry
177 email = qct.EMail
174 } 178 }
175 179
176 session, _ := auth.GetSession(req) 180 session, _ := auth.GetSession(req)
177 181
178 var jobID int64 182 var jobID int64
179 if jobID, err = imports.AddJob( 183 if jobID, err = imports.AddJob(
180 kind, 184 kind,
181 due, 185 due,
182 retries, 186 trys,
183 waitRetry, 187 waitRetry,
184 session.User, 188 session.User,
185 sendEmail, 189 email,
186 serialized, 190 serialized,
187 ); err != nil { 191 ); err != nil {
188 return 192 return
189 } 193 }
190 194