retropilot
/
retropilot-server
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

added model for drive segments, pilotauth now uses ORM

pull/4/head
AdamSBlack 2022-01-10 01:07:56 +00:00
parent 22bf9d74e0
commit 7a11f51cd8
No known key found for this signature in database
GPG Key ID: E66E51A97D150E28
3 changed files with 126 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
controllers/devices.js
View File

@ -107,6 +107,21 @@ async function getDeviceFromDongle(dongleId) {
}
return devices.dataValues;
}
// TODO combine these redundant functions into one
async function getDeviceFromSerial(serial) {
if (!serial) return null;
const devices = await orm.models.device.findOne({ where: { serial } });
if (!devices || !devices.dataValues) {
return null;
}
return devices.dataValues;
}
async function updateDevice(dongleId, data) {
if (!dongleId) return null;
return orm.models.device.update(data, { where: { dongle_id: dongleId } });
}
async function setIgnoredUploads(dongleId, isIgnored) {
await orm.models.accounts.update(
@ -245,6 +260,63 @@ async function getBootlogs(dongleId) {
return bootlogFiles;
}
async function updateOrCreateDrive(dongleId, identifier, data) {
const check = orm.models.drives.findOne({ where: { dongle_id: dongleId, identifier } });
if (check.dataValues) {
return { error: true, msg: 'DRIVE_EXISTS', drive_already_exits: true };
}
return orm.models.drives.create({
...data,
dongle_Id: dongleId,
identifier,
});
}
async function updateOrCreateDriveSegment(dongleId, identifier, segmentId, data) {
console.log(orm);
const check = orm.models.drive_segments.findOne({
where: { dongle_id: dongleId, drive_identifier: identifier },
});
if (check.dataValues) {
return { error: true, msg: 'DRIVE_EXISTS', drive_already_exits: true };
}
return orm.models.drive_segments.create({
...data,
segment_id: segmentId,
drive_identifier: identifier,
dongle_id: dongleId,
});
}
async function getDriveSegment(dongleId, driveName, segment) {
return orm.models.drive_segments.findOne({
where: {
segment_id: segment,
drive_identifier: driveName,
dongle_id: dongleId,
},
});
}
async function createDongle(dongleId, accountId, imei, serial, publicKey) {
return orm.models.device.create({
dongle_id: dongleId,
account_id: 0,
imei,
serial,
device_type: 'freon',
public_key: publicKey,
created: Date.now(),
last_ping: Date.now(),
storage_used: 0,
});
}
module.exports = {
pairDevice,
unpairDevice,
@ -257,10 +329,15 @@ module.exports = {
updateLastPing,
isUserAuthorised,
getOwnersFromDongle,
createDongle,
getDeviceFromSerial,
updateDevice,
// drive stuff, move maybe?
getDrives,
getBootlogs,
getCrashlogs,
getDriveFromidentifier,
updateOrCreateDrive,
updateOrCreateDriveSegment,
};

1
models/index.model.js
View File

@ -17,6 +17,7 @@ const modelDefiners = [
require('./athena_action_log.model'),
require('./athena_returned_data.model'),
require('./device_authorised_users.model'),
require('./drive_segments.model'),
];
for (const modelDefiner of modelDefiners) {

116
routes/api.js
View File

@ -28,6 +28,7 @@ async function dbConnect() {
dbConnect();
// DRIVE & BOOT/CRASH LOG FILE UPLOAD HANDLING
router.put('/backend/post_upload', bodyParser.raw({
inflate: true,
@ -284,51 +285,40 @@ async function upload(req, res) {
const timeSplit = driveName.split('--');
const timeString = `${timeSplit[0]} ${timeSplit[1].replace(/-/g, ':')}`;
const driveResult = await models.run(
'INSERT INTO drives (identifier, dongle_id, max_segment, duration, distance_meters, filesize, upload_complete, is_processed, drive_date, created, last_upload, is_preserved, is_deleted, is_physically_removed) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
driveName,
dongleId,
segment,
0,
0,
0,
false,
false,
Date.parse(timeString),
Date.now(),
Date.now(),
false,
false,
false,
).catch((err) => {logger.warn("303", err)})
const driveResult = await deviceController.updateOrCreateDrive(dongleId, identifier, {
max_segment: segment,
duration: 0,
distance_meters: 0,
filesize: 0,
upload_complete: false,
is_processed: false,
drive_date: Date.parse(timeString),
created: Date.now(),
last_upload: Date.now(),
is_preserved: false,
is_deleted: false,
is_physically_removed: false,
})
await models.run(
'INSERT INTO drive_segments (segment_id, drive_identifier, dongle_id, duration, distance_meters, upload_complete, is_processed, is_stalled, created) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
segment,
driveName,
dongleId,
0,
0,
false,
false,
false,
Date.now(),
).catch((err) => {logger.warn("316", err)})
await deviceController.updateOrCreateDriveSegment(dongleId, driveName, segment, {
duration: 0,
distance_meters: 0,
upload_complete: false,
is_processed: false,
is_stalled: false,
created: Date.now(),
})
logger.info(`HTTP.UPLOAD_URL created new drive #${JSON.stringify(driveResult.lastID)}`);
} else {
await models.run(
'UPDATE drives SET last_upload = ?, max_segment = ?, upload_complete = ?, is_processed = ? WHERE identifier = ? AND dongle_id = ?',
Date.now(),
Math.max(drive.max_segment, segment),
false,
false,
driveName,
dongleId,
).catch((err) => {logger.warn("328", err)})
const driveSegment = await models.get('SELECT * FROM drive_segments WHERE drive_identifier = ? AND dongle_id = ? AND segment_id = ?', driveName, dongleId, segment);
await deviceController.updateOrCreateDrive(dongleId, driveName, {
max_segment: Math.max(drive.max_segment, segment),
upload_complete: false,
is_processed: false,
last_upload: Date.now(),
})
const driveSegment = await driveController.getDriveSegment(dongleId, driveName, segment);
if (driveSegment == null) {
await models.run(
'INSERT INTO drive_segments (segment_id, drive_identifier, dongle_id, duration, distance_meters, upload_complete, is_processed, is_stalled, created) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
@ -342,15 +332,20 @@ async function upload(req, res) {
false,
Date.now(),
).catch((err) => {logger.warn("344", err)})
await deviceController.updateOrCreateDriveSegment(dongleId, driveName, segment, {
duration: 0,
distance_meters: 0,
upload_complete: false,
is_processed: false,
is_stalled: false,
created: Date.now()
})
} else {
await models.run(
'UPDATE drive_segments SET upload_complete = ?, is_stalled = ? WHERE drive_identifier = ? AND dongle_id = ? AND segment_id = ?',
false,
false,
driveName,
dongleId,
segment,
).catch((err) => {logger.warn("353", err)})
await deviceController.updateOrCreateDriveSegment(dongleId, driveName, segment, {
is_processed: false,
is_stalled: false,
})
}
logger.info(`HTTP.UPLOAD_URL updated existing drive: ${JSON.stringify(drive)}`);
@ -391,7 +386,7 @@ router.post('/v2/pilotauth/', bodyParser.urlencoded({ extended: true }), async (
return res.status(400).send('Malformed Request.');
}
const device = await models.get('SELECT * FROM devices WHERE serial = ?', serial);
const device = await deviceController.getDeviceFromSerial(serial)
if (device == null) {
logger.info(`HTTP.V2.PILOTAUTH REGISTERING NEW DEVICE (${imei1}, ${serial})`);
@ -401,20 +396,10 @@ router.post('/v2/pilotauth/', bodyParser.urlencoded({ extended: true }), async (
const dongleId = crypto.randomBytes(4).toString('hex');
const isDongleIdTaken = await models.get('SELECT * FROM devices WHERE serial = ?', serial);
if (isDongleIdTaken == null) {
await models.run(
'INSERT INTO devices (dongle_id, account_id, imei, serial, device_type, public_key, created, last_ping, storage_used) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
dongleId,
0,
imei1,
serial,
'freon',
publicKey,
Date.now(),
Date.now(),
0,
);
await deviceController.createDongle(dongleId, 0, imei1, serial, publicKey)
const newDevice = await models.get('SELECT * FROM devices WHERE dongle_id = ?', dongleId);
const newDevice = await deviceController.getDeviceFromDongle(dongleId);
logger.info(`HTTP.V2.PILOTAUTH REGISTERED NEW DEVICE: ${JSON.stringify(newDevice)}`);
return res.status(200).json({ dongle_id: newDevice.dongle_id, access_token: 'DEPRECATED-BUT-REQUIRED-FOR-07' });
@ -422,12 +407,7 @@ router.post('/v2/pilotauth/', bodyParser.urlencoded({ extended: true }), async (
}
}
await models.run(
'UPDATE devices SET last_ping = ?, public_key = ? WHERE dongle_id = ?',
Date.now(),
publicKey,
device.dongle_id,
);
await deviceController.updateDevice(device.dongle_id, {last_ping: Date.now(), public_key: publicKey})
logger.info(`HTTP.V2.PILOTAUTH REACTIVATING KNOWN DEVICE (${imei1}, ${serial}) with dongle_id ${device.dongle_id}`);
return res.status(200).json({ dongle_id: device.dongle_id, access_token: 'DEPRECATED-BUT-REQUIRED-FOR-07' });