@opengis/gis 0.2.44 → 0.2.46

package/server/routes/gis/cartocss/add.cartocss.js

@@ -1,18 +1,152 @@
+import carto from 'carto';
+
+import { dataUpdate } from '@opengis/fastify-table/utils.js';
+import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+
+const { UploadXML } = mapnik();
+
+const srsList = {};
+
+const getGeomColumn = (geoms, customColumn) => {
+  if (customColumn && geoms.includes(customColumn)) {
+    return customColumn;
+  }
+  if (geoms.includes('geom')) {
+    return 'geom';
+  }
+  return geoms[0];
+};
+
+async function cartoBounds({ id, dataset }, pg) {
+  const sqlBounds = dataset.map(el => ({ tbl: el.table.split('.'), geom: el.gcol || 'geom' })).map(({ tbl, geom }) => `select ST_EstimatedExtent('${tbl[0]}','${tbl[1]}', '${geom}')`);
+
+  const geom = await pg.query(
+    `update gis.style set             
+      geom=(select st_extent(st_estimatedextent) from ( ${sqlBounds.join(' union all ')})q )
+      where style_id=$1 returning geom::box2d`,
+    [id],
+  ).then(e => e.rows?.[0]?.geom);
+
+  const bounds = geom
+    ? geom.replace(/[A-Z\)\(]+/g, '').split(/[ ,]+/).map(el => el - 0)
+    : null;
+
+  if (!bounds) {
+    throw new Error('empty bounds');
+  }
+
+  return bounds;
+}
+
+function cartoData(el, extent, pg) {
+  const minzoom = el.zoom ? (+el.zoom || 5) : 5;
+  const maxzoom = el.maxzoom ? (+el.maxzoom || 22) : 22;
+  const view = `(select ${el.columns || '1'}, ${el.gcol} from ${el.table} where ${el.query || 'true'} ) as data`;
+  const layerBound = extent || [-180, -85, 180, 85];
+
+  return {
+    id: el.caption,
+    name: el.caption,
+    properties: { minzoom, maxzoom },
+    srs: el.proj4text || '+proj=longlat +datum=WGS84 +no_defs',
+    Datasource: {
+      simplify_geometries: true,
+      type: 'postgis',
+      extent: layerBound.join(','),
+      table: view,
+      geometry_field: el.gcol,
+      host: pg.options?.host || 'localhost',
+      dbname: pg.options?.database || 'postgres',
+      port: pg.options?.port || 5432,
+      user: pg.options?.user || 'postgres',
+      password: pg.options?.password || 'postgres',
+    },
+  };
+}
+
+async function uploadXML({ id, dataset, style }, pg) {
+  if (!id || !dataset?.length) {
+    return null;
+  }
+  await Promise.all(dataset.filter((el) => el.active !== false).map(async el => {
+    const { table } = el;
+
+    const geoms = await pg.query(`SELECT json_agg(attname) as geoms FROM pg_attribute
+      where attrelid = to_regclass($1::text)
+      and attnum > 0
+      AND NOT attisdropped
+      and atttypid::regtype::text ='geometry'`, [table]).then(e => e.rows?.[0]?.geoms || []);
+
+    const gcol = getGeomColumn(geoms, el.gcol);
+    Object.assign(el, { gcol });
+
+    const srid = el.srid ? el.srid
+      : await pg.query(`select st_srid(${gcol}) as srid from ${table} where ${gcol} is not null limit 1`).then(e => e.rows[0]?.srid);
+
+    if (srid && !srsList[srid] && (srid - 0 > 0)) {
+      srsList[srid] = await pg.query(`SELECT proj4text from spatial_ref_sys where srid=$1`, [srid])
+        .then(e => e.rows[0]?.proj4text);
+    }
+    Object.assign(el, { gcol, proj4text: srsList[srid] });
+  }));
+
+  const bounds = await cartoBounds({ id, dataset }, pg);
+
+  const arrayLayers = dataset.filter((el) => el.active !== false).map((el) => cartoData(el, bounds, pg));
+
+  const configJson = {
+    format: 'png',
+    Layer: arrayLayers.reverse(),
+    srs: '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over',
+    bounds,
+    'maximum-extent': '-20037508.34,-20037508.34,20037508.34,20037508.34',
+    center: [0, 0, 2],
+    minzoom: 1,
+    maxzoom: 25,
+    Stylesheet: [{
+      id: 'carto_css_style',
+      data: style || '',
+    }],
+  };
+
+  // generate
+  const res = new carto.Renderer().render(configJson);
+  const xmlFileText = typeof res === 'string' ? res : res?.data;
+  if (!xmlFileText) {
+    throw new Error('xml generation error');
+  }
+  const { status } = await UploadXML({
+    name: id,
+    xml: xmlFileText,
+  });
+  if (status !== 'success') {
+    throw new Error('xml upload error');
+  }
+  return xmlFileText;
+}
+
 export default async function addCartocss(req, reply) {
   const { pg, body, params } = req;
 
   const { id } = params;
   if (!id) return reply.status(400).send({ message: 'id is empty', status: 400 });
 
-  const { config, style } = body;
-  if (!config && !style) return reply.status(400).send({ message: 'config, style is empty', status: 400 });
+  const { config: dataset, style } = body;
+  if (!dataset && !style) return reply.status(400).send({ message: 'config, style is empty', status: 400 });
 
   const selectCartocss = `select cartocss_id from gis.cartocss where cartocss_id=$1`;
   const cartocss = await pg.one(selectCartocss, [id]);
   if (!cartocss) return reply.status(404).send({ message: 'cartocss not found', status: 404 });
 
-  const updateCartocss = `update gis.cartocss set config=$2::jsonb, style=$3::text where cartocss_id=$1`;
-  await pg.query(updateCartocss, [id, config, style]);
+  await dataUpdate({
+    pg,
+    id,
+    table: 'gis.cartocss',
+    data: { config: dataset, style },
+    uid: req.user?.uid,
+  });
+
+  await uploadXML({ id, dataset, style }, pg);
 
   return reply.status(200).send({ message: 'cartocss updated', status: 200 });
 }

package/server/routes/map/index.mjs

@@ -4,7 +4,7 @@ import mapFeatures from './controllers/mapFeatures.js';
 
 import mapCatalog from './controllers/mapCatalog.js';
 import mapCatalogAttribute from './controllers/mapCatalogAttribute.js';
-import rtile from './controllers/rtile.js';
+// import rtile from './controllers/rtile.js';
 import vtile from './controllers/vtile.js';
 import vtile1 from './vtile1.js';
 import geojson from './controllers/geojson.js';
@@ -99,9 +99,9 @@ export default async function route(app) {
   if (!app.hasRoute({ method: 'GET', url: '/map-catalog/:service/:attr' })) {
     app.get('/map-catalog/:service/:attr', publicParams, mapCatalogAttribute);
   }
-  if (!app.hasRoute({ method: 'GET', url: '/layer-rtile/:id/:z/:y/:x' })) {
-    app.get('/layer-rtile/:id/:z/:y/:x', publicParams, rtile);
-  }
+  // if (!app.hasRoute({ method: 'GET', url: '/layer-rtile/:id/:z/:y/:x' })) {
+  //   app.get('/layer-rtile/:id/:z/:y/:x', publicParams, rtile);
+  // }
   if (!app.hasRoute({ method: 'GET', url: '/layer-vtile/:id/:z/:y/:x' })) {
     app.get('/layer-vtile/:id/:z/:y/:x', publicParams, vtile);
   }

package/server/routes/map/maps/get.map.js

@@ -32,7 +32,7 @@ export default async function getMap({ params = {}, pg = pgClients.client }, rep
   const totals = pg.queryCache ? await pg.queryCache('select json_object_agg(oid::regclass, reltuples) from pg_class')
     .then(el => el.rows?.[0]?.json_object_agg || {}) : {};
   const maps = pg.pk?.['gis.maps'] ? await pg.query(
-    'SELECT map_id as id, map_key as slug, name FROM gis.maps',
+    'SELECT map_id as id, map_key as slug, name  FROM gis.maps where is_active and is_public order by name',
   ).then(el => el.rows || []) : [];
 
   if (params.id) {

package/server/routes/mapnik/controllers/createXML.js

@@ -0,0 +1,61 @@
+import path from 'node:path';
+
+import { pgClients, eventStream } from '@opengis/fastify-table/utils.js';
+
+import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+
+const { GetRasterStatus, CreateXML } = mapnik();
+
+export default async function createXml({
+    pg = pgClients.client, params, query,
+}, reply) {
+    if (!GetRasterStatus || !CreateXML) {
+        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+    }
+
+    const { id } = params;
+
+    if (!id) {
+        return reply.status(400).send({ error: 'not enough params: id', code: 400 });
+    }
+
+    const data = pg.pk?.['gis.rasters']
+        ? await pg.query('select raster_id as id, source_path, srid, raster_zoom from gis.rasters where raster_id=$1::text', [id])
+            .then(el => el.rows?.[0])
+        : null;
+
+    if (!data?.id) {
+        return reply.status(404).send({ error: 'raster not found', code: 404 });
+    }
+
+    if (!data.source_path) {
+        return reply.status(400).send({ error: 'raster source_path not set', code: 400 });
+    }
+
+    const relpath = `/map/raster/${data.source_path}`;
+
+    // check raster upload status, skip for directories
+    const uploadStatus = path.extname(relpath) ? await GetRasterStatus({ path: relpath }) : {};
+
+    if (uploadStatus.exists === false) {
+        return reply.status(400).send({ error: 'raster not uploaded', code: 400 });
+    }
+
+    if (uploadStatus.finished === false) {
+        return reply.status(400).send({ error: 'upload not finished', code: 400 });
+    }
+
+    const callback = eventStream(reply);
+
+    // create at xml/:id with name only, always - by path
+    const resp = await CreateXML({
+        path: data.source_path,
+        name: id,
+        previewZoom: data.raster_zoom,
+        srid: data.srid,
+        vrt: query.vrt === '1' /* || !data.source_path.toLowerCase().endsWith('.tif') */,
+    }, callback);
+
+    callback('finish', 1);
+    return reply.status(200).send(resp);
+}

package/server/routes/mapnik/controllers/rtile.js

@@ -0,0 +1,86 @@
+import Sphericalmercator from '@mapbox/sphericalmercator';
+
+import { config, logger, pgClients } from '@opengis/fastify-table/utils.js';
+
+import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+
+const { RenderTile } = mapnik();
+
+const mercator = new Sphericalmercator({ size: 256 });
+
+/**
+ * Формування растрового tile cartoCss
+ *
+ * @method GET
+ * @alias rtile
+ * @param {String} bbox - bbox
+ * @param {Number} height - висота по координатам
+ * @param {Number} width - ширина по координатам
+ * @param {String} data - стилізація
+ * @param {String} lang - мова
+ * @param {String} z - координата z
+ * @param {String} x - координата y
+ * @param {String} y - координата x
+ */
+
+export default async function rtile({
+    pg = pgClients.client, params, query,
+}, reply) {
+    if (!RenderTile) {
+        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+    }
+
+    const { id, z, y } = params;
+
+    const x = params.x.split('.')[0] - 0;
+
+    if (!id) {
+        return reply.status(400).send({ error: 'not enough params: id', code: 400 });
+    }
+
+    if (!x || !y || !z) {
+        return reply.status(400).send({ error: 'not enough params: xyz', code: 400 });
+    }
+
+    const raster = pg.pk?.['gis.rasters']
+        ? await pg.query('select raster_id, source_path from gis.rasters where raster_id=$1::text', [id])
+            .then(el => el.rows?.[0])
+        : null;
+
+    // const relpath = raster ? `/map/raster/${raster.source_path}` : null;
+
+    const cartoExists = pg.pk?.['gis.cartocss']
+        ? await pg.query('select cartocss_id from gis.cartocss where cartocss_id=$1::text', [id])
+            .then(el => el.rows?.[0]?.cartocss_id)
+        : null;
+
+    if (!raster && !cartoExists) {
+        return reply.status(404).send({ error: 'raster / cartocss not found', code: 404 });
+    }
+
+    const bbox = mercator.bbox(y, x, z, false, '900913');
+
+    try {
+        const data = await RenderTile({
+            path: raster ? raster.source_path : null,
+            name: id,
+            width: 256,
+            height: 256,
+            bbox,
+            ttl: query.nocache ? '0' : '1h',
+        });
+
+        if (data.err) {
+            logger.file('rtile/error', { error: data.err });
+            return reply.status(500).send({ error: config.local ? data.err : 'render error', code: 500 });
+        }
+
+        const buffer = Buffer.from(data.base64, 'base64');
+
+        return reply.headers({ 'Content-Type': 'image/png' }).send(buffer);
+    }
+    catch (err) {
+        logger.file('rtile/error', { error: err.toString(), stack: err.stack });
+        return reply.status(500).send({ error: config.local ? err.toString() : 'rtile error', code: 500 });
+    }
+}

package/server/routes/mapnik/controllers/uploadRaster.js

@@ -0,0 +1,159 @@
+import path from 'node:path';
+import { ListObjectsV2Command } from '@aws-sdk/client-s3';
+
+/* eslint-disable no-await-in-loop */
+import {
+    config, isFileExists, logger, pgClients, eventStream, downloadFile, s3Client,
+} from '@opengis/fastify-table/utils.js';
+
+import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
+
+const { UploadRaster, GetRasterStatus } = mapnik();
+
+const CHUNK_SIZE = 1024 * 1024; // 1 MB per chunk
+
+function sequence(files, data, fn) {
+    return files.reduce(
+        (promise, relpath) => promise.then(() => fn({
+            ...data,
+            relpath, // allow upload multiple to one directory for vrt
+        })),
+        Promise.resolve(),
+    );
+}
+
+async function uploadRasterFile({
+    id, prefix, relpath: relpathOriginal, callback = () => { },
+}) {
+    const name = path.basename(relpathOriginal);
+    const metadata = await isFileExists(relpathOriginal);
+    const relpath = relpathOriginal.replace(config.folder, '').replace(prefix, '');
+
+    if (!metadata || !metadata.ContentLength) {
+        callback(`File not found at s3: ${relpath}`);
+        return { error: `File not found at s3: ${relpath}`, code: 404 };
+    }
+
+    let offset = 0;
+
+    try {
+        const uploadStatus = await GetRasterStatus({ path: relpath, md5: true });
+
+        offset = uploadStatus.exists ? +uploadStatus.size : 0;
+
+        if (offset === metadata.ContentLength) {
+            callback(`Already uploaded: ${relpath}`);
+            return { message: 'already uploaded', status: 200 };
+        }
+
+        while (offset < metadata.ContentLength) {
+            const end = Math.min(offset + CHUNK_SIZE - 1, metadata.ContentLength - 1);
+            const Range = `bytes=${offset}-${end}`;
+
+            callback(`Uploading chunk ${(end / 1024 / 1024).toFixed(0)}/${(metadata.ContentLength / 1024 / 1024).toFixed(0)} MB...`);
+
+            const chunk = await downloadFile(relpathOriginal, { Range, fallback: false });
+            // const { Body: chunk } = await s3Client.send(new GetObjectCommand({ Bucket, Key, Range }));
+            const bufferPart = chunk ? await chunk.transformToByteArray() : [];
+
+            if (!bufferPart.length) {
+                callback(`Server error: file not found / zero bytes: ${relpath}`);
+                break;
+            }
+
+            const result = await UploadRaster({
+                path: relpath,
+                filesize: metadata.ContentLength,
+                data: bufferPart,
+                chunked: true,
+            });
+
+            if (result.finished) {
+                callback(`Upload completed: ${relpath}`);
+                break;
+            }
+
+            if (!result.uploaded) {
+                callback(`Chunked upload error: ${relpath}`);
+                break;
+            }
+
+            offset = +result.uploaded;
+        }
+
+        return null;
+    }
+    catch (err) {
+        logger.file('mapnik/upload/error', { error: err.toString(), stack: err.stack });
+        callback(config.local ? err.toString() : `Upload error: ${relpath}`);
+        return null;
+    }
+}
+
+export default async function uploadRaster({
+    pg = pgClients.client, params,
+}, reply) {
+    if (!UploadRaster || !GetRasterStatus) {
+        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+    }
+
+    const { id } = params;
+
+    if (!id) {
+        return reply.status(400).send({ error: 'not enough params: id', code: 400 });
+    }
+
+    const data = pg.pk?.['gis.rasters']
+        ? await pg.query('select raster_id as id, source_path from gis.rasters where raster_id=$1::text', [id])
+            .then(el => el.rows?.[0])
+        : null;
+
+    if (!data?.id) {
+        return reply.status(404).send({ error: 'raster not found', code: 404 });
+    }
+
+    if (!data.source_path) {
+        return reply.status(400).send({ error: 'raster source_path not set', code: 400 });
+    }
+
+    const prefix = '/map/raster';
+    const relpath = `${prefix}/${data.source_path}`;
+
+    if (!path.extname(relpath)) {
+        const metadata = await s3Client.send(new ListObjectsV2Command({
+            Bucket: config.s3?.containerName || 'work',
+            Prefix: path.join(config.folder, relpath).replace(/\\/g, '/'),
+        }));
+        if (!metadata.Contents?.length) {
+            return reply.status(404).send({
+                error: 'invalid: raster source_path: not found / empty directory',
+                code: 404,
+            });
+        }
+
+        // list rasters, skip preview subdir content, skip folders from s3 directory name of which only starts with same characters, but does not exactly match
+        const files = metadata.Contents.map(file => file.Key).filter((file) => path.basename(path.dirname(file)) === path.basename(relpath) && !path.basename(path.dirname(file)).startsWith('preview') && path.extname(file).toLowerCase() === '.tif');
+
+        if (!files.length) {
+            return reply.status(400).send({
+                error: 'invalid: raster source_path: no raster files at directory',
+                code: 400,
+            });
+        }
+        const callback = eventStream(reply);
+        await sequence(files, { id, prefix, callback }, uploadRasterFile);
+        return callback('finish', 1);
+    }
+
+    const metadata = await isFileExists(relpath);
+
+    if (!metadata || !metadata.ContentLength) {
+        return reply.status(404).send({ error: `File not found at s3: ${data.source_path}`, code: 404 });
+    }
+
+    const callback = eventStream(reply);
+    await uploadRasterFile({
+        id, prefix, callback, relpath,
+    });
+    return callback('finish', 1);
+}

package/server/routes/mapnik/index.js

@@ -0,0 +1,16 @@
+import uploadRaster from './controllers/uploadRaster.js';
+import createXML from './controllers/createXML.js';
+import rtile from './controllers/rtile.js';
+
+const publicParams = { config: { policy: 'L0' }, package: 'gis' }; // L0 === public
+const params = { config: { policy: 'L1' }, package: 'gis' }; // L1 === authorized only
+
+export default async function route(app) {
+  app.get('/raster-upload/:id', params, uploadRaster);
+  app.get('/raster-xml/:id', publicParams, createXML);
+  app.get('/raster-tile/:id/:z/:y/:x', publicParams, rtile);
+  // temporary support of old alias
+  if (!app.hasRoute({ method: 'GET', url: '/layer-rtile/:id/:z/:y/:x' })) {
+    app.get('/layer-rtile/:id/:z/:y/:x', publicParams, rtile);
+  }
+}

package/server/plugins/mapnik/funcs/createXML.js

@@ -1,72 +0,0 @@
-import carto from 'carto';
-
-import rasterExists from './rasterExists.js';
-import rasterConfig from './rasterConfig.js';
-
-export default async function createXML({
-  fullPath, srs, extent: bounds, send, size
-}) {
-
-  const configFilePath = fullPath.replace('/preview1', '').replace('mosaic.vrt', 'config.yml')
-  const configData = await rasterConfig(configFilePath);
-
-  const rasterPreview = await rasterExists(fullPath, 1);
-
-  if (rasterPreview) {
-    send('preview:' + rasterPreview);
-  }
-
-  const rasterZoom = configData?.previewZoom ?? (rasterPreview && size?.includes('G') ? 16 : 0);
-
-  const rasterScaling = 'bilinear';
-
-  const Layer = [].concat([
-    {
-      id: 'test',
-      name: 'test',
-      geometry: 'raster',
-      properties: { minzoom: +rasterZoom + 1 },
-      srs: srs || '+proj=longlat +datum=WGS84 +no_defs ',
-      Datasource: {
-        // extent: bounds.join(','),
-        file: fullPath,
-        type: 'gdal',
-      },
-    }]).concat(
-      rasterZoom && rasterPreview ? [{
-        id: 'testpreview',
-        name: 'testpreview',
-        geometry: 'raster',
-        properties: { maxzoom: +rasterZoom },
-        srs: srs || '+proj=longlat +datum=WGS84 +no_defs ',
-        Datasource: {
-          // extent: bounds.join(','),
-          file: rasterPreview,
-          type: 'gdal',
-        },
-      }]
-        : [],
-    );
-
-  const data = `#testpreview{raster-opacity:1; raster-scaling:${rasterScaling};}  #test{raster-opacity:1;raster-scaling:${rasterScaling}; } `;
-
-  const configJson = {
-    format: 'png',
-    Layer,
-    srs: '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs +over',
-    bounds: bounds || [-180, -85.05112877980659, 180, 85.05112877980659],
-    'maximum-extent': '-20037508.34,-20037508.34,20037508.34,20037508.34',
-    center: [0, 0, 2],
-    minzoom: 1,
-    maxzoom: 25,
-    Stylesheet: [{ id: 'carto_css_style', data }],
-  };
-
-  const xmlFileText = new carto.Renderer().render(configJson);
-
-  if (!xmlFileText) {
-    return { status: 500, error: `Cant create xml for ${fullPath}` };
-  }
-
-  return xmlFileText;
-}

package/server/plugins/mapnik/funcs/gdalWrapper.js

@@ -1,72 +0,0 @@
-import path from 'path';
-import { randomUUID as uuidv4 } from 'crypto';
-import mapnik from './mapnik.js';
-
-import { config } from '@opengis/fastify-table/utils.js';
-
-const { mapServerAddress } = mapnik();
-
-function unixPath(data) {
-  if (mapServerAddress && !mapServerAddress?.includes('localhost') && data?.[1] === ':') {
-    return path.posix.join('/data/softpro', data.substr(3).replace(/\\/g, '/'));
-  }
-  return data;
-}
-const gdalWrapper = async ({
-  name, pathIn, pathOut, parameters, funcs, send = console.log,
-}) => {
-  const timeStart = new Date();
-  const pref = name === 'gdalbuildvrt' ? ' -o ' : '';
-  const cmd = `${name} ${parameters || ''} ${unixPath(pathIn) || ''} ${pref} ${unixPath(pathOut) || ''}`;
-
-  if (mapServerAddress) {
-    const out = pref + (unixPath(pathOut) || '');
-    const obj = {
-      name, path: unixPath(pathIn), out, params: parameters,
-    };
-
-    const time = Date.now();
-    const { result, err } = await mapnik().gdal(obj);
-
-    if (config.local && false) {
-      send(cmd);
-      send(JSON.stringify(obj));
-      send(`${Date.now() - time}`);
-    }
-
-    if (err) {
-      const logObj = {
-        level: 'ERROR',
-        uuid: uuidv4(),
-        name: 'GDAL',
-        subname: 'GDALWRAPPER',
-        msec: new Date() - timeStart,
-        param: { cmd },
-        status: '500',
-        response: { error: err },
-      };
-      // log.error({ name: 'gdal', ...logObj });
-      send(err);
-    }
-    return { err, result };
-  }
-
-  const result = await funcs.exec(cmd, { send });
-  if (!result) {
-    const logObj = {
-      level: 'ERROR',
-      uuid: uuidv4(),
-      name: 'GDAL',
-      subname: 'GDALWRAPPER',
-      msec: new Date() - timeStart,
-      param: { cmd },
-      status: '500',
-      response: { error: `Cant execute ${cmd}` },
-    };
-    // log.error({ name: 'gdal', ...logObj });
-    return { err: `Cant execute ${cmd}` };
-  }
-  return { result };
-};
-
-export default gdalWrapper;