geojson#GeoJSON TypeScript Examples

// get the first coordinate in a GeoJSON
export function coordFirst(data: GeoJSON): number[] {
  if (data.type === 'FeatureCollection') {
    return coordFirst(data.features[0].geometry);
  }
  if (data.type === 'Feature') {
    return coordFirst(data.geometry);
  }
  if (data.type === 'GeometryCollection') {
    return coordFirst(data.geometries[0]);
  }
  if (data.type === 'MultiPolygon') {
    return data.coordinates[0][0][0];
  }
  if (data.type === 'Polygon') {
    return data.coordinates[0][0];
  }
  throw new Error(
    'you called coordFirst on data that is not a GeoJSON or GeoJSON Geometry',
  );
}

handleEntityDuplicate = <T>(
  repository: Repository<T>,
  query: (
    repository: Repository<T>,
    polygon?: GeoJSON | null,
  ) => Promise<T | undefined>,
  polygon?: GeoJSON | null,
) => {
  return (err) => {
    // Catch unique violation, i.e. there is already a site at this location
    if (err.code === '23505') {
      return query(repository, polygon).then((found) => {
        if (!found) {
          throw new InternalServerErrorException(
            'Could not fetch conflicting entry',
          );
        }

        return found;
      });
    }

    throw err;
  };
}

poiQuery = (
  poiRepository: Repository<SiteSurveyPoint>,
  polygon?: GeoJSON | null,
) => {
  return poiRepository
    .createQueryBuilder(`surveyPoints`)
    .innerJoinAndSelect('surveyPoints.site', 'site')
    .where(
      `surveyPoints.polygon = ST_SetSRID(ST_GeomFromGeoJSON(:polygon), 4326)::geometry`,
      { polygon },
    )
    .getOne();
}

siteQuery = (
  siteRepository: Repository<Site>,
  polygon?: GeoJSON | null,
) => {
  return siteRepository
    .createQueryBuilder(`entity`)
    .where(
      `entity.polygon = ST_SetSRID(ST_GeomFromGeoJSON(:polygon), 4326)::geometry`,
      { polygon },
    )
    .getOne();
}

createUserDto = (mockUser: DeepPartial<User>): CreateUserDto => ({
  fullName: mockUser.fullName,
  email: mockUser.email as string,
  organization: mockUser.organization,
  country: mockUser.country,
  description: mockUser.description,
  imageUrl: mockUser.imageUrl,
  location: mockUser.location as GeoJSON,
})

@ApiPointProperty()
  @Column({
    type: 'geometry',
    spatialFeatureType: 'Point',
    nullable: true,
    srid: 4326,
  })
  @Index({ spatial: true })
  location: GeoJSON | null;

@ApiPointProperty()
  @Column({
    type: 'geometry',
    unique: true,
    srid: 4326,
    nullable: false,
  })
  @Index({ spatial: true })
  polygon: GeoJSON | null;

async update(
    id: number,
    updateSiteSurveyPointDto: UpdateSiteSurveyPointDto,
  ): Promise<SiteSurveyPoint> {
    const { latitude, longitude, siteId } = updateSiteSurveyPointDto;
    const polygon: { polygon: GeoJSON } | {} =
      longitude !== undefined && latitude !== undefined
        ? {
            polygon: createPoint(longitude, latitude),
          }
        : {};
    const updateSite = siteId !== undefined ? { site: { id: siteId } } : {};

    const result = await this.surveyPointsRepository.update(id, {
      ...omit(updateSiteSurveyPointDto, 'longitude', 'latitude', 'siteId'),
      ...updateSite,
      ...polygon,
    });

    if (!result.affected) {
      throw new NotFoundException(
        `Site Point of Interest with ID ${id} not found.`,
      );
    }

    const updated = await this.surveyPointsRepository.findOne(id);

    return updated!;
  }

async create(
    createSiteSurveyPointDto: CreateSiteSurveyPointDto,
  ): Promise<SiteSurveyPoint> {
    const { latitude, longitude, siteId } = createSiteSurveyPointDto;

    const polygon: GeoJSON | undefined =
      longitude !== undefined && latitude !== undefined
        ? createPoint(longitude, latitude)
        : undefined;

    return this.surveyPointsRepository.save({
      ...createSiteSurveyPointDto,
      site: { id: siteId },
      polygon,
    });
  }

@ApiPointProperty()
  @Column({
    type: 'geometry',
    unique: true,
    srid: 4326,
    nullable: true,
  })
  @Index({ spatial: true })
  polygon: GeoJSON | null;

@ApiPointProperty()
  @Column({
    type: 'geometry',
    unique: true,
    srid: 4326,
    nullable: false,
  })
  @Index({ spatial: true })
  polygon: GeoJSON | null;

@Column('point')
  @Index({ spatial: true })
  location: GeoJSON;

@ApiPointProperty()
  @IsOptional()
  @IsNotEmpty()
  readonly location?: GeoJSON | null;

async findSensors(): Promise<
    (Site & { sensorPosition: GeoJSON; sensorType: SensorType })[]
  > {
    const sites = await this.siteRepository.find({
      where: { sensorId: Not(IsNull()) },
    });

    // Get spotter data and add site id to distinguish them
    const spotterData = await Bluebird.map(
      sites,
      (site) => {
        if (site.sensorId === null) {
          console.warn(`Spotter for site ${site.id} appears null.`);
        }
        return getSpotterData(site.sensorId!).then((data) => {
          return {
            id: site.id,
            ...data,
          };
        });
      },
      { concurrency: 10 },
    );

    // Group spotter data by site id for easier search
    const siteIdToSpotterData: Record<number, SpotterData & { id: number }> =
      keyBy(spotterData, (o) => o.id);

    // Construct final response
    return sites.map((site) => {
      const data = siteIdToSpotterData[site.id];
      const longitude = getLatestData(data.longitude)?.value;
      const latitude = getLatestData(data.latitude)?.value;
      const sitePosition = site.polygon as Point;

      // If no longitude or latitude is provided by the spotter fallback to the site coordinates
      return {
        ...site,
        applied: site.applied,
        sensorPosition: createPoint(
          longitude || sitePosition.coordinates[0],
          latitude || sitePosition.coordinates[1],
        ),
        sensorType: SensorType.SofarSpotter,
      };
    });
  }

@ApiPointProperty()
  @IsOptional()
  @IsNotEmpty()
  readonly polygon?: GeoJSON;

@ApiPointProperty()
  @IsNotEmpty()
  readonly polygon: GeoJSON;

@Column({
    type: 'jsonb',
    nullable: true,
  })
  zones?: GeoJSON;