feat: Add endpoints for retrieving towns and exact town details (#31)

The code changes include adding new endpoints in the controller.js file to handle requests for retrieving towns and exact town details. The getTowns endpoint retrieves a list of towns based on various query parameters such as name, population, offset, limit, fields, and sort. The getExactTown endpoint retrieves the details of a specific town based on its ID.

This commit message follows the conventional format of "feat: <description>" to indicate the addition of a new feature.

src/v1/controller.js

@@ -2,6 +2,7 @@ const Provinces = require('./data/Provinces');
 const Districts = require('./data/Districts');
 const Neighborhoods = require('./data/Neighborhoods');
 const Villages = require('./data/Villages');
+const Towns = require('./data/Towns');
 
 exports.getProvinces = (req, res) => {
   try {
@@ -171,3 +172,43 @@ exports.getExactVillage = (req, res) => {
     });
   }
 };
+
+exports.getTowns = (req, res) => {
+  try {
+    const { name, minPopulation, maxPopulation, offset, limit, fields, sort } =
+      req.query;
+
+    const town = Towns.getTowns(
+      name,
+      minPopulation,
+      maxPopulation,
+      offset,
+      limit,
+      fields,
+      sort,
+    );
+
+    return res.send({ status: 'OK', data: town });
+  } catch (error) {
+    res.status(error?.status || 500).send({
+      status: 'ERROR',
+      error: error?.message || 'Internal Server Error',
+    });
+  }
+};
+
+exports.getExactTown = (req, res) => {
+  try {
+    const { id } = req.params;
+    const { fields } = req.query;
+
+    const town = Towns.getExactTown(id, fields);
+
+    return res.send({ status: 'OK', data: town });
+  } catch (error) {
+    res.status(error?.status || 500).send({
+      status: 'ERROR',
+      error: error?.message || 'Internal Server Error',
+    });
+  }
+};

src/v1/data/Towns.js

@@ -0,0 +1,205 @@
+const data = require('./towns.json');
+
+exports.getTowns = function (
+  name,
+  minPopulation = 1,
+  maxPopulation = 1000000000,
+  offset = 0,
+  limit,
+  fields,
+  sort,
+) {
+  try {
+    let towns = data;
+
+    if (!Object.values(arguments).some((item) => item)) {
+      return towns.slice(+offset, +offset + 1000);
+    }
+
+    if (name) {
+      nameAlt =
+        name.charAt(0).toLocaleUpperCase('TR') +
+        name.slice(1).toLocaleLowerCase('tr');
+      towns = towns.filter(
+        (item) => item.name.includes(name) || item.name.includes(nameAlt),
+      );
+    }
+
+    if (minPopulation || maxPopulation) {
+      if (+minPopulation <= 0 && +maxPopulation <= 0) {
+        throw {
+          status: 404,
+          message:
+            "You can't search for a town with a population of 0 or less.",
+        };
+      }
+
+      if (+minPopulation > +maxPopulation) {
+        throw {
+          status: 404,
+          message:
+            'The minimum population cannot be greater than the maximum population.',
+        };
+      }
+
+      towns = towns.filter((item) => {
+        return (
+          item.population >= minPopulation && item.population <= maxPopulation
+        );
+      });
+    }
+
+    if (sort) {
+      const sortArray = sort.split(',').reverse();
+
+      sortArray.forEach((item) => {
+        if (item !== 'name' && item !== '-name') {
+          if (item.startsWith('-')) {
+            const field = item.slice(1);
+            towns.sort((a, b) => (a[field] > b[field] ? -1 : 1));
+          } else {
+            towns.sort((a, b) => (a[item] > b[item] ? 1 : -1));
+          }
+        } else {
+          if (item.startsWith('-')) {
+            const field = item.slice(1);
+            towns.sort((a, b) =>
+              b[field].localeCompare(a[field], 'tr', { sensitivity: 'base' }),
+            );
+          } else {
+            towns.sort((a, b) =>
+              a[item].localeCompare(b[item], 'tr', { sensitivity: 'base' }),
+            );
+          }
+        }
+      });
+
+      if (
+        sortArray.some((item) => !Object.keys(data[0]).includes(item)) &&
+        !sortArray.some(
+          (item) => !Object.keys(data[0]).includes(item.startsWith('-')),
+        )
+      ) {
+        throw {
+          status: 404,
+          message:
+            'Invalid sort. The sort parameter must be a comma-separated list of valid fields.',
+        };
+      }
+    }
+
+    if (fields) {
+      const fieldsArray = fields.split(',');
+      const filteredTowns = [];
+
+      towns.forEach((item) => {
+        const filteredTown = {};
+        fieldsArray.forEach((field) => {
+          filteredTown[field] = item[field];
+        });
+        filteredTowns.push(filteredTown);
+      });
+
+      towns = filteredTowns;
+
+      if (fieldsArray.some((item) => !Object.keys(data[0]).includes(item))) {
+        throw {
+          status: 404,
+          message:
+            'Invalid fields. The fields parameter must be a comma-separated list of valid fields.',
+        };
+      }
+    }
+
+    if (!limit) {
+      limit = 1000;
+    }
+
+    if (limit > 1000) {
+      throw {
+        status: 404,
+        message: 'The limit value must be less than or equal to 1000.',
+      };
+    }
+    towns = towns.slice(+offset, +offset + +limit);
+
+    if (+offset >= data.length && +limit == 0) {
+      throw {
+        status: 404,
+        message:
+          'Invalid offset and limit. The limit value must be greater than 0. The offset value must be less than ' +
+          data.length,
+      };
+    } else if (+offset >= data.length) {
+      throw {
+        status: 404,
+        message:
+          'Invalid offset. The offset value must be less than ' + data.length,
+      };
+    } else if (+limit == 0) {
+      throw {
+        status: 404,
+        message: 'Invalid limit. The limit value must be greater than 0.',
+      };
+    }
+
+    if (towns.length > 0) {
+      return towns;
+    } else {
+      throw {
+        status: 404,
+        message: 'No town found.',
+      };
+    }
+  } catch (error) {
+    throw {
+      status: error?.status || 500,
+      message: error?.message || 'Internal Server Error',
+    };
+  }
+};
+
+exports.getExactTown = function (id, fields) {
+  try {
+    if (!isFinite(id)) {
+      throw {
+        status: 404,
+        message: 'Invalid town ID. The id parameter must be a number.',
+      };
+    }
+
+    const town = data.find((item) => item.id === +id);
+
+    if (fields) {
+      const fieldsArray = fields.split(',');
+      const filteredTown = {};
+
+      fieldsArray.forEach((field) => {
+        filteredTown[field] = town[field];
+      });
+
+      if (fieldsArray.some((item) => !Object.keys(data[0]).includes(item))) {
+        throw {
+          status: 404,
+          message:
+            'Invalid fields. The fields parameter must be a comma-separated list of valid fields.',
+        };
+      }
+      return filteredTown;
+    } else {
+      if (town) {
+        return town;
+      } else {
+        throw {
+          status: 404,
+          message: 'No town found.',
+        };
+      }
+    }
+  } catch (error) {
+    throw {
+      status: error?.status || 500,
+      message: error?.message || 'Internal Server Error',
+    };
+  }
+};