API for RESTful CRUD for the data

[gbowne1]

As we mostly have html forms that allow the user to store their radio log data they entered in the MongoDB/Mongoose database by clicking submit, save, edit, update, delete, etc.

I was thinking about doing some sort of API for RESTful CRUD for the application's data files, as like the data will mostly be saved by the user in JSON, CSV, XLSX, XLS format

A small amount of the data will be shown in the view in/on a table.

Something like this:

const express = require('express');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');
const app = express();

// Connect to MongoDB database
mongoose.connect('mongodb://127.0.0.1:27017/mydatabase', { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('MongoDB Connected'))
  .catch(err => console.log(err));

// Define a schema for the data
const mySchema = new mongoose.Schema({
  field1: String,
  field2: String,
  field3: Number
});

// Define a model for the data based on the schema
const MyModel = mongoose.model('MyModel', mySchema);

// Use body-parser middleware to parse incoming JSON data
app.use(bodyParser.json());

// Define API endpoints
app.get('/api/data', async (req, res) => {
  try {
    const data = await MyModel.find();
    res.json(data);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

app.post('/api/data', async (req, res) => {
  const data = new MyModel({
    field1: req.body.field1,
    field2: req.body.field2,
    field3: req.body.field3
  });

  try {
    const newData = await data.save();
    res.status(201).json(newData);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

app.patch('/api/data/:id', getUser, async (req, res) => {
  if (req.body.field1 != null) {
    res.user.field1 = req.body.field1;
  }
  if (req.body.field2 != null) {
    res.user.field2 = req.body.field2;
  }
  if (req.body.field3 != null) {
    res.user.field3 = req.body.field3;
  }
  try {
    const updatedData = await res.user.save();
    res.json(updatedData);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
});

app.delete('/api/data/:id', getUser, async (req, res) => {
  try {
    await res.user.remove();
    res.json({ message: 'Data has been deleted' });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
});

// Define middleware function to get a single user by ID
async function getUser(req, res, next) {
  let user;
  try {
    user = await MyModel.findById(req.params.id);
    if (user == null) {
      return res.status(404).json({ message: 'Cannot find data' });
    }
  } catch (err) {
    return res.status(500).json({ message: err.message });
  }

  res.user = user;
  next();
}

// Start the server
app.listen(3000, () => console.log('Server started'));

[gbowne1]

@jzunigarce

[jzunigarce]

We can add, just need define the name of route and define if the data has a specific format or will be unstructured

[gbowne1]

my first inclination is to use either JSON or CSV for the saved data coming from the forms/database.. and really either way is fine for me.

So I would think the route would be api/v1/data/ and /data/:id

I've never used app.patch and app.delete.. but that seems the logical way to do this as above.

There is one format that we will have to export and import to/from.. and that is ADIF. And its specs are here: https://www.adif.org/100/adif_100.htm

[jzunigarce]

For Rest Api we consider use the standar http verbs: get, post, put/patch and delete. Put and patch allows. edit the information, the main difference is that patch applies partial modifications while put updates the entire document. For its part, delete deletes a resource (physically or logically as appropriate)

[gbowne1]

Yeah that seems most logical.

We should take care of those random times the user might want to modify the data, all or in partial..

Also want to take care of the case where a user might want to export to share their data with others..among other things.

[jzunigarce]

For validation of data we use a middleware

[gbowne1]

yeah, easier than creating a separate utility.

[gbowne1]

My template for swllog.html