gemma: pkg/imports/sr.go comparison

comparison pkg/imports/sr.go @ 1392:0e1d89241cda

Imports: An Import (e.g. a sounding result import) can now write a 'summary' of a successful import. This is done if the import switches to to state 'pending'.

author	Sascha L. Teichmann <sascha.teichmann@intevation.de>
date	Wed, 28 Nov 2018 09:52:34 +0100
parents	8d59457a5651
children	eb82076fdffe

comparison

equal deleted inserted replaced

-:801ae5f4bc5b
+:0e1d89241cda
 ST_Transform(ST_GeomFromWKB($5, $6::integer), 4326)::geography
 END)
 )
 RETURNING
 id,
+ST_X(ST_Centroid(point_cloud::geometry)),
+ST_Y(ST_Centroid(point_cloud::geometry)),
 CASE WHEN ST_Y(ST_Centroid(point_cloud::geometry)) > 0 THEN
 32600
 ELSE
 32700
 END + floor((ST_X(ST_Centroid(point_cloud::geometry))+180)/6)::int + 1`
 func (sr *SoundingResult) Do(
 	ctx context.Context,
 	importID int64,
 	conn *sql.Conn,
 	feedback Feedback,
-) error {
+) (interface{}, error) {
 	z, err := zip.OpenReader(filepath.Join(sr.Dir, "sr.zip"))
 	if err != nil {
-		return err
+		return nil, err
 	}
 	defer z.Close()
 	feedback.Info("Looking for 'meta.json'")
 	mf := common.FindInZIP(z, "meta.json")
 	if mf == nil && !sr.completeOverride() {
-		return errors.New("Cannot find 'meta.json'")
+		return nil, errors.New("Cannot find 'meta.json'")
 	}
 	m, err := sr.loadMeta(mf)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if err := m.Validate(ctx, conn); err != nil {
-		return common.ToError(err)
+		return nil, common.ToError(err)
 	}
 	feedback.Info("Looking for '*.xyz'")
 	xyzf := common.FindInZIP(z, ".xyz")
 	if xyzf == nil {
-		return errors.New("Cannot find any *.xyz file")
+		return nil, errors.New("Cannot find any *.xyz file")
 	}
 	xyz, err := loadXYZ(xyzf, feedback)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if len(xyz) == 0 {
-		return errors.New("XYZ does not contain any vertices")
+		return nil, errors.New("XYZ does not contain any vertices")
 	}
 	// Is there a boundary shapefile in the ZIP archive?
 	polygon, err := loadBoundary(z)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	tx, err := conn.BeginTx(ctx, nil)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	defer tx.Rollback()
-	var id int64
+	var (
-	var epsg uint32
+		id       int64
+		epsg     uint32
+		lat, lon float64
+	)
 	start := time.Now()
 	err = tx.QueryRow(insertPointsSQL,
 		m.Bottleneck,
 		m.Date.Time,
 		m.DepthReference,
 		xyz.AsWKB(),
 		polygon.AsWBK(),
 		m.EPSG,
-	).Scan(&id, &epsg)
+	).Scan(&id, &lat, &lon, &epsg)
 	xyz, polygon = nil, nil // not need from now on.
 	feedback.Info("storing points took %s", time.Since(start))
 	if err != nil {
-		return err
+		return nil, err
 	}
 	feedback.Info("Best suited UTM EPSG: %d", epsg)
 	feedback.Info("Triangulate...")
 	start = time.Now()
 	tin, err := octree.GenerateTinByID(ctx, conn, id, epsg)
 	feedback.Info("triangulation took %s", time.Since(start))
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if tin == nil {
-		return errors.New("cannot load TIN from database")
+		return nil, errors.New("cannot load TIN from database")
 	}
 	feedback.Info("Building octree...")
 	builder := octree.NewBuilder(tin)
 	start = time.Now()
 	builder.Build()
 	octreeIndex, err := builder.Bytes()
 	tin = nil // not needed from now on
 	feedback.Info("building octree took %s", time.Since(start))
 	if err != nil {
-		return err
+		return nil, err
 	}
 	feedback.Info("Store octree...")
 	start = time.Now()
 	h := sha1.New()
 	h.Write(octreeIndex)
 	checksum := hex.EncodeToString(h.Sum(nil))
 	_, err = tx.Exec(insertOctreeSQL, id, checksum, octreeIndex)
 	feedback.Info("storing octree index took %s", time.Since(start))
 	if err != nil {
-		return err
+		return nil, err
 	}
 	tree := builder.Tree()
 	builder = nil // not needed from now on
 	feedback.Info("Generate contour lines...")
 	start = time.Now()
 	err = generateContours(tree, tx, id)
 	feedback.Info("generating and storing contour lines took %s", time.Since(start))
 	if err != nil {
-		return err
+		return nil, err
 	}
 	// Store for potential later removal.
 	if err = track(ctx, tx, importID, "waterway.sounding_results", id); err != nil {
-		return err
+		return nil, err
 	}
 	if err = tx.Commit(); err == nil {
 		feedback.Info("Storing sounding result was successful.")
 	}
-	return err
+	summary := struct {
+		Bottleneck string                    `json:"bottleneck"`
+		Date       models.SoundingResultDate `json:"date"`
+		Lat        float64                   `json:"lat"`
+		Lon        float64                   `json:"lon"`
+	}{
+		Bottleneck: m.Bottleneck,
+		Date:       m.Date,
+		Lat:        lat,
+		Lon:        lon,
+	}
+	return &summary, err
 }
 func (sr *SoundingResult) CleanUp() error {
 	return os.RemoveAll(sr.Dir)
 }

Mercurial > gemma

comparison pkg/imports/sr.go @ 1392:0e1d89241cda