admin/33408
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated via schema editor on 2025-08-15 05:24

Browse Source
This commit is contained in:
Flatlogic Bot 2025-08-15 05:25:29 +00:00
parent 347b5af94c
commit 422644171d
117 changed files with 9032 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -1,3 +1,8 @@
node_modules/
*/node_modules/
*/build/
**/node_modules/
**/build/
.DS_Store
.env

7
app-shell/src/_schema.json
View File

File diff suppressed because one or more lines are too long

164
backend/src/db/api/aircrafts.js
View File

@ -18,6 +18,36 @@ module.exports = class AircraftsDBApi {
registration_number: data.registration_number
||
null
,
make: data.make
||
null
,
model: data.model
||
null
,
year: data.year
||
null
,
serial_number: data.serial_number
||
null
,
engine_count: data.engine_count
||
null
,
engine_type: data.engine_type
||
null
,
@ -42,6 +72,36 @@ module.exports = class AircraftsDBApi {
registration_number: item.registration_number
||
null
,
make: item.make
||
null
,
model: item.model
||
null
,
year: item.year
||
null
,
serial_number: item.serial_number
||
null
,
engine_count: item.engine_count
||
null
,
engine_type: item.engine_type
||
null
,
importHash: item.importHash || null,
@ -66,6 +126,18 @@ module.exports = class AircraftsDBApi {
if (data.registration_number !== undefined) updatePayload.registration_number = data.registration_number;
if (data.make !== undefined) updatePayload.make = data.make;
if (data.model !== undefined) updatePayload.model = data.model;
if (data.year !== undefined) updatePayload.year = data.year;
if (data.serial_number !== undefined) updatePayload.serial_number = data.serial_number;
if (data.engine_count !== undefined) updatePayload.engine_count = data.engine_count;
if (data.engine_type !== undefined) updatePayload.engine_type = data.engine_type;
updatePayload.updatedById = currentUser.id;
await aircrafts.update(updatePayload, {transaction});
@ -172,6 +244,98 @@ module.exports = class AircraftsDBApi {
};
}
if (filter.make) {
where = {
...where,
[Op.and]: Utils.ilike(
'aircrafts',
'make',
filter.make,
),
};
}
if (filter.model) {
where = {
...where,
[Op.and]: Utils.ilike(
'aircrafts',
'model',
filter.model,
),
};
}
if (filter.serial_number) {
where = {
...where,
[Op.and]: Utils.ilike(
'aircrafts',
'serial_number',
filter.serial_number,
),
};
}
if (filter.engine_type) {
where = {
...where,
[Op.and]: Utils.ilike(
'aircrafts',
'engine_type',
filter.engine_type,
),
};
}
if (filter.yearRange) {
const [start, end] = filter.yearRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
year: {
...where.year,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
year: {
...where.year,
[Op.lte]: end,
},
};
}
}
if (filter.engine_countRange) {
const [start, end] = filter.engine_countRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
engine_count: {
...where.engine_count,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
engine_count: {
...where.engine_count,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,

19
backend/src/db/api/flights.js
View File

@ -53,6 +53,11 @@ module.exports = class FlightsDBApi {
remarks: data.remarks
||
null
,
time_recorded_for: data.time_recorded_for
||
null
,
@ -112,6 +117,11 @@ module.exports = class FlightsDBApi {
remarks: item.remarks
||
null
,
time_recorded_for: item.time_recorded_for
||
null
,
importHash: item.importHash || null,
@ -150,6 +160,8 @@ module.exports = class FlightsDBApi {
if (data.remarks !== undefined) updatePayload.remarks = data.remarks;
if (data.time_recorded_for !== undefined) updatePayload.time_recorded_for = data.time_recorded_for;
updatePayload.updatedById = currentUser.id;
await flights.update(updatePayload, {transaction});
@ -405,6 +417,13 @@ module.exports = class FlightsDBApi {
};
}
if (filter.time_recorded_for) {
where = {
...where,
time_recorded_for: filter.time_recorded_for,
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;

335
backend/src/db/api/inspection_intervals.js Normal file
View File

@ -0,0 +1,335 @@
const db = require('../models');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class Inspection_intervalsDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const inspection_intervals = await db.inspection_intervals.create(
{
id: data.id || undefined,
type: data.type
||
null
,
interval_hours: data.interval_hours
||
null
,
interval_months: data.interval_months
||
null
,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
return inspection_intervals;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const inspection_intervalsData = data.map((item, index) => ({
id: item.id || undefined,
type: item.type
||
null
,
interval_hours: item.interval_hours
||
null
,
interval_months: item.interval_months
||
null
,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const inspection_intervals = await db.inspection_intervals.bulkCreate(inspection_intervalsData, { transaction });
return inspection_intervals;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || {id: null};
const transaction = (options && options.transaction) || undefined;
const inspection_intervals = await db.inspection_intervals.findByPk(id, {}, {transaction});
const updatePayload = {};
if (data.type !== undefined) updatePayload.type = data.type;
if (data.interval_hours !== undefined) updatePayload.interval_hours = data.interval_hours;
if (data.interval_months !== undefined) updatePayload.interval_months = data.interval_months;
updatePayload.updatedById = currentUser.id;
await inspection_intervals.update(updatePayload, {transaction});
return inspection_intervals;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const inspection_intervals = await db.inspection_intervals.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of inspection_intervals) {
await record.update(
{deletedBy: currentUser.id},
{transaction}
);
}
for (const record of inspection_intervals) {
await record.destroy({transaction});
}
});
return inspection_intervals;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || {id: null};
const transaction = (options && options.transaction) || undefined;
const inspection_intervals = await db.inspection_intervals.findByPk(id, options);
await inspection_intervals.update({
deletedBy: currentUser.id
}, {
transaction,
});
await inspection_intervals.destroy({
transaction
});
return inspection_intervals;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const inspection_intervals = await db.inspection_intervals.findOne(
{ where },
{ transaction },
);
if (!inspection_intervals) {
return inspection_intervals;
}
const output = inspection_intervals.get({plain: true});
return output;
}
static async findAll(filter, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.interval_hoursRange) {
const [start, end] = filter.interval_hoursRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
interval_hours: {
...where.interval_hours,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
interval_hours: {
...where.interval_hours,
[Op.lte]: end,
},
};
}
}
if (filter.interval_monthsRange) {
const [start, end] = filter.interval_monthsRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
interval_months: {
...where.interval_months,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
interval_months: {
...where.interval_months,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true'
};
}
if (filter.type) {
where = {
...where,
type: filter.type,
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
const queryOptions = {
where,
include,
distinct: true,
order: filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.inspection_intervals.findAndCountAll(queryOptions);
return {
rows: options?.countOnly ? [] : rows,
count: count
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(query, limit, offset) {
let where = {};
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike(
'inspection_intervals',
'id',
query,
),
],
};
}
const records = await db.inspection_intervals.findAll({
attributes: [ 'id', 'id' ],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['id', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.id,
}));
}
};

36
backend/src/db/api/inspections.js
View File

@ -28,6 +28,11 @@ module.exports = class InspectionsDBApi {
type: data.type
||
null
,
performed_at: data.performed_at
||
null
,
@ -62,6 +67,11 @@ module.exports = class InspectionsDBApi {
type: item.type
||
null
,
performed_at: item.performed_at
||
null
,
importHash: item.importHash || null,
@ -90,6 +100,8 @@ module.exports = class InspectionsDBApi {
if (data.type !== undefined) updatePayload.type = data.type;
if (data.performed_at !== undefined) updatePayload.performed_at = data.performed_at;
updatePayload.updatedById = currentUser.id;
await inspections.update(updatePayload, {transaction});
@ -233,6 +245,30 @@ module.exports = class InspectionsDBApi {
}
}
if (filter.performed_atRange) {
const [start, end] = filter.performed_atRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
performed_at: {
...where.performed_at,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
performed_at: {
...where.performed_at,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,

92
backend/src/db/api/organizations.js
View File

@ -18,6 +18,26 @@ module.exports = class OrganizationsDBApi {
name: data.name
||
null
,
address: data.address
||
null
,
phone: data.phone
||
null
,
website: data.website
||
null
,
contact_email: data.contact_email
||
null
,
@ -42,6 +62,26 @@ module.exports = class OrganizationsDBApi {
name: item.name
||
null
,
address: item.address
||
null
,
phone: item.phone
||
null
,
website: item.website
||
null
,
contact_email: item.contact_email
||
null
,
importHash: item.importHash || null,
@ -66,6 +106,14 @@ module.exports = class OrganizationsDBApi {
if (data.name !== undefined) updatePayload.name = data.name;
if (data.address !== undefined) updatePayload.address = data.address;
if (data.phone !== undefined) updatePayload.phone = data.phone;
if (data.website !== undefined) updatePayload.website = data.website;
if (data.contact_email !== undefined) updatePayload.contact_email = data.contact_email;
updatePayload.updatedById = currentUser.id;
await organizations.update(updatePayload, {transaction});
@ -172,6 +220,50 @@ module.exports = class OrganizationsDBApi {
};
}
if (filter.address) {
where = {
...where,
[Op.and]: Utils.ilike(
'organizations',
'address',
filter.address,
),
};
}
if (filter.phone) {
where = {
...where,
[Op.and]: Utils.ilike(
'organizations',
'phone',
filter.phone,
),
};
}
if (filter.website) {
where = {
...where,
[Op.and]: Utils.ilike(
'organizations',
'website',
filter.website,
),
};
}
if (filter.contact_email) {
where = {
...where,
[Op.and]: Utils.ilike(
'organizations',
'contact_email',
filter.contact_email,
),
};
}
if (filter.active !== undefined) {
where = {
...where,

339
backend/src/db/api/squawk_notes.js Normal file
View File

@ -0,0 +1,339 @@
const db = require('../models');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class Squawk_notesDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const squawk_notes = await db.squawk_notes.create(
{
id: data.id || undefined,
content: data.content
||
null
,
created_at: data.created_at
||
null
,
updated_at: data.updated_at
||
null
,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
return squawk_notes;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const squawk_notesData = data.map((item, index) => ({
id: item.id || undefined,
content: item.content
||
null
,
created_at: item.created_at
||
null
,
updated_at: item.updated_at
||
null
,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const squawk_notes = await db.squawk_notes.bulkCreate(squawk_notesData, { transaction });
return squawk_notes;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || {id: null};
const transaction = (options && options.transaction) || undefined;
const squawk_notes = await db.squawk_notes.findByPk(id, {}, {transaction});
const updatePayload = {};
if (data.content !== undefined) updatePayload.content = data.content;
if (data.created_at !== undefined) updatePayload.created_at = data.created_at;
if (data.updated_at !== undefined) updatePayload.updated_at = data.updated_at;
updatePayload.updatedById = currentUser.id;
await squawk_notes.update(updatePayload, {transaction});
return squawk_notes;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const squawk_notes = await db.squawk_notes.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of squawk_notes) {
await record.update(
{deletedBy: currentUser.id},
{transaction}
);
}
for (const record of squawk_notes) {
await record.destroy({transaction});
}
});
return squawk_notes;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || {id: null};
const transaction = (options && options.transaction) || undefined;
const squawk_notes = await db.squawk_notes.findByPk(id, options);
await squawk_notes.update({
deletedBy: currentUser.id
}, {
transaction,
});
await squawk_notes.destroy({
transaction
});
return squawk_notes;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const squawk_notes = await db.squawk_notes.findOne(
{ where },
{ transaction },
);
if (!squawk_notes) {
return squawk_notes;
}
const output = squawk_notes.get({plain: true});
return output;
}
static async findAll(filter, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.content) {
where = {
...where,
[Op.and]: Utils.ilike(
'squawk_notes',
'content',
filter.content,
),
};
}
if (filter.created_atRange) {
const [start, end] = filter.created_atRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
created_at: {
...where.created_at,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
created_at: {
...where.created_at,
[Op.lte]: end,
},
};
}
}
if (filter.updated_atRange) {
const [start, end] = filter.updated_atRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
updated_at: {
...where.updated_at,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
updated_at: {
...where.updated_at,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true'
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
const queryOptions = {
where,
include,
distinct: true,
order: filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.squawk_notes.findAndCountAll(queryOptions);
return {
rows: options?.countOnly ? [] : rows,
count: count
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(query, limit, offset) {
let where = {};
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike(
'squawk_notes',
'id',
query,
),
],
};
}
const records = await db.squawk_notes.findAll({
attributes: [ 'id', 'id' ],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['id', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.id,
}));
}
};

54
backend/src/db/migrations/1755235073089.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'aircrafts',
'make',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'aircrafts',
'make',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235092122.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'aircrafts',
'model',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'aircrafts',
'model',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235099304.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'aircrafts',
'year',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'aircrafts',
'year',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235116132.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'aircrafts',
'serial_number',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'aircrafts',
'serial_number',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235129055.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'aircrafts',
'engine_count',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'aircrafts',
'engine_count',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235139703.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'aircrafts',
'engine_type',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'aircrafts',
'engine_type',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

70
backend/src/db/migrations/1755235148389.js Normal file
View File

@ -0,0 +1,70 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.createTable('inspection_intervals', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.dropTable('inspection_intervals', { transaction });
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

59
backend/src/db/migrations/1755235167753.js Normal file
View File

@ -0,0 +1,59 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'inspection_intervals',
'aircraftId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'aircrafts',
key: 'id',
},
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'inspection_intervals',
'aircraftId',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

56
backend/src/db/migrations/1755235182170.js Normal file
View File

@ -0,0 +1,56 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'inspection_intervals',
'type',
{
type: Sequelize.DataTypes.ENUM,
values: ['value'],
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'inspection_intervals',
'type',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235190221.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'inspection_intervals',
'interval_hours',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'inspection_intervals',
'interval_hours',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235200131.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'inspection_intervals',
'interval_months',
{
type: Sequelize.DataTypes.INTEGER,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'inspection_intervals',
'interval_months',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

56
backend/src/db/migrations/1755235235761.js Normal file
View File

@ -0,0 +1,56 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'flights',
'time_recorded_for',
{
type: Sequelize.DataTypes.ENUM,
values: ['value'],
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'flights',
'time_recorded_for',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235278015.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'inspections',
'performed_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'inspections',
'performed_at',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

59
backend/src/db/migrations/1755235284654.js Normal file
View File

@ -0,0 +1,59 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'inspections',
'performed_byId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'inspections',
'performed_byId',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

38
backend/src/db/migrations/1755235302058.js Normal file
View File

@ -0,0 +1,38 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235314511.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'organizations',
'address',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'organizations',
'address',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235321727.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'organizations',
'phone',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'organizations',
'phone',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

70
backend/src/db/migrations/1755235329555.js Normal file
View File

@ -0,0 +1,70 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.createTable('squawk_notes', {
id: {
type: Sequelize.DataTypes.UUID,
defaultValue: Sequelize.DataTypes.UUIDV4,
primaryKey: true,
},
createdById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
updatedById: {
type: Sequelize.DataTypes.UUID,
references: {
key: 'id',
model: 'users',
},
},
createdAt: { type: Sequelize.DataTypes.DATE },
updatedAt: { type: Sequelize.DataTypes.DATE },
deletedAt: { type: Sequelize.DataTypes.DATE },
importHash: {
type: Sequelize.DataTypes.STRING(255),
allowNull: true,
unique: true,
},
}, { transaction });
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.dropTable('squawk_notes', { transaction });
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

59
backend/src/db/migrations/1755235335413.js Normal file
View File

@ -0,0 +1,59 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'squawk_notes',
'squawkId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'squawks',
key: 'id',
},
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'squawk_notes',
'squawkId',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235341823.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'squawk_notes',
'content',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'squawk_notes',
'content',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

59
backend/src/db/migrations/1755235349373.js Normal file
View File

@ -0,0 +1,59 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'squawk_notes',
'created_byId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'squawk_notes',
'created_byId',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

59
backend/src/db/migrations/1755235356802.js Normal file
View File

@ -0,0 +1,59 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'squawk_notes',
'updated_byId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'users',
key: 'id',
},
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'squawk_notes',
'updated_byId',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235372885.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'squawk_notes',
'created_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'squawk_notes',
'created_at',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235386208.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'squawk_notes',
'updated_at',
{
type: Sequelize.DataTypes.DATE,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'squawk_notes',
'updated_at',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235397461.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'organizations',
'website',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'organizations',
'website',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

54
backend/src/db/migrations/1755235464158.js Normal file
View File

@ -0,0 +1,54 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.addColumn(
'organizations',
'contact_email',
{
type: Sequelize.DataTypes.TEXT,
},
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await queryInterface.removeColumn(
'organizations',
'contact_email',
{ transaction }
);
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

38
backend/src/db/migrations/1755235464384.js Normal file
View File

@ -0,0 +1,38 @@
module.exports = {
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async up(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
/**
* @param {QueryInterface} queryInterface
* @param {Sequelize} Sequelize
* @returns {Promise<void>}
*/
async down(queryInterface, Sequelize) {
/**
* @type {Transaction}
*/
const transaction = await queryInterface.sequelize.transaction();
try {
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
}
};

30
backend/src/db/models/aircrafts.js
View File

@ -19,6 +19,36 @@ registration_number: {
},
make: {
type: DataTypes.TEXT,
},
model: {
type: DataTypes.TEXT,
},
year: {
type: DataTypes.INTEGER,
},
serial_number: {
type: DataTypes.TEXT,
},
engine_count: {
type: DataTypes.INTEGER,
},
engine_type: {
type: DataTypes.TEXT,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,

11
backend/src/db/models/flights.js
View File

@ -54,6 +54,17 @@ remarks: {
},
time_recorded_for: {
type: DataTypes.ENUM,
values: [
"value"
],
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,

64
backend/src/db/models/inspection_intervals.js Normal file
View File

@ -0,0 +1,64 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function(sequelize, DataTypes) {
const inspection_intervals = sequelize.define(
'inspection_intervals',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
type: {
type: DataTypes.ENUM,
values: [
"value"
],
},
interval_hours: {
type: DataTypes.INTEGER,
},
interval_months: {
type: DataTypes.INTEGER,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
inspection_intervals.associate = (db) => {
db.inspection_intervals.belongsTo(db.users, {
as: 'createdBy',
});
db.inspection_intervals.belongsTo(db.users, {
as: 'updatedBy',
});
};
return inspection_intervals;
};

5
backend/src/db/models/inspections.js
View File

@ -41,6 +41,11 @@ type: {
},
performed_at: {
type: DataTypes.DATE,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,

20
backend/src/db/models/organizations.js
View File

@ -19,6 +19,26 @@ name: {
},
address: {
type: DataTypes.TEXT,
},
phone: {
type: DataTypes.TEXT,
},
website: {
type: DataTypes.TEXT,
},
contact_email: {
type: DataTypes.TEXT,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,

58
backend/src/db/models/squawk_notes.js Normal file
View File

@ -0,0 +1,58 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function(sequelize, DataTypes) {
const squawk_notes = sequelize.define(
'squawk_notes',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
content: {
type: DataTypes.TEXT,
},
created_at: {
type: DataTypes.DATE,
},
updated_at: {
type: DataTypes.DATE,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
squawk_notes.associate = (db) => {
db.squawk_notes.belongsTo(db.users, {
as: 'createdBy',
});
db.squawk_notes.belongsTo(db.users, {
as: 'updatedBy',
});
};
return squawk_notes;
};

71
backend/src/db/seeders/20250815051908.js Normal file
View File

@ -0,0 +1,71 @@
const { v4: uuid } = require("uuid");
const db = require('../models');
const Sequelize = require('sequelize');
const config = require("../../config");
module.exports = {
/**
* @param{import("sequelize").QueryInterface} queryInterface
* @return {Promise<void>}
*/
async up(queryInterface) {
const createdAt = new Date();
const updatedAt = new Date();
/** @type {Map<string, string>} */
const idMap = new Map();
/**
* @param {string} key
* @return {string}
*/
function getId(key) {
if (idMap.has(key)) {
return idMap.get(key);
}
const id = uuid();
idMap.set(key, id);
return id;
}
/**
* @param {string} name
*/
function createPermissions(name) {
return [
{ id: getId(`CREATE_${name.toUpperCase()}`), createdAt, updatedAt, name: `CREATE_${name.toUpperCase()}` },
{ id: getId(`READ_${name.toUpperCase()}`), createdAt, updatedAt, name: `READ_${name.toUpperCase()}` },
{ id: getId(`UPDATE_${name.toUpperCase()}`), createdAt, updatedAt, name: `UPDATE_${name.toUpperCase()}` },
{ id: getId(`DELETE_${name.toUpperCase()}`), createdAt, updatedAt, name: `DELETE_${name.toUpperCase()}` }
];
}
const entities = [
"inspection_intervals",
];
const createdPermissions = entities.flatMap(createPermissions);
// Add permissions to database
await queryInterface.bulkInsert("permissions", createdPermissions);
// Get permissions ids
const permissionsIds = createdPermissions.map((p) => p.id);
// Get admin role
const adminRole = await db.roles.findOne({
where: {name: config.roles.admin}
});
if (adminRole) {
// Add permissions to admin role if it exists
await adminRole.addPermissions(permissionsIds);
}
},
down: async (queryInterface, Sequelize) => {
await queryInterface.bulkDelete("permissions", entities.flatMap(createPermissions));
}
};

71
backend/src/db/seeders/20250815052209.js Normal file
View File

@ -0,0 +1,71 @@
const { v4: uuid } = require("uuid");
const db = require('../models');
const Sequelize = require('sequelize');
const config = require("../../config");
module.exports = {
/**
* @param{import("sequelize").QueryInterface} queryInterface
* @return {Promise<void>}
*/
async up(queryInterface) {
const createdAt = new Date();
const updatedAt = new Date();
/** @type {Map<string, string>} */
const idMap = new Map();
/**
* @param {string} key
* @return {string}
*/
function getId(key) {
if (idMap.has(key)) {
return idMap.get(key);
}
const id = uuid();
idMap.set(key, id);
return id;
}
/**
* @param {string} name
*/
function createPermissions(name) {
return [
{ id: getId(`CREATE_${name.toUpperCase()}`), createdAt, updatedAt, name: `CREATE_${name.toUpperCase()}` },
{ id: getId(`READ_${name.toUpperCase()}`), createdAt, updatedAt, name: `READ_${name.toUpperCase()}` },
{ id: getId(`UPDATE_${name.toUpperCase()}`), createdAt, updatedAt, name: `UPDATE_${name.toUpperCase()}` },
{ id: getId(`DELETE_${name.toUpperCase()}`), createdAt, updatedAt, name: `DELETE_${name.toUpperCase()}` }
];
}
const entities = [
"squawk_notes",
];
const createdPermissions = entities.flatMap(createPermissions);
// Add permissions to database
await queryInterface.bulkInsert("permissions", createdPermissions);
// Get permissions ids
const permissionsIds = createdPermissions.map((p) => p.id);
// Get admin role
const adminRole = await db.roles.findOne({
where: {name: config.roles.admin}
});
if (adminRole) {
// Add permissions to admin role if it exists
await adminRole.addPermissions(permissionsIds);
}
},
down: async (queryInterface, Sequelize) => {
await queryInterface.bulkDelete("permissions", entities.flatMap(createPermissions));
}
};

8
backend/src/index.js
View File

@ -34,6 +34,10 @@ const rolesRoutes = require('./routes/roles');
const permissionsRoutes = require('./routes/permissions');
const inspection_intervalsRoutes = require('./routes/inspection_intervals');
const squawk_notesRoutes = require('./routes/squawk_notes');
const getBaseUrl = (url) => {
if (!url) return '';
return url.endsWith('/api') ? url.slice(0, -4) : url;
@ -106,6 +110,10 @@ app.use('/api/roles', passport.authenticate('jwt', {session: false}), rolesRoute
app.use('/api/permissions', passport.authenticate('jwt', {session: false}), permissionsRoutes);
app.use('/api/inspection_intervals', passport.authenticate('jwt', {session: false}), inspection_intervalsRoutes);
app.use('/api/squawk_notes', passport.authenticate('jwt', {session: false}), squawk_notesRoutes);
app.use('/api/contact-form', contactFormRoutes);
app.use(

22
backend/src/routes/aircrafts.js
View File

@ -20,6 +20,25 @@ const { parse } = require('json2csv');
* registration_number:
* type: string
* default: registration_number
* make:
* type: string
* default: make
* model:
* type: string
* default: model
* serial_number:
* type: string
* default: serial_number
* engine_type:
* type: string
* default: engine_type
* year:
* type: integer
* format: int64
* engine_count:
* type: integer
* format: int64
*/
@ -276,7 +295,8 @@ router.get('/', wrapAsync(async (req, res) => {
req.query, { currentUser }
);
if (filetype && filetype === 'csv') {
const fields = ['id','registration_number',
const fields = ['id','registration_number','make','model','serial_number','engine_type',
'year','engine_count',
];
const opts = { fields };

1
backend/src/routes/flights.js
View File

@ -37,6 +37,7 @@ const { parse } = require('json2csv');
* type: integer
* format: int64
*
*/
/**

415
backend/src/routes/inspection_intervals.js Normal file
View File

@ -0,0 +1,415 @@
const express = require('express');
const Inspection_intervalsService = require('../services/inspection_intervals');
const Inspection_intervalsDBApi = require('../db/api/inspection_intervals');
const wrapAsync = require('../helpers').wrapAsync;
const router = express.Router();
const { parse } = require('json2csv');
/**
* @swagger
* components:
* schemas:
* Inspection_intervals:
* type: object
* properties:
* interval_hours:
* type: integer
* format: int64
* interval_months:
* type: integer
* format: int64
*
*/
/**
* @swagger
* tags:
* name: Inspection_intervals
* description: The Inspection_intervals managing API
*/
/**
* @swagger
* /api/inspection_intervals:
* post:
* security:
* - bearerAuth: []
* tags: [Inspection_intervals]
* summary: Add new item
* description: Add new item
* requestBody:
* required: true
* content:
* application/json:
* schema:
* properties:
* data:
* description: Data of the updated item
* type: object
* $ref: "#/components/schemas/Inspection_intervals"
* responses:
* 200:
* description: The item was successfully added
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Inspection_intervals"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 405:
* description: Invalid input data
* 500:
* description: Some server error
*/
router.post('/', wrapAsync(async (req, res) => {
const referer = req.headers.referer || `${req.protocol}://${req.hostname}${req.originalUrl}`;
const link = new URL(referer);
await Inspection_intervalsService.create(req.body.data, req.currentUser, true, link.host);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/budgets/bulk-import:
* post:
* security:
* - bearerAuth: []
* tags: [Inspection_intervals]
* summary: Bulk import items
* description: Bulk import items
* requestBody:
* required: true
* content:
* application/json:
* schema:
* properties:
* data:
* description: Data of the updated items
* type: array
* items:
* $ref: "#/components/schemas/Inspection_intervals"
* responses:
* 200:
* description: The items were successfully imported
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Inspection_intervals"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 405:
* description: Invalid input data
* 500:
* description: Some server error
*
*/
router.post('/bulk-import', wrapAsync(async (req, res) => {
const referer = req.headers.referer || `${req.protocol}://${req.hostname}${req.originalUrl}`;
const link = new URL(referer);
await Inspection_intervalsService.bulkImport(req, res, true, link.host);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/inspection_intervals/{id}:
* put:
* security:
* - bearerAuth: []
* tags: [Inspection_intervals]
* summary: Update the data of the selected item
* description: Update the data of the selected item
* parameters:
* - in: path
* name: id
* description: Item ID to update
* required: true
* schema:
* type: string
* requestBody:
* description: Set new item data
* required: true
* content:
* application/json:
* schema:
* properties:
* id:
* description: ID of the updated item
* type: string
* data:
* description: Data of the updated item
* type: object
* $ref: "#/components/schemas/Inspection_intervals"
* required:
* - id
* responses:
* 200:
* description: The item data was successfully updated
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Inspection_intervals"
* 400:
* description: Invalid ID supplied
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Item not found
* 500:
* description: Some server error
*/
router.put('/:id', wrapAsync(async (req, res) => {
await Inspection_intervalsService.update(req.body.data, req.body.id, req.currentUser);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/inspection_intervals/{id}:
* delete:
* security:
* - bearerAuth: []
* tags: [Inspection_intervals]
* summary: Delete the selected item
* description: Delete the selected item
* parameters:
* - in: path
* name: id
* description: Item ID to delete
* required: true
* schema:
* type: string
* responses:
* 200:
* description: The item was successfully deleted
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Inspection_intervals"
* 400:
* description: Invalid ID supplied
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Item not found
* 500:
* description: Some server error
*/
router.delete('/:id', wrapAsync(async (req, res) => {
await Inspection_intervalsService.remove(req.params.id, req.currentUser);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/inspection_intervals/deleteByIds:
* post:
* security:
* - bearerAuth: []
* tags: [Inspection_intervals]
* summary: Delete the selected item list
* description: Delete the selected item list
* requestBody:
* required: true
* content:
* application/json:
* schema:
* properties:
* ids:
* description: IDs of the updated items
* type: array
* responses:
* 200:
* description: The items was successfully deleted
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Inspection_intervals"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Items not found
* 500:
* description: Some server error
*/
router.post('/deleteByIds', wrapAsync(async (req, res) => {
await Inspection_intervalsService.deleteByIds(req.body.data, req.currentUser);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/inspection_intervals:
* get:
* security:
* - bearerAuth: []
* tags: [Inspection_intervals]
* summary: Get all inspection_intervals
* description: Get all inspection_intervals
* responses:
* 200:
* description: Inspection_intervals list successfully received
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Inspection_intervals"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Data not found
* 500:
* description: Some server error
*/
router.get('/', wrapAsync(async (req, res) => {
const filetype = req.query.filetype
const currentUser = req.currentUser;
const payload = await Inspection_intervalsDBApi.findAll(
req.query, { currentUser }
);
if (filetype && filetype === 'csv') {
const fields = ['id',
'interval_hours','interval_months',
];
const opts = { fields };
try {
const csv = parse(payload.rows, opts);
res.status(200).attachment(csv);
res.send(csv)
} catch (err) {
console.error(err);
}
} else {
res.status(200).send(payload);
}
}));
/**
* @swagger
* /api/inspection_intervals/count:
* get:
* security:
* - bearerAuth: []
* tags: [Inspection_intervals]
* summary: Count all inspection_intervals
* description: Count all inspection_intervals
* responses:
* 200:
* description: Inspection_intervals count successfully received
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Inspection_intervals"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Data not found
* 500:
* description: Some server error
*/
router.get('/count', wrapAsync(async (req, res) => {
const currentUser = req.currentUser;
const payload = await Inspection_intervalsDBApi.findAll(
req.query,
null,
{ countOnly: true, currentUser }
);
res.status(200).send(payload);
}));
/**
* @swagger
* /api/inspection_intervals/autocomplete:
* get:
* security:
* - bearerAuth: []
* tags: [Inspection_intervals]
* summary: Find all inspection_intervals that match search criteria
* description: Find all inspection_intervals that match search criteria
* responses:
* 200:
* description: Inspection_intervals list successfully received
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Inspection_intervals"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Data not found
* 500:
* description: Some server error
*/
router.get('/autocomplete', async (req, res) => {
const payload = await Inspection_intervalsDBApi.findAllAutocomplete(
req.query.query,
req.query.limit,
req.query.offset,
);
res.status(200).send(payload);
});
/**
* @swagger
* /api/inspection_intervals/{id}:
* get:
* security:
* - bearerAuth: []
* tags: [Inspection_intervals]
* summary: Get selected item
* description: Get selected item
* parameters:
* - in: path
* name: id
* description: ID of item to get
* required: true
* schema:
* type: string
* responses:
* 200:
* description: Selected item successfully received
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Inspection_intervals"
* 400:
* description: Invalid ID supplied
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Item not found
* 500:
* description: Some server error
*/
router.get('/:id', wrapAsync(async (req, res) => {
const payload = await Inspection_intervalsDBApi.findBy(
{ id: req.params.id },
);
res.status(200).send(payload);
}));
router.use('/', require('../helpers').commonErrorHandler);
module.exports = router;

2
backend/src/routes/inspections.js
View File

@ -275,7 +275,7 @@ router.get('/', wrapAsync(async (req, res) => {
if (filetype && filetype === 'csv') {
const fields = ['id',
'last_performed','due_date',
'last_performed','due_date','performed_at',
];
const opts = { fields };
try {

14
backend/src/routes/organizations.js
View File

@ -20,6 +20,18 @@ const { parse } = require('json2csv');
* name:
* type: string
* default: name
* address:
* type: string
* default: address
* phone:
* type: string
* default: phone
* website:
* type: string
* default: website
* contact_email:
* type: string
* default: contact_email
*/
@ -276,7 +288,7 @@ router.get('/', wrapAsync(async (req, res) => {
req.query, { currentUser }
);
if (filetype && filetype === 'csv') {
const fields = ['id','name',
const fields = ['id','name','address','phone','website','contact_email',
];
const opts = { fields };

411
backend/src/routes/squawk_notes.js Normal file
View File

@ -0,0 +1,411 @@
const express = require('express');
const Squawk_notesService = require('../services/squawk_notes');
const Squawk_notesDBApi = require('../db/api/squawk_notes');
const wrapAsync = require('../helpers').wrapAsync;
const router = express.Router();
const { parse } = require('json2csv');
/**
* @swagger
* components:
* schemas:
* Squawk_notes:
* type: object
* properties:
* content:
* type: string
* default: content
*/
/**
* @swagger
* tags:
* name: Squawk_notes
* description: The Squawk_notes managing API
*/
/**
* @swagger
* /api/squawk_notes:
* post:
* security:
* - bearerAuth: []
* tags: [Squawk_notes]
* summary: Add new item
* description: Add new item
* requestBody:
* required: true
* content:
* application/json:
* schema:
* properties:
* data:
* description: Data of the updated item
* type: object
* $ref: "#/components/schemas/Squawk_notes"
* responses:
* 200:
* description: The item was successfully added
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Squawk_notes"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 405:
* description: Invalid input data
* 500:
* description: Some server error
*/
router.post('/', wrapAsync(async (req, res) => {
const referer = req.headers.referer || `${req.protocol}://${req.hostname}${req.originalUrl}`;
const link = new URL(referer);
await Squawk_notesService.create(req.body.data, req.currentUser, true, link.host);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/budgets/bulk-import:
* post:
* security:
* - bearerAuth: []
* tags: [Squawk_notes]
* summary: Bulk import items
* description: Bulk import items
* requestBody:
* required: true
* content:
* application/json:
* schema:
* properties:
* data:
* description: Data of the updated items
* type: array
* items:
* $ref: "#/components/schemas/Squawk_notes"
* responses:
* 200:
* description: The items were successfully imported
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Squawk_notes"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 405:
* description: Invalid input data
* 500:
* description: Some server error
*
*/
router.post('/bulk-import', wrapAsync(async (req, res) => {
const referer = req.headers.referer || `${req.protocol}://${req.hostname}${req.originalUrl}`;
const link = new URL(referer);
await Squawk_notesService.bulkImport(req, res, true, link.host);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/squawk_notes/{id}:
* put:
* security:
* - bearerAuth: []
* tags: [Squawk_notes]
* summary: Update the data of the selected item
* description: Update the data of the selected item
* parameters:
* - in: path
* name: id
* description: Item ID to update
* required: true
* schema:
* type: string
* requestBody:
* description: Set new item data
* required: true
* content:
* application/json:
* schema:
* properties:
* id:
* description: ID of the updated item
* type: string
* data:
* description: Data of the updated item
* type: object
* $ref: "#/components/schemas/Squawk_notes"
* required:
* - id
* responses:
* 200:
* description: The item data was successfully updated
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Squawk_notes"
* 400:
* description: Invalid ID supplied
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Item not found
* 500:
* description: Some server error
*/
router.put('/:id', wrapAsync(async (req, res) => {
await Squawk_notesService.update(req.body.data, req.body.id, req.currentUser);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/squawk_notes/{id}:
* delete:
* security:
* - bearerAuth: []
* tags: [Squawk_notes]
* summary: Delete the selected item
* description: Delete the selected item
* parameters:
* - in: path
* name: id
* description: Item ID to delete
* required: true
* schema:
* type: string
* responses:
* 200:
* description: The item was successfully deleted
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Squawk_notes"
* 400:
* description: Invalid ID supplied
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Item not found
* 500:
* description: Some server error
*/
router.delete('/:id', wrapAsync(async (req, res) => {
await Squawk_notesService.remove(req.params.id, req.currentUser);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/squawk_notes/deleteByIds:
* post:
* security:
* - bearerAuth: []
* tags: [Squawk_notes]
* summary: Delete the selected item list
* description: Delete the selected item list
* requestBody:
* required: true
* content:
* application/json:
* schema:
* properties:
* ids:
* description: IDs of the updated items
* type: array
* responses:
* 200:
* description: The items was successfully deleted
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Squawk_notes"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Items not found
* 500:
* description: Some server error
*/
router.post('/deleteByIds', wrapAsync(async (req, res) => {
await Squawk_notesService.deleteByIds(req.body.data, req.currentUser);
const payload = true;
res.status(200).send(payload);
}));
/**
* @swagger
* /api/squawk_notes:
* get:
* security:
* - bearerAuth: []
* tags: [Squawk_notes]
* summary: Get all squawk_notes
* description: Get all squawk_notes
* responses:
* 200:
* description: Squawk_notes list successfully received
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Squawk_notes"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Data not found
* 500:
* description: Some server error
*/
router.get('/', wrapAsync(async (req, res) => {
const filetype = req.query.filetype
const currentUser = req.currentUser;
const payload = await Squawk_notesDBApi.findAll(
req.query, { currentUser }
);
if (filetype && filetype === 'csv') {
const fields = ['id','content',
'created_at','updated_at',
];
const opts = { fields };
try {
const csv = parse(payload.rows, opts);
res.status(200).attachment(csv);
res.send(csv)
} catch (err) {
console.error(err);
}
} else {
res.status(200).send(payload);
}
}));
/**
* @swagger
* /api/squawk_notes/count:
* get:
* security:
* - bearerAuth: []
* tags: [Squawk_notes]
* summary: Count all squawk_notes
* description: Count all squawk_notes
* responses:
* 200:
* description: Squawk_notes count successfully received
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Squawk_notes"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Data not found
* 500:
* description: Some server error
*/
router.get('/count', wrapAsync(async (req, res) => {
const currentUser = req.currentUser;
const payload = await Squawk_notesDBApi.findAll(
req.query,
null,
{ countOnly: true, currentUser }
);
res.status(200).send(payload);
}));
/**
* @swagger
* /api/squawk_notes/autocomplete:
* get:
* security:
* - bearerAuth: []
* tags: [Squawk_notes]
* summary: Find all squawk_notes that match search criteria
* description: Find all squawk_notes that match search criteria
* responses:
* 200:
* description: Squawk_notes list successfully received
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Squawk_notes"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Data not found
* 500:
* description: Some server error
*/
router.get('/autocomplete', async (req, res) => {
const payload = await Squawk_notesDBApi.findAllAutocomplete(
req.query.query,
req.query.limit,
req.query.offset,
);
res.status(200).send(payload);
});
/**
* @swagger
* /api/squawk_notes/{id}:
* get:
* security:
* - bearerAuth: []
* tags: [Squawk_notes]
* summary: Get selected item
* description: Get selected item
* parameters:
* - in: path
* name: id
* description: ID of item to get
* required: true
* schema:
* type: string
* responses:
* 200:
* description: Selected item successfully received
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Squawk_notes"
* 400:
* description: Invalid ID supplied
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Item not found
* 500:
* description: Some server error
*/
router.get('/:id', wrapAsync(async (req, res) => {
const payload = await Squawk_notesDBApi.findBy(
{ id: req.params.id },
);
res.status(200).send(payload);
}));
router.use('/', require('../helpers').commonErrorHandler);
module.exports = router;

131
backend/src/services/inspection_intervals.js Normal file
View File

@ -0,0 +1,131 @@
const db = require('../db/models');
const Inspection_intervalsDBApi = require('../db/api/inspection_intervals');
const processFile = require("../middlewares/upload");
const ValidationError = require('./notifications/errors/validation');
const csv = require('csv-parser');
const axios = require('axios');
const config = require('../config');
const stream = require('stream');
module.exports = class Inspection_intervalsService {
static async create(data, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await Inspection_intervalsDBApi.create(
data,
{
currentUser,
transaction,
},
);
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
};
static async bulkImport(req, res, sendInvitationEmails = true, host) {
const transaction = await db.sequelize.transaction();
try {
await processFile(req, res);
const bufferStream = new stream.PassThrough();
const results = [];
await bufferStream.end(Buffer.from(req.file.buffer, "utf-8")); // convert Buffer to Stream
await new Promise((resolve, reject) => {
bufferStream
.pipe(csv())
.on('data', (data) => results.push(data))
.on('end', async () => {
console.log('CSV results', results);
resolve();
})
.on('error', (error) => reject(error));
})
await Inspection_intervalsDBApi.bulkImport(results, {
transaction,
ignoreDuplicates: true,
validate: true,
currentUser: req.currentUser
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
static async update(data, id, currentUser) {
const transaction = await db.sequelize.transaction();
try {
let inspection_intervals = await Inspection_intervalsDBApi.findBy(
{id},
{transaction},
);
if (!inspection_intervals) {
throw new ValidationError(
'inspection_intervalsNotFound',
);
}
const updatedInspection_intervals = await Inspection_intervalsDBApi.update(
id,
data,
{
currentUser,
transaction,
},
);
await transaction.commit();
return updatedInspection_intervals;
} catch (error) {
await transaction.rollback();
throw error;
}
};
static async deleteByIds(ids, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await Inspection_intervalsDBApi.deleteByIds(ids, {
currentUser,
transaction,
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
static async remove(id, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await Inspection_intervalsDBApi.remove(
id,
{
currentUser,
transaction,
},
);
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
};

38
backend/src/services/search.js
View File

@ -59,6 +59,14 @@ module.exports = class SearchService {
"registration_number",
"make",
"model",
"serial_number",
"engine_type",
],
"flights": [
@ -75,6 +83,14 @@ module.exports = class SearchService {
"name",
"address",
"phone",
"website",
"contact_email",
],
"squawks": [
@ -91,9 +107,23 @@ module.exports = class SearchService {
],
"squawk_notes": [
"content",
],
};
const columnsInt = {
"aircrafts": [
"year",
"engine_count",
],
"flights": [
"start_tach_time",
@ -104,6 +134,14 @@ module.exports = class SearchService {
],
"inspection_intervals": [
"interval_hours",
"interval_months",
],
};
let allFoundRecords = [];

131
backend/src/services/squawk_notes.js Normal file
View File

@ -0,0 +1,131 @@
const db = require('../db/models');
const Squawk_notesDBApi = require('../db/api/squawk_notes');
const processFile = require("../middlewares/upload");
const ValidationError = require('./notifications/errors/validation');
const csv = require('csv-parser');
const axios = require('axios');
const config = require('../config');
const stream = require('stream');
module.exports = class Squawk_notesService {
static async create(data, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await Squawk_notesDBApi.create(
data,
{
currentUser,
transaction,
},
);
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
};
static async bulkImport(req, res, sendInvitationEmails = true, host) {
const transaction = await db.sequelize.transaction();
try {
await processFile(req, res);
const bufferStream = new stream.PassThrough();
const results = [];
await bufferStream.end(Buffer.from(req.file.buffer, "utf-8")); // convert Buffer to Stream
await new Promise((resolve, reject) => {
bufferStream
.pipe(csv())
.on('data', (data) => results.push(data))
.on('end', async () => {
console.log('CSV results', results);
resolve();
})
.on('error', (error) => reject(error));
})
await Squawk_notesDBApi.bulkImport(results, {
transaction,
ignoreDuplicates: true,
validate: true,
currentUser: req.currentUser
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
static async update(data, id, currentUser) {
const transaction = await db.sequelize.transaction();
try {
let squawk_notes = await Squawk_notesDBApi.findBy(
{id},
{transaction},
);
if (!squawk_notes) {
throw new ValidationError(
'squawk_notesNotFound',
);
}
const updatedSquawk_notes = await Squawk_notesDBApi.update(
id,
data,
{
currentUser,
transaction,
},
);
await transaction.commit();
return updatedSquawk_notes;
} catch (error) {
await transaction.rollback();
throw error;
}
};
static async deleteByIds(ids, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await Squawk_notesDBApi.deleteByIds(ids, {
currentUser,
transaction,
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
static async remove(id, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await Squawk_notesDBApi.remove(
id,
{
currentUser,
transaction,
},
);
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
};

1
frontend/json/runtimeError.json Normal file
View File

@ -0,0 +1 @@
{}

54
frontend/src/components/Aircrafts/CardAircrafts.tsx
View File

@ -88,6 +88,60 @@ const CardAircrafts = ({
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Make</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.make }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Model</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.model }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Year</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.year }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Serial number</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.serial_number }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Engine count</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.engine_count }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Engine type</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.engine_type }
</div>
</dd>
</div>
</dl>
</li>
))}

30
frontend/src/components/Aircrafts/ListAircrafts.tsx
View File

@ -50,6 +50,36 @@ const ListAircrafts = ({ aircrafts, loading, onDelete, currentPage, numPages, on
<p className={'line-clamp-2'}>{ item.technicians }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Make</p>
<p className={'line-clamp-2'}>{ item.make }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Model</p>
<p className={'line-clamp-2'}>{ item.model }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Year</p>
<p className={'line-clamp-2'}>{ item.year }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Serial number</p>
<p className={'line-clamp-2'}>{ item.serial_number }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Engine count</p>
<p className={'line-clamp-2'}>{ item.engine_count }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Engine type</p>
<p className={'line-clamp-2'}>{ item.engine_type }</p>
</div>
</Link>
<ListActionsPopover
onDelete={onDelete}

80
frontend/src/components/Aircrafts/configureAircraftsCols.tsx
View File

@ -73,6 +73,86 @@ export const loadColumns = async (
},
{
field: 'make',
headerName: 'Make',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'model',
headerName: 'Model',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'year',
headerName: 'Year',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
type: 'number',
},
{
field: 'serial_number',
headerName: 'Serial number',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'engine_count',
headerName: 'Engine count',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
type: 'number',
},
{
field: 'engine_type',
headerName: 'Engine type',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'actions',
type: 'actions',

9
frontend/src/components/Flights/CardFlights.tsx
View File

@ -142,6 +142,15 @@ const CardFlights = ({
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Time recorded for</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.time_recorded_for }
</div>
</dd>
</div>
</dl>
</li>
))}

5
frontend/src/components/Flights/ListFlights.tsx
View File

@ -80,6 +80,11 @@ const ListFlights = ({ flights, loading, onDelete, currentPage, numPages, onPage
<p className={'line-clamp-2'}>{ item.remarks }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Time recorded for</p>
<p className={'line-clamp-2'}>{ item.time_recorded_for }</p>
</div>
</Link>
<ListActionsPopover
onDelete={onDelete}

19
frontend/src/components/Flights/configureFlightsCols.tsx
View File

@ -160,6 +160,25 @@ export const loadColumns = async (
},
{
field: 'time_recorded_for',
headerName: 'Time recorded for',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
type: 'singleSelect',
valueOptions: [
"value" ,
],
},
{
field: 'actions',
type: 'actions',

120
frontend/src/components/Inspection_intervals/CardInspection_intervals.tsx Normal file
View File

@ -0,0 +1,120 @@
import React from 'react';
import ListActionsPopover from '../ListActionsPopover';
import { useAppSelector } from '../../stores/hooks';
import dataFormatter from '../../helpers/dataFormatter';
import { Pagination } from '../Pagination';
import LoadingSpinner from "../LoadingSpinner";
import Link from 'next/link';
type Props = {
inspection_intervals: any[];
loading: boolean;
onDelete: (id: string) => void;
currentPage: number;
numPages: number;
onPageChange: (page: number) => void;
};
const CardInspection_intervals = ({
inspection_intervals,
loading,
onDelete,
currentPage,
numPages,
onPageChange,
}: Props) => {
const asideScrollbarsStyle = useAppSelector(
(state) => state.style.asideScrollbarsStyle,
);
const bgColor = useAppSelector((state) => state.style.cardsColor);
const darkMode = useAppSelector((state) => state.style.darkMode);
const corners = useAppSelector((state) => state.style.corners);
const focusRing = useAppSelector((state) => state.style.focusRingColor);
return (
<div className={'p-4'}>
{loading && <LoadingSpinner />}
<ul
role='list'
className='grid grid-cols-1 gap-x-6 gap-y-8 lg:grid-cols-3 2xl:grid-cols-4 xl:gap-x-8'
>
{!loading && inspection_intervals.map((item, index) => (
<li
key={item.id}
className={`overflow-hidden ${corners !== 'rounded-full'? corners : 'rounded-3xl'} border ${focusRing} border-gray-200 dark:border-dark-700 ${
darkMode ? 'aside-scrollbars-[slate]' : asideScrollbarsStyle
}`}
>
<Link href={`/inspection_intervals/inspection_intervals-view/?id=${item.id}`} className='text-lg font-bold leading-6 line-clamp-1'>
{item.id}
</Link>
<div className='ml-auto'>
<ListActionsPopover
onDelete={onDelete}
itemId={item.id}
pathEdit={`/inspection_intervals/inspection_intervals-edit/?id=${item.id}`}
pathView={`/inspection_intervals/inspection_intervals-view/?id=${item.id}`}
hasUpdatePermission={true}
/>
</div>
</div>
<dl className='divide-y dark:divide-dark-700 px-6 py-4 text-sm leading-6 h-64 overflow-y-auto'>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Aircraft</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ dataFormatter.aircraftsOneListFormatter(item.aircraft) }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Type</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.type }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Interval hours</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.interval_hours }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Interval months</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.interval_months }
</div>
</dd>
</div>
</dl>
</li>
))}
{!loading && inspection_intervals.length === 0 && (
<div className='col-span-full flex items-center justify-center h-40'>
<p className=''>No data to display</p>
</div>
)}
</ul>
<div className={'flex items-center justify-center my-6'}>
<Pagination
currentPage={currentPage}
numPages={numPages}
setCurrentPage={onPageChange}
/>
</div>
</div>
);
};
export default CardInspection_intervals;

87
frontend/src/components/Inspection_intervals/ListInspection_intervals.tsx Normal file
View File

@ -0,0 +1,87 @@
import React from 'react';
import CardBox from '../CardBox';
import dataFormatter from '../../helpers/dataFormatter';
import ListActionsPopover from "../ListActionsPopover";
import {useAppSelector} from "../../stores/hooks";
import {Pagination} from "../Pagination";
import LoadingSpinner from "../LoadingSpinner";
import Link from 'next/link';
type Props = {
inspection_intervals: any[];
loading: boolean;
onDelete: (id: string) => void;
currentPage: number;
numPages: number;
onPageChange: (page: number) => void;
};
const ListInspection_intervals = ({ inspection_intervals, loading, onDelete, currentPage, numPages, onPageChange }: Props) => {
const corners = useAppSelector((state) => state.style.corners);
const bgColor = useAppSelector((state) => state.style.cardsColor);
return (
<>
<div className='relative overflow-x-auto p-4 space-y-4'>
{loading && <LoadingSpinner />}
{!loading && inspection_intervals.map((item) => (
<div key={item.id}>
<CardBox hasTable isList className={'rounded shadow-none'}>
<div className={`flex rounded dark:bg-dark-900 border items-center overflow-hidden`}>
<Link
href={`/inspection_intervals/inspection_intervals-view/?id=${item.id}`}
className={
'flex-1 px-4 py-6 h-24 flex divide-x-2 divide-stone-300 items-center overflow-hidden dark:divide-dark-700 overflow-x-auto'
}
>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Aircraft</p>
<p className={'line-clamp-2'}>{ dataFormatter.aircraftsOneListFormatter(item.aircraft) }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Type</p>
<p className={'line-clamp-2'}>{ item.type }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Interval hours</p>
<p className={'line-clamp-2'}>{ item.interval_hours }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Interval months</p>
<p className={'line-clamp-2'}>{ item.interval_months }</p>
</div>
</Link>
<ListActionsPopover
onDelete={onDelete}
itemId={item.id}
pathEdit={`/inspection_intervals/inspection_intervals-edit/?id=${item.id}`}
pathView={`/inspection_intervals/inspection_intervals-view/?id=${item.id}`}
hasUpdatePermission={true}
/>
</div>
</CardBox>
</div>
))}
{!loading && inspection_intervals.length === 0 && (
<div className='col-span-full flex items-center justify-center h-40'>
<p className=''>No data to display</p>
</div>
)}
</div>
<div className={'flex items-center justify-center my-6'}>
<Pagination
currentPage={currentPage}
numPages={numPages}
setCurrentPage={onPageChange}
/>
</div>
</>
)
};
export default ListInspection_intervals

441
frontend/src/components/Inspection_intervals/TableInspection_intervals.tsx Normal file
View File

@ -0,0 +1,441 @@
import React, { useEffect, useState, useMemo } from 'react'
import { createPortal } from 'react-dom';
import { ToastContainer, toast } from 'react-toastify';
import BaseButton from '../BaseButton'
import CardBoxModal from '../CardBoxModal'
import CardBox from "../CardBox";
import { fetch, update, deleteItem, setRefetch, deleteItemsByIds } from '../../stores/inspection_intervals/inspection_intervalsSlice'
import { useAppDispatch, useAppSelector } from '../../stores/hooks'
import { useRouter } from 'next/router'
import { Field, Form, Formik } from "formik";
import {
DataGrid,
GridColDef,
} from '@mui/x-data-grid';
import {loadColumns} from "./configureInspection_intervalsCols";
import _ from 'lodash';
import dataFormatter from '../../helpers/dataFormatter'
import {dataGridStyles} from "../../styles";
import axios from 'axios';
const perPage = 10;
const TableSampleInspection_intervals = ({ filterItems, setFilterItems, filters, showGrid }) => {
const notify = (type, msg) => toast( msg, {type, position: "bottom-center"});
const dispatch = useAppDispatch();
const router = useRouter();
const pagesList = [];
const [id, setId] = useState(null);
const [currentPage, setCurrentPage] = useState(0);
const [filterRequest, setFilterRequest] = React.useState('');
const [columns, setColumns] = useState<GridColDef[]>([]);
const [selectedRows, setSelectedRows] = useState([]);
const [sortModel, setSortModel] = useState([
{
field: '',
sort: 'desc',
},
]);
const { inspection_intervals, loading, count, notify: inspection_intervalsNotify, refetch } = useAppSelector((state) => state.inspection_intervals)
const { currentUser } = useAppSelector((state) => state.auth);
const focusRing = useAppSelector((state) => state.style.focusRingColor);
const bgColor = useAppSelector((state) => state.style.bgLayoutColor);
const corners = useAppSelector((state) => state.style.corners);
const numPages = Math.floor(count / perPage) === 0 ? 1 : Math.ceil(count / perPage);
for (let i = 0; i < numPages; i++) {
pagesList.push(i);
}
const loadData = async (page = currentPage, request = filterRequest) => {
if (page !== currentPage) setCurrentPage(page);
if (request !== filterRequest) setFilterRequest(request);
const { sort, field } = sortModel[0];
const query = `?page=${page}&limit=${perPage}${request}&sort=${sort}&field=${field}`;
dispatch(fetch({ limit: perPage, page, query }));
};
useEffect(() => {
if (inspection_intervalsNotify.showNotification) {
notify(inspection_intervalsNotify.typeNotification, inspection_intervalsNotify.textNotification);
}
}, [inspection_intervalsNotify.showNotification]);
useEffect(() => {
if (!currentUser) return;
loadData();
}, [sortModel, currentUser]);
useEffect(() => {
if (refetch) {
loadData(0);
dispatch(setRefetch(false));
}
}, [refetch, dispatch]);
const [isModalInfoActive, setIsModalInfoActive] = useState(false)
const [isModalTrashActive, setIsModalTrashActive] = useState(false)
const handleModalAction = () => {
setIsModalInfoActive(false)
setIsModalTrashActive(false)
}
const handleDeleteModalAction = (id: string) => {
setId(id)
setIsModalTrashActive(true)
}
const handleDeleteAction = async () => {
if (id) {
await dispatch(deleteItem(id));
await loadData(0);
setIsModalTrashActive(false);
}
};
const generateFilterRequests = useMemo(() => {
let request = '&';
filterItems.forEach((item) => {
const isRangeFilter = filters.find(
(filter) =>
filter.title === item.fields.selectedField &&
(filter.number || filter.date),
);
if (isRangeFilter) {
const from = item.fields.filterValueFrom;
const to = item.fields.filterValueTo;
if (from) {
request += `${item.fields.selectedField}Range=${from}&`;
}
if (to) {
request += `${item.fields.selectedField}Range=${to}&`;
}
} else {
const value = item.fields.filterValue;
if (value) {
request += `${item.fields.selectedField}=${value}&`;
}
}
});
return request;
}, [filterItems, filters]);
const deleteFilter = (value) => {
const newItems = filterItems.filter((item) => item.id !== value);
if (newItems.length) {
setFilterItems(newItems);
} else {
loadData(0, '');
setFilterItems(newItems);
}
};
const handleSubmit = () => {
loadData(0, generateFilterRequests);
};
const handleChange = (id) => (e) => {
const value = e.target.value;
const name = e.target.name;
setFilterItems(
filterItems.map((item) => {
if (item.id !== id) return item;
if (name === 'selectedField') return { id, fields: { [name]: value } };
return { id, fields: { ...item.fields, [name]: value } }
}),
);
};
const handleReset = () => {
setFilterItems([]);
loadData(0, '');
};
const onPageChange = (page: number) => {
loadData(page);
setCurrentPage(page);
};
useEffect(() => {
loadColumns(handleDeleteModalAction, `inspection_intervals`).then((newCols) =>
setColumns(newCols),
);
}, []);
const handleTableSubmit = async (id: string, data) => {
if (!_.isEmpty(data)) {
await dispatch(update({ id, data }))
.unwrap()
.then((res) => res)
.catch((err) => {
throw new Error(err);
});
}
};
const onDeleteRows = async (selectedRows) => {
await dispatch(deleteItemsByIds(selectedRows));
await loadData(0);
};
const controlClasses =
'w-full py-2 px-2 my-2 border-gray-700 rounded dark:placeholder-gray-400 ' +
` ${bgColor} ${focusRing} ${corners} ` +
'dark:bg-slate-800 border';
const dataGrid = (
<div className='relative overflow-x-auto'>
<DataGrid
autoHeight
rowHeight={64}
sx={dataGridStyles}
className={'datagrid--table'}
getRowClassName={() => `datagrid--row`}
rows={inspection_intervals ?? []}
columns={columns}
initialState={{
pagination: {
paginationModel: {
pageSize: 10,
},
},
}}
disableRowSelectionOnClick
onProcessRowUpdateError={(params) => {
console.log('Error', params);
}}
processRowUpdate={async (newRow, oldRow) => {
const data = dataFormatter.dataGridEditFormatter(newRow);
try {
await handleTableSubmit(newRow.id, data);
return newRow;
} catch {
return oldRow;
}
}}
sortingMode={'server'}
checkboxSelection
onRowSelectionModelChange={(ids) => {
setSelectedRows(ids)
}}
onSortModelChange={(params) => {
params.length
? setSortModel(params)
: setSortModel([{ field: '', sort: 'desc' }]);
}}
rowCount={count}
pageSizeOptions={[10]}
paginationMode={'server'}
loading={loading}
onPaginationModelChange={(params) => {
onPageChange(params.page);
}}
/>
</div>
)
return (
<>
{filterItems && Array.isArray( filterItems ) && filterItems.length ?
<CardBox>
<Formik
initialValues={{
checkboxes: ['lorem'],
switches: ['lorem'],
radio: 'lorem',
}}
onSubmit={() => null}
>
<Form>
<>
{filterItems && filterItems.map((filterItem) => {
return (
<div key={filterItem.id} className="flex mb-4">
<div className="flex flex-col w-full mr-3">
<div className="text-gray-500 font-bold">Filter</div>
<Field
className={controlClasses}
name='selectedField'
id='selectedField'
component='select'
value={filterItem?.fields?.selectedField || ''}
onChange={handleChange(filterItem.id)}
>
{filters.map((selectOption) => (
<option
key={selectOption.title}
value={`${selectOption.title}`}
>
{selectOption.label}
</option>
))}
</Field>
</div>
{filters.find((filter) =>
filter.title === filterItem?.fields?.selectedField
)?.type === 'enum' ? (
<div className="flex flex-col w-full mr-3">
<div className="text-gray-500 font-bold">
Value
</div>
<Field
className={controlClasses}
name="filterValue"
id='filterValue'
component="select"
value={filterItem?.fields?.filterValue || ''}
onChange={handleChange(filterItem.id)}
>
<option value="">Select Value</option>
{filters.find((filter) =>
filter.title === filterItem?.fields?.selectedField
)?.options?.map((option) => (
<option key={option} value={option}>
{option}
</option>
))}
</Field>
</div>
) : filters.find((filter) =>
filter.title === filterItem?.fields?.selectedField
)?.number ? (
<div className="flex flex-row w-full mr-3">
<div className="flex flex-col w-full mr-3">
<div className="text-gray-500 font-bold">From</div>
<Field
className={controlClasses}
name='filterValueFrom'
placeholder='From'
id='filterValueFrom'
value={filterItem?.fields?.filterValueFrom || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
<div className="flex flex-col w-full">
<div className="text-gray-500 font-bold">To</div>
<Field
className={controlClasses}
name='filterValueTo'
placeholder='to'
id='filterValueTo'
value={filterItem?.fields?.filterValueTo || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
</div>
) : filters.find(
(filter) =>
filter.title ===
filterItem?.fields?.selectedField
)?.date ? (
<div className='flex flex-row w-full mr-3'>
<div className='flex flex-col w-full mr-3'>
<div className='text-gray-500 font-bold'>
From
</div>
<Field
className={controlClasses}
name='filterValueFrom'
placeholder='From'
id='filterValueFrom'
type='datetime-local'
value={filterItem?.fields?.filterValueFrom || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
<div className='flex flex-col w-full'>
<div className='text-gray-500 font-bold'>To</div>
<Field
className={controlClasses}
name='filterValueTo'
placeholder='to'
id='filterValueTo'
type='datetime-local'
value={filterItem?.fields?.filterValueTo || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
</div>
) : (
<div className="flex flex-col w-full mr-3">
<div className="text-gray-500 font-bold">Contains</div>
<Field
className={controlClasses}
name='filterValue'
placeholder='Contained'
id='filterValue'
value={filterItem?.fields?.filterValue || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
)}
<div className="flex flex-col">
<div className="text-gray-500 font-bold">Action</div>
<BaseButton
className="my-2"
type='reset'
color='danger'
label='Delete'
onClick={() => {
deleteFilter(filterItem.id)
}}
/>
</div>
</div>
)
})}
<div className="flex">
<BaseButton
className="my-2 mr-3"
color="success"
label='Apply'
onClick={handleSubmit}
/>
<BaseButton
className="my-2"
color='info'
label='Cancel'
onClick={handleReset}
/>
</div>
</>
</Form>
</Formik>
</CardBox> : null
}
<CardBoxModal
title="Please confirm"
buttonColor="info"
buttonLabel={loading ? 'Deleting...' : 'Confirm'}
isActive={isModalTrashActive}
onConfirm={handleDeleteAction}
onCancel={handleModalAction}
>
<p>Are you sure you want to delete this item?</p>
</CardBoxModal>
{dataGrid}
{selectedRows.length > 0 &&
createPortal(
<BaseButton
className='me-4'
color='danger'
label={`Delete ${selectedRows.length === 1 ? 'Row' : 'Rows'}`}
onClick={() => onDeleteRows(selectedRows)}
/>,
document.getElementById('delete-rows-button'),
)}
<ToastContainer />
</>
)
}
export default TableSampleInspection_intervals

119
frontend/src/components/Inspection_intervals/configureInspection_intervalsCols.tsx Normal file
View File

@ -0,0 +1,119 @@
import React from 'react';
import BaseIcon from '../BaseIcon';
import { mdiEye, mdiTrashCan, mdiPencilOutline } from '@mdi/js';
import axios from 'axios';
import {
GridActionsCellItem,
GridRowParams,
GridValueGetterParams,
} from '@mui/x-data-grid';
import dataFormatter from '../../helpers/dataFormatter'
import DataGridMultiSelect from "../DataGridMultiSelect";
import ListActionsPopover from '../ListActionsPopover';
type Params = (id: string) => void;
export const loadColumns = async (
onDelete: Params,
entityName: string,
) => {
async function callOptionsApi(entityName: string) {
try {
const data = await axios(`/${entityName}/autocomplete?limit=100`);
return data.data;
} catch (error) {
console.log(error);
return [];
}
}
return [
{
field: 'aircraft',
headerName: 'Aircraft',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
sortable: false,
type: 'singleSelect',
getOptionValue: (value: any) => value?.id,
getOptionLabel: (value: any) => value?.label,
valueOptions: await callOptionsApi('aircrafts'),
valueGetter: (params: GridValueGetterParams) =>
params?.value?.id ?? params?.value,
},
{
field: 'type',
headerName: 'Type',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
type: 'singleSelect',
valueOptions: [
"value" ,
],
},
{
field: 'interval_hours',
headerName: 'Interval hours',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
type: 'number',
},
{
field: 'interval_months',
headerName: 'Interval months',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
type: 'number',
},
{
field: 'actions',
type: 'actions',
minWidth: 30,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
getActions: (params: GridRowParams) => {
return [
<div key={params?.row?.id}>
<ListActionsPopover
onDelete={onDelete}
itemId={params?.row?.id}
pathEdit={`/inspection_intervals/inspection_intervals-edit/?id=${params?.row?.id}`}
pathView={`/inspection_intervals/inspection_intervals-view/?id=${params?.row?.id}`}
hasUpdatePermission={true}
/>
</div>,
]
},
},
];
};

18
frontend/src/components/Inspections/CardInspections.tsx
View File

@ -97,6 +97,24 @@ const CardInspections = ({
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Performed at</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ dataFormatter.dateTimeFormatter(item.performed_at) }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Performed_by</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ dataFormatter.usersOneListFormatter(item.performed_by) }
</div>
</dd>
</div>
</dl>
</li>
))}

10
frontend/src/components/Inspections/ListInspections.tsx
View File

@ -55,6 +55,16 @@ const ListInspections = ({ inspections, loading, onDelete, currentPage, numPages
<p className={'line-clamp-2'}>{ item.type }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Performed at</p>
<p className={'line-clamp-2'}>{ dataFormatter.dateTimeFormatter(item.performed_at) }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Performed_by</p>
<p className={'line-clamp-2'}>{ dataFormatter.usersOneListFormatter(item.performed_by) }</p>
</div>
</Link>
<ListActionsPopover
onDelete={onDelete}

36
frontend/src/components/Inspections/configureInspectionsCols.tsx
View File

@ -92,6 +92,42 @@ export const loadColumns = async (
},
{
field: 'performed_at',
headerName: 'Performed at',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
type: 'dateTime',
valueGetter: (params: GridValueGetterParams) =>
new Date(params.row.performed_at),
},
{
field: 'performed_by',
headerName: 'Performed_by',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
sortable: false,
type: 'singleSelect',
getOptionValue: (value: any) => value?.id,
getOptionLabel: (value: any) => value?.label,
valueOptions: await callOptionsApi('users'),
valueGetter: (params: GridValueGetterParams) =>
params?.value?.id ?? params?.value,
},
{
field: 'actions',
type: 'actions',

45
frontend/src/components/Organizations/CardOrganizations.tsx
View File

@ -79,6 +79,51 @@ const CardOrganizations = ({
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Avatar</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.avatar }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Address</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.address }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Phone</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.phone }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Website</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.website }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Contact email</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.contact_email }
</div>
</dd>
</div>
</dl>
</li>
))}

25
frontend/src/components/Organizations/ListOrganizations.tsx
View File

@ -45,6 +45,31 @@ const ListOrganizations = ({ organizations, loading, onDelete, currentPage, numP
<p className={'line-clamp-2'}>{ item.members }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Avatar</p>
<p className={'line-clamp-2'}>{ item.avatar }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Address</p>
<p className={'line-clamp-2'}>{ item.address }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Phone</p>
<p className={'line-clamp-2'}>{ item.phone }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Website</p>
<p className={'line-clamp-2'}>{ item.website }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Contact email</p>
<p className={'line-clamp-2'}>{ item.contact_email }</p>
</div>
</Link>
<ListActionsPopover
onDelete={onDelete}

65
frontend/src/components/Organizations/configureOrganizationsCols.tsx
View File

@ -53,6 +53,71 @@ export const loadColumns = async (
},
{
field: 'avatar',
headerName: 'Avatar',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'address',
headerName: 'Address',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'phone',
headerName: 'Phone',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'website',
headerName: 'Website',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'contact_email',
headerName: 'Contact email',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'actions',
type: 'actions',

138
frontend/src/components/Squawk_notes/CardSquawk_notes.tsx Normal file
View File

@ -0,0 +1,138 @@
import React from 'react';
import ListActionsPopover from '../ListActionsPopover';
import { useAppSelector } from '../../stores/hooks';
import dataFormatter from '../../helpers/dataFormatter';
import { Pagination } from '../Pagination';
import LoadingSpinner from "../LoadingSpinner";
import Link from 'next/link';
type Props = {
squawk_notes: any[];
loading: boolean;
onDelete: (id: string) => void;
currentPage: number;
numPages: number;
onPageChange: (page: number) => void;
};
const CardSquawk_notes = ({
squawk_notes,
loading,
onDelete,
currentPage,
numPages,
onPageChange,
}: Props) => {
const asideScrollbarsStyle = useAppSelector(
(state) => state.style.asideScrollbarsStyle,
);
const bgColor = useAppSelector((state) => state.style.cardsColor);
const darkMode = useAppSelector((state) => state.style.darkMode);
const corners = useAppSelector((state) => state.style.corners);
const focusRing = useAppSelector((state) => state.style.focusRingColor);
return (
<div className={'p-4'}>
{loading && <LoadingSpinner />}
<ul
role='list'
className='grid grid-cols-1 gap-x-6 gap-y-8 lg:grid-cols-3 2xl:grid-cols-4 xl:gap-x-8'
>
{!loading && squawk_notes.map((item, index) => (
<li
key={item.id}
className={`overflow-hidden ${corners !== 'rounded-full'? corners : 'rounded-3xl'} border ${focusRing} border-gray-200 dark:border-dark-700 ${
darkMode ? 'aside-scrollbars-[slate]' : asideScrollbarsStyle
}`}
>
<Link href={`/squawk_notes/squawk_notes-view/?id=${item.id}`} className='text-lg font-bold leading-6 line-clamp-1'>
{item.id}
</Link>
<div className='ml-auto'>
<ListActionsPopover
onDelete={onDelete}
itemId={item.id}
pathEdit={`/squawk_notes/squawk_notes-edit/?id=${item.id}`}
pathView={`/squawk_notes/squawk_notes-view/?id=${item.id}`}
hasUpdatePermission={true}
/>
</div>
</div>
<dl className='divide-y dark:divide-dark-700 px-6 py-4 text-sm leading-6 h-64 overflow-y-auto'>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Squawk</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ dataFormatter.squawksOneListFormatter(item.squawk) }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Content</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ item.content }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Created_by</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ dataFormatter.usersOneListFormatter(item.created_by) }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Updated_by</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ dataFormatter.usersOneListFormatter(item.updated_by) }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Created at</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ dataFormatter.dateTimeFormatter(item.created_at) }
</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className='text-gray-500 dark:text-dark-600'>Updated at</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{ dataFormatter.dateTimeFormatter(item.updated_at) }
</div>
</dd>
</div>
</dl>
</li>
))}
{!loading && squawk_notes.length === 0 && (
<div className='col-span-full flex items-center justify-center h-40'>
<p className=''>No data to display</p>
</div>
)}
</ul>
<div className={'flex items-center justify-center my-6'}>
<Pagination
currentPage={currentPage}
numPages={numPages}
setCurrentPage={onPageChange}
/>
</div>
</div>
);
};
export default CardSquawk_notes;

97
frontend/src/components/Squawk_notes/ListSquawk_notes.tsx Normal file
View File

@ -0,0 +1,97 @@
import React from 'react';
import CardBox from '../CardBox';
import dataFormatter from '../../helpers/dataFormatter';
import ListActionsPopover from "../ListActionsPopover";
import {useAppSelector} from "../../stores/hooks";
import {Pagination} from "../Pagination";
import LoadingSpinner from "../LoadingSpinner";
import Link from 'next/link';
type Props = {
squawk_notes: any[];
loading: boolean;
onDelete: (id: string) => void;
currentPage: number;
numPages: number;
onPageChange: (page: number) => void;
};
const ListSquawk_notes = ({ squawk_notes, loading, onDelete, currentPage, numPages, onPageChange }: Props) => {
const corners = useAppSelector((state) => state.style.corners);
const bgColor = useAppSelector((state) => state.style.cardsColor);
return (
<>
<div className='relative overflow-x-auto p-4 space-y-4'>
{loading && <LoadingSpinner />}
{!loading && squawk_notes.map((item) => (
<div key={item.id}>
<CardBox hasTable isList className={'rounded shadow-none'}>
<div className={`flex rounded dark:bg-dark-900 border items-center overflow-hidden`}>
<Link
href={`/squawk_notes/squawk_notes-view/?id=${item.id}`}
className={
'flex-1 px-4 py-6 h-24 flex divide-x-2 divide-stone-300 items-center overflow-hidden dark:divide-dark-700 overflow-x-auto'
}
>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Squawk</p>
<p className={'line-clamp-2'}>{ dataFormatter.squawksOneListFormatter(item.squawk) }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Content</p>
<p className={'line-clamp-2'}>{ item.content }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Created_by</p>
<p className={'line-clamp-2'}>{ dataFormatter.usersOneListFormatter(item.created_by) }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Updated_by</p>
<p className={'line-clamp-2'}>{ dataFormatter.usersOneListFormatter(item.updated_by) }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Created at</p>
<p className={'line-clamp-2'}>{ dataFormatter.dateTimeFormatter(item.created_at) }</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500'}>Updated at</p>
<p className={'line-clamp-2'}>{ dataFormatter.dateTimeFormatter(item.updated_at) }</p>
</div>
</Link>
<ListActionsPopover
onDelete={onDelete}
itemId={item.id}
pathEdit={`/squawk_notes/squawk_notes-edit/?id=${item.id}`}
pathView={`/squawk_notes/squawk_notes-view/?id=${item.id}`}
hasUpdatePermission={true}
/>
</div>
</CardBox>
</div>
))}
{!loading && squawk_notes.length === 0 && (
<div className='col-span-full flex items-center justify-center h-40'>
<p className=''>No data to display</p>
</div>
)}
</div>
<div className={'flex items-center justify-center my-6'}>
<Pagination
currentPage={currentPage}
numPages={numPages}
setCurrentPage={onPageChange}
/>
</div>
</>
)
};
export default ListSquawk_notes

441
frontend/src/components/Squawk_notes/TableSquawk_notes.tsx Normal file
View File

@ -0,0 +1,441 @@
import React, { useEffect, useState, useMemo } from 'react'
import { createPortal } from 'react-dom';
import { ToastContainer, toast } from 'react-toastify';
import BaseButton from '../BaseButton'
import CardBoxModal from '../CardBoxModal'
import CardBox from "../CardBox";
import { fetch, update, deleteItem, setRefetch, deleteItemsByIds } from '../../stores/squawk_notes/squawk_notesSlice'
import { useAppDispatch, useAppSelector } from '../../stores/hooks'
import { useRouter } from 'next/router'
import { Field, Form, Formik } from "formik";
import {
DataGrid,
GridColDef,
} from '@mui/x-data-grid';
import {loadColumns} from "./configureSquawk_notesCols";
import _ from 'lodash';
import dataFormatter from '../../helpers/dataFormatter'
import {dataGridStyles} from "../../styles";
import axios from 'axios';
const perPage = 10;
const TableSampleSquawk_notes = ({ filterItems, setFilterItems, filters, showGrid }) => {
const notify = (type, msg) => toast( msg, {type, position: "bottom-center"});
const dispatch = useAppDispatch();
const router = useRouter();
const pagesList = [];
const [id, setId] = useState(null);
const [currentPage, setCurrentPage] = useState(0);
const [filterRequest, setFilterRequest] = React.useState('');
const [columns, setColumns] = useState<GridColDef[]>([]);
const [selectedRows, setSelectedRows] = useState([]);
const [sortModel, setSortModel] = useState([
{
field: '',
sort: 'desc',
},
]);
const { squawk_notes, loading, count, notify: squawk_notesNotify, refetch } = useAppSelector((state) => state.squawk_notes)
const { currentUser } = useAppSelector((state) => state.auth);
const focusRing = useAppSelector((state) => state.style.focusRingColor);
const bgColor = useAppSelector((state) => state.style.bgLayoutColor);
const corners = useAppSelector((state) => state.style.corners);
const numPages = Math.floor(count / perPage) === 0 ? 1 : Math.ceil(count / perPage);
for (let i = 0; i < numPages; i++) {
pagesList.push(i);
}
const loadData = async (page = currentPage, request = filterRequest) => {
if (page !== currentPage) setCurrentPage(page);
if (request !== filterRequest) setFilterRequest(request);
const { sort, field } = sortModel[0];
const query = `?page=${page}&limit=${perPage}${request}&sort=${sort}&field=${field}`;
dispatch(fetch({ limit: perPage, page, query }));
};
useEffect(() => {
if (squawk_notesNotify.showNotification) {
notify(squawk_notesNotify.typeNotification, squawk_notesNotify.textNotification);
}
}, [squawk_notesNotify.showNotification]);
useEffect(() => {
if (!currentUser) return;
loadData();
}, [sortModel, currentUser]);
useEffect(() => {
if (refetch) {
loadData(0);
dispatch(setRefetch(false));
}
}, [refetch, dispatch]);
const [isModalInfoActive, setIsModalInfoActive] = useState(false)
const [isModalTrashActive, setIsModalTrashActive] = useState(false)
const handleModalAction = () => {
setIsModalInfoActive(false)
setIsModalTrashActive(false)
}
const handleDeleteModalAction = (id: string) => {
setId(id)
setIsModalTrashActive(true)
}
const handleDeleteAction = async () => {
if (id) {
await dispatch(deleteItem(id));
await loadData(0);
setIsModalTrashActive(false);
}
};
const generateFilterRequests = useMemo(() => {
let request = '&';
filterItems.forEach((item) => {
const isRangeFilter = filters.find(
(filter) =>
filter.title === item.fields.selectedField &&
(filter.number || filter.date),
);
if (isRangeFilter) {
const from = item.fields.filterValueFrom;
const to = item.fields.filterValueTo;
if (from) {
request += `${item.fields.selectedField}Range=${from}&`;
}
if (to) {
request += `${item.fields.selectedField}Range=${to}&`;
}
} else {
const value = item.fields.filterValue;
if (value) {
request += `${item.fields.selectedField}=${value}&`;
}
}
});
return request;
}, [filterItems, filters]);
const deleteFilter = (value) => {
const newItems = filterItems.filter((item) => item.id !== value);
if (newItems.length) {
setFilterItems(newItems);
} else {
loadData(0, '');
setFilterItems(newItems);
}
};
const handleSubmit = () => {
loadData(0, generateFilterRequests);
};
const handleChange = (id) => (e) => {
const value = e.target.value;
const name = e.target.name;
setFilterItems(
filterItems.map((item) => {
if (item.id !== id) return item;
if (name === 'selectedField') return { id, fields: { [name]: value } };
return { id, fields: { ...item.fields, [name]: value } }
}),
);
};
const handleReset = () => {
setFilterItems([]);
loadData(0, '');
};
const onPageChange = (page: number) => {
loadData(page);
setCurrentPage(page);
};
useEffect(() => {
loadColumns(handleDeleteModalAction, `squawk_notes`).then((newCols) =>
setColumns(newCols),
);
}, []);
const handleTableSubmit = async (id: string, data) => {
if (!_.isEmpty(data)) {
await dispatch(update({ id, data }))
.unwrap()
.then((res) => res)
.catch((err) => {
throw new Error(err);
});
}
};
const onDeleteRows = async (selectedRows) => {
await dispatch(deleteItemsByIds(selectedRows));
await loadData(0);
};
const controlClasses =
'w-full py-2 px-2 my-2 border-gray-700 rounded dark:placeholder-gray-400 ' +
` ${bgColor} ${focusRing} ${corners} ` +
'dark:bg-slate-800 border';
const dataGrid = (
<div className='relative overflow-x-auto'>
<DataGrid
autoHeight
rowHeight={64}
sx={dataGridStyles}
className={'datagrid--table'}
getRowClassName={() => `datagrid--row`}
rows={squawk_notes ?? []}
columns={columns}
initialState={{
pagination: {
paginationModel: {
pageSize: 10,
},
},
}}
disableRowSelectionOnClick
onProcessRowUpdateError={(params) => {
console.log('Error', params);
}}
processRowUpdate={async (newRow, oldRow) => {
const data = dataFormatter.dataGridEditFormatter(newRow);
try {
await handleTableSubmit(newRow.id, data);
return newRow;
} catch {
return oldRow;
}
}}
sortingMode={'server'}
checkboxSelection
onRowSelectionModelChange={(ids) => {
setSelectedRows(ids)
}}
onSortModelChange={(params) => {
params.length
? setSortModel(params)
: setSortModel([{ field: '', sort: 'desc' }]);
}}
rowCount={count}
pageSizeOptions={[10]}
paginationMode={'server'}
loading={loading}
onPaginationModelChange={(params) => {
onPageChange(params.page);
}}
/>
</div>
)
return (
<>
{filterItems && Array.isArray( filterItems ) && filterItems.length ?
<CardBox>
<Formik
initialValues={{
checkboxes: ['lorem'],
switches: ['lorem'],
radio: 'lorem',
}}
onSubmit={() => null}
>
<Form>
<>
{filterItems && filterItems.map((filterItem) => {
return (
<div key={filterItem.id} className="flex mb-4">
<div className="flex flex-col w-full mr-3">
<div className="text-gray-500 font-bold">Filter</div>
<Field
className={controlClasses}
name='selectedField'
id='selectedField'
component='select'
value={filterItem?.fields?.selectedField || ''}
onChange={handleChange(filterItem.id)}
>
{filters.map((selectOption) => (
<option
key={selectOption.title}
value={`${selectOption.title}`}
>
{selectOption.label}
</option>
))}
</Field>
</div>
{filters.find((filter) =>
filter.title === filterItem?.fields?.selectedField
)?.type === 'enum' ? (
<div className="flex flex-col w-full mr-3">
<div className="text-gray-500 font-bold">
Value
</div>
<Field
className={controlClasses}
name="filterValue"
id='filterValue'
component="select"
value={filterItem?.fields?.filterValue || ''}
onChange={handleChange(filterItem.id)}
>
<option value="">Select Value</option>
{filters.find((filter) =>
filter.title === filterItem?.fields?.selectedField
)?.options?.map((option) => (
<option key={option} value={option}>
{option}
</option>
))}
</Field>
</div>
) : filters.find((filter) =>
filter.title === filterItem?.fields?.selectedField
)?.number ? (
<div className="flex flex-row w-full mr-3">
<div className="flex flex-col w-full mr-3">
<div className="text-gray-500 font-bold">From</div>
<Field
className={controlClasses}
name='filterValueFrom'
placeholder='From'
id='filterValueFrom'
value={filterItem?.fields?.filterValueFrom || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
<div className="flex flex-col w-full">
<div className="text-gray-500 font-bold">To</div>
<Field
className={controlClasses}
name='filterValueTo'
placeholder='to'
id='filterValueTo'
value={filterItem?.fields?.filterValueTo || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
</div>
) : filters.find(
(filter) =>
filter.title ===
filterItem?.fields?.selectedField
)?.date ? (
<div className='flex flex-row w-full mr-3'>
<div className='flex flex-col w-full mr-3'>
<div className='text-gray-500 font-bold'>
From
</div>
<Field
className={controlClasses}
name='filterValueFrom'
placeholder='From'
id='filterValueFrom'
type='datetime-local'
value={filterItem?.fields?.filterValueFrom || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
<div className='flex flex-col w-full'>
<div className='text-gray-500 font-bold'>To</div>
<Field
className={controlClasses}
name='filterValueTo'
placeholder='to'
id='filterValueTo'
type='datetime-local'
value={filterItem?.fields?.filterValueTo || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
</div>
) : (
<div className="flex flex-col w-full mr-3">
<div className="text-gray-500 font-bold">Contains</div>
<Field
className={controlClasses}
name='filterValue'
placeholder='Contained'
id='filterValue'
value={filterItem?.fields?.filterValue || ''}
onChange={handleChange(filterItem.id)}
/>
</div>
)}
<div className="flex flex-col">
<div className="text-gray-500 font-bold">Action</div>
<BaseButton
className="my-2"
type='reset'
color='danger'
label='Delete'
onClick={() => {
deleteFilter(filterItem.id)
}}
/>
</div>
</div>
)
})}
<div className="flex">
<BaseButton
className="my-2 mr-3"
color="success"
label='Apply'
onClick={handleSubmit}
/>
<BaseButton
className="my-2"
color='info'
label='Cancel'
onClick={handleReset}
/>
</div>
</>
</Form>
</Formik>
</CardBox> : null
}
<CardBoxModal
title="Please confirm"
buttonColor="info"
buttonLabel={loading ? 'Deleting...' : 'Confirm'}
isActive={isModalTrashActive}
onConfirm={handleDeleteAction}
onCancel={handleModalAction}
>
<p>Are you sure you want to delete this item?</p>
</CardBoxModal>
{dataGrid}
{selectedRows.length > 0 &&
createPortal(
<BaseButton
className='me-4'
color='danger'
label={`Delete ${selectedRows.length === 1 ? 'Row' : 'Rows'}`}
onClick={() => onDeleteRows(selectedRows)}
/>,
document.getElementById('delete-rows-button'),
)}
<ToastContainer />
</>
)
}
export default TableSampleSquawk_notes

157
frontend/src/components/Squawk_notes/configureSquawk_notesCols.tsx Normal file
View File

@ -0,0 +1,157 @@
import React from 'react';
import BaseIcon from '../BaseIcon';
import { mdiEye, mdiTrashCan, mdiPencilOutline } from '@mdi/js';
import axios from 'axios';
import {
GridActionsCellItem,
GridRowParams,
GridValueGetterParams,
} from '@mui/x-data-grid';
import dataFormatter from '../../helpers/dataFormatter'
import DataGridMultiSelect from "../DataGridMultiSelect";
import ListActionsPopover from '../ListActionsPopover';
type Params = (id: string) => void;
export const loadColumns = async (
onDelete: Params,
entityName: string,
) => {
async function callOptionsApi(entityName: string) {
try {
const data = await axios(`/${entityName}/autocomplete?limit=100`);
return data.data;
} catch (error) {
console.log(error);
return [];
}
}
return [
{
field: 'squawk',
headerName: 'Squawk',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
sortable: false,
type: 'singleSelect',
getOptionValue: (value: any) => value?.id,
getOptionLabel: (value: any) => value?.label,
valueOptions: await callOptionsApi('squawks'),
valueGetter: (params: GridValueGetterParams) =>
params?.value?.id ?? params?.value,
},
{
field: 'content',
headerName: 'Content',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
},
{
field: 'created_by',
headerName: 'Created_by',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
sortable: false,
type: 'singleSelect',
getOptionValue: (value: any) => value?.id,
getOptionLabel: (value: any) => value?.label,
valueOptions: await callOptionsApi('users'),
valueGetter: (params: GridValueGetterParams) =>
params?.value?.id ?? params?.value,
},
{
field: 'updated_by',
headerName: 'Updated_by',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
sortable: false,
type: 'singleSelect',
getOptionValue: (value: any) => value?.id,
getOptionLabel: (value: any) => value?.label,
valueOptions: await callOptionsApi('users'),
valueGetter: (params: GridValueGetterParams) =>
params?.value?.id ?? params?.value,
},
{
field: 'created_at',
headerName: 'Created at',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
type: 'dateTime',
valueGetter: (params: GridValueGetterParams) =>
new Date(params.row.created_at),
},
{
field: 'updated_at',
headerName: 'Updated at',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: true,
type: 'dateTime',
valueGetter: (params: GridValueGetterParams) =>
new Date(params.row.updated_at),
},
{
field: 'actions',
type: 'actions',
minWidth: 30,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
getActions: (params: GridRowParams) => {
return [
<div key={params?.row?.id}>
<ListActionsPopover
onDelete={onDelete}
itemId={params?.row?.id}
pathEdit={`/squawk_notes/squawk_notes-edit/?id=${params?.row?.id}`}
pathView={`/squawk_notes/squawk_notes-view/?id=${params?.row?.id}`}
hasUpdatePermission={true}
/>
</div>,
]
},
},
];
};

16
frontend/src/menuAside.ts
View File

@ -64,6 +64,22 @@ const menuAside: MenuAsideItem[] = [
icon: 'mdiFileDocumentEditOutline' in icon ? icon['mdiFileDocumentEditOutline' as keyof typeof icon] : icon.mdiTable ?? icon.mdiTable,
permissions: 'READ_WORK_ORDERS'
},
{
href: '/inspection_intervals/inspection_intervals-list',
label: 'Inspection intervals',
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
icon: icon.mdiTable ?? icon.mdiTable,
permissions: 'READ_INSPECTION_INTERVALS'
},
{
href: '/squawk_notes/squawk_notes-list',
label: 'Squawk notes',
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
icon: icon.mdiTable ?? icon.mdiTable,
permissions: 'READ_SQUAWK_NOTES'
},
{
href: '/profile',
label: 'Profile',

68
frontend/src/pages/aircrafts/[aircraftsId].tsx
View File

@ -36,6 +36,18 @@ const EditAircrafts = () => {
owner: null,
'make': '',
'model': '',
year: '',
'serial_number': '',
engine_count: '',
'engine_type': '',
}
const [initialValues, setInitialValues] = useState(initVals)
@ -108,6 +120,62 @@ const EditAircrafts = () => {
></Field>
</FormField>
<FormField
label="Make"
>
<Field
name="make"
placeholder="Make"
/>
</FormField>
<FormField
label="Model"
>
<Field
name="model"
placeholder="Model"
/>
</FormField>
<FormField
label="Year"
>
<Field
type="number"
name="year"
placeholder="Year"
/>
</FormField>
<FormField
label="Serial number"
>
<Field
name="serial_number"
placeholder="Serial number"
/>
</FormField>
<FormField
label="Engine count"
>
<Field
type="number"
name="engine_count"
placeholder="Engine count"
/>
</FormField>
<FormField
label="Engine type"
>
<Field
name="engine_type"
placeholder="Engine type"
/>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />

68
frontend/src/pages/aircrafts/aircrafts-edit.tsx
View File

@ -37,6 +37,18 @@ const EditAircraftsPage = () => {
owner: null,
'make': '',
'model': '',
year: '',
'serial_number': '',
engine_count: '',
'engine_type': '',
}
const [initialValues, setInitialValues] = useState(initVals)
@ -106,6 +118,62 @@ const EditAircraftsPage = () => {
></Field>
</FormField>
<FormField
label="Make"
>
<Field
name="make"
placeholder="Make"
/>
</FormField>
<FormField
label="Model"
>
<Field
name="model"
placeholder="Model"
/>
</FormField>
<FormField
label="Year"
>
<Field
type="number"
name="year"
placeholder="Year"
/>
</FormField>
<FormField
label="Serial number"
>
<Field
name="serial_number"
placeholder="Serial number"
/>
</FormField>
<FormField
label="Engine count"
>
<Field
type="number"
name="engine_count"
placeholder="Engine count"
/>
</FormField>
<FormField
label="Engine type"
>
<Field
name="engine_type"
placeholder="Engine type"
/>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />

3
frontend/src/pages/aircrafts/aircrafts-list.tsx
View File

@ -22,7 +22,8 @@ const AircraftsTablesPage = () => {
const dispatch = useAppDispatch();
const [filters] = useState([{label: 'RegistrationNumber', title: 'registration_number'},
const [filters] = useState([{label: 'RegistrationNumber', title: 'registration_number'},{label: 'Make', title: 'make'},{label: 'Model', title: 'model'},{label: 'Serial number', title: 'serial_number'},{label: 'Engine type', title: 'engine_type'},
{label: 'Year', title: 'year', number: 'true'},{label: 'Engine count', title: 'engine_count', number: 'true'},
]);
const addFilter = () => {

68
frontend/src/pages/aircrafts/aircrafts-new.tsx
View File

@ -29,6 +29,18 @@ const initialValues = {
owner: '',
make: '',
model: '',
year: '',
serial_number: '',
engine_count: '',
engine_type: '',
}
const AircraftsNew = () => {
@ -70,6 +82,62 @@ const AircraftsNew = () => {
<Field name="owner" id="owner" component={SelectField} options={[]} itemRef={'users'}></Field>
</FormField>
<FormField
label="Make"
>
<Field
name="make"
placeholder="Make"
/>
</FormField>
<FormField
label="Model"
>
<Field
name="model"
placeholder="Model"
/>
</FormField>
<FormField
label="Year"
>
<Field
type="number"
name="year"
placeholder="Year"
/>
</FormField>
<FormField
label="Serial number"
>
<Field
name="serial_number"
placeholder="Serial number"
/>
</FormField>
<FormField
label="Engine count"
>
<Field
type="number"
name="engine_count"
placeholder="Engine count"
/>
</FormField>
<FormField
label="Engine type"
>
<Field
name="engine_type"
placeholder="Engine type"
/>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />

3
frontend/src/pages/aircrafts/aircrafts-table.tsx
View File

@ -22,7 +22,8 @@ const AircraftsTablesPage = () => {
const dispatch = useAppDispatch();
const [filters] = useState([{label: 'RegistrationNumber', title: 'registration_number'},
const [filters] = useState([{label: 'RegistrationNumber', title: 'registration_number'},{label: 'Make', title: 'make'},{label: 'Model', title: 'model'},{label: 'Serial number', title: 'serial_number'},{label: 'Engine type', title: 'engine_type'},
{label: 'Year', title: 'year', number: 'true'},{label: 'Engine count', title: 'engine_count', number: 'true'},
]);
const addFilter = () => {

87
frontend/src/pages/aircrafts/aircrafts-view.tsx
View File

@ -61,6 +61,36 @@ const AircraftsView = () => {
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Make</p>
<p>{aircrafts?.make}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Model</p>
<p>{aircrafts?.model}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Year</p>
<p>{aircrafts?.year || 'No data'}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Serial number</p>
<p>{aircrafts?.serial_number}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Engine count</p>
<p>{aircrafts?.engine_count || 'No data'}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Engine type</p>
<p>{aircrafts?.engine_type}</p>
</div>
<>
<p className={'block font-bold mb-2'}>Flights Aircraft</p>
<CardBox
@ -88,6 +118,8 @@ const AircraftsView = () => {
<th>Remarks</th>
<th>Time recorded for</th>
</tr>
</thead>
<tbody>
@ -127,6 +159,10 @@ const AircraftsView = () => {
{ item.remarks }
</td>
<td data-label="time_recorded_for">
{ item.time_recorded_for }
</td>
</tr>
))}
</tbody>
@ -153,6 +189,8 @@ const AircraftsView = () => {
<th>Type</th>
<th>Performed at</th>
</tr>
</thead>
<tbody>
@ -172,6 +210,10 @@ const AircraftsView = () => {
{ item.type }
</td>
<td data-label="performed_at">
{ dataFormatter.dateTimeFormatter(item.performed_at) }
</td>
</tr>
))}
</tbody>
@ -259,6 +301,51 @@ const AircraftsView = () => {
</CardBox>
</>
<>
<p className={'block font-bold mb-2'}>Inspection_intervals Aircraft</p>
<CardBox
className='mb-6 border border-gray-300 rounded overflow-hidden'
hasTable
>
<div className='overflow-x-auto'>
<table>
<thead>
<tr>
<th>Type</th>
<th>Interval hours</th>
<th>Interval months</th>
</tr>
</thead>
<tbody>
{aircrafts.inspection_intervals_aircraft && Array.isArray(aircrafts.inspection_intervals_aircraft) &&
aircrafts.inspection_intervals_aircraft.map((item: any) => (
<tr key={item.id} onClick={() => router.push(`/inspection_intervals/inspection_intervals-view/?id=${item.id}`)}>
<td data-label="type">
{ item.type }
</td>
<td data-label="interval_hours">
{ item.interval_hours }
</td>
<td data-label="interval_months">
{ item.interval_months }
</td>
</tr>
))}
</tbody>
</table>
</div>
{!aircrafts?.inspection_intervals_aircraft?.length && <div className={'text-center py-4'}>No data</div>}
</CardBox>
</>
<BaseDivider />
<BaseButton

62
frontend/src/pages/dashboard.tsx
View File

@ -26,10 +26,12 @@ const Dashboard = () => {
const [work_orders, setWork_orders] = React.useState(loadingMessage);
const [roles, setRoles] = React.useState(loadingMessage);
const [permissions, setPermissions] = React.useState(loadingMessage);
const [inspection_intervals, setInspection_intervals] = React.useState(loadingMessage);
const [squawk_notes, setSquawk_notes] = React.useState(loadingMessage);
async function loadData() {
const entities = ['users','aircrafts','flights','inspections','organizations','squawks','work_orders','roles','permissions',];
const fns = [setUsers,setAircrafts,setFlights,setInspections,setOrganizations,setSquawks,setWork_orders,setRoles,setPermissions,];
const entities = ['users','aircrafts','flights','inspections','organizations','squawks','work_orders','roles','permissions','inspection_intervals','squawk_notes',];
const fns = [setUsers,setAircrafts,setFlights,setInspections,setOrganizations,setSquawks,setWork_orders,setRoles,setPermissions,setInspection_intervals,setSquawk_notes,];
const requests = entities.map((entity, index) => {
return axios.get(`/${entity.toLowerCase()}/count`);
@ -263,6 +265,62 @@ const Dashboard = () => {
</div>
</Link>
<Link href={'/inspection_intervals/inspection_intervals-list'}>
<div
className={`${corners !== 'rounded-full'? corners : 'rounded-3xl'} dark:bg-dark-900 ${cardsStyle} dark:border-dark-700 p-6`}
>
<div className="flex justify-between align-center">
<div>
<div className="text-lg leading-tight text-gray-500 dark:text-gray-400">
Inspection intervals
</div>
<div className="text-3xl leading-tight font-semibold">
{inspection_intervals}
</div>
</div>
<div>
<BaseIcon
className={`${iconsColor}`}
w="w-16"
h="h-16"
size={48}
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
path={icon.mdiTable || icon.mdiTable}
/>
</div>
</div>
</div>
</Link>
<Link href={'/squawk_notes/squawk_notes-list'}>
<div
className={`${corners !== 'rounded-full'? corners : 'rounded-3xl'} dark:bg-dark-900 ${cardsStyle} dark:border-dark-700 p-6`}
>
<div className="flex justify-between align-center">
<div>
<div className="text-lg leading-tight text-gray-500 dark:text-gray-400">
Squawk notes
</div>
<div className="text-3xl leading-tight font-semibold">
{squawk_notes}
</div>
</div>
<div>
<BaseIcon
className={`${iconsColor}`}
w="w-16"
h="h-16"
size={48}
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
path={icon.mdiTable || icon.mdiTable}
/>
</div>
</div>
</div>
</Link>
</div>
</SectionMain>
</>

12
frontend/src/pages/flights/[flightsId].tsx
View File

@ -50,6 +50,8 @@ const EditFlights = () => {
remarks: '',
time_recorded_for: '',
}
const [initialValues, setInitialValues] = useState(initVals)
@ -195,6 +197,16 @@ const EditFlights = () => {
<Field name="remarks" as="textarea" placeholder="Remarks" />
</FormField>
<FormField label="Time recorded for">
<FormCheckRadioGroup>
<FormCheckRadio type="radio" label="value">
<Field type="radio" name="time_recorded_for" value="value" />
</FormCheckRadio>
</FormCheckRadioGroup>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />

12
frontend/src/pages/flights/flights-edit.tsx
View File

@ -51,6 +51,8 @@ const EditFlightsPage = () => {
remarks: '',
time_recorded_for: '',
}
const [initialValues, setInitialValues] = useState(initVals)
@ -193,6 +195,16 @@ const EditFlightsPage = () => {
<Field name="remarks" as="textarea" placeholder="Remarks" />
</FormField>
<FormField label="Time recorded for">
<FormCheckRadioGroup>
<FormCheckRadio type="radio" label="value">
<Field type="radio" name="time_recorded_for" value="value" />
</FormCheckRadio>
</FormCheckRadioGroup>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />

1
frontend/src/pages/flights/flights-list.tsx
View File

@ -27,6 +27,7 @@ const FlightsTablesPage = () => {
{label: 'StartTachTime', title: 'start_tach_time', number: 'true'},{label: 'EndTachTime', title: 'end_tach_time', number: 'true'},{label: 'HobbsTime', title: 'hobbs_time', number: 'true'},
{label: 'StartTime', title: 'start_time', date: 'true'},{label: 'EndTime', title: 'end_time', date: 'true'},
{label: 'Time recorded for', title: 'time_recorded_for', type: 'enum', options: ['value']},
]);
const addFilter = () => {
const newItem = {

12
frontend/src/pages/flights/flights-new.tsx
View File

@ -43,6 +43,8 @@ const initialValues = {
remarks: '',
time_recorded_for: '',
}
const FlightsNew = () => {
@ -147,6 +149,16 @@ const FlightsNew = () => {
<Field name="remarks" as="textarea" placeholder="Remarks" />
</FormField>
<FormField label="Time recorded for">
<FormCheckRadioGroup>
<FormCheckRadio type="radio" label="value">
<Field type="radio" name="time_recorded_for" value="value" />
</FormCheckRadio>
</FormCheckRadioGroup>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />

1
frontend/src/pages/flights/flights-table.tsx
View File

@ -27,6 +27,7 @@ const FlightsTablesPage = () => {
{label: 'StartTachTime', title: 'start_tach_time', number: 'true'},{label: 'EndTachTime', title: 'end_tach_time', number: 'true'},{label: 'HobbsTime', title: 'hobbs_time', number: 'true'},
{label: 'StartTime', title: 'start_time', date: 'true'},{label: 'EndTime', title: 'end_time', date: 'true'},
{label: 'Time recorded for', title: 'time_recorded_for', type: 'enum', options: ['value']},
]);
const addFilter = () => {
const newItem = {

5
frontend/src/pages/flights/flights-view.tsx
View File

@ -111,6 +111,11 @@ const FlightsView = () => {
<textarea className={'w-full'} disabled value={flights?.remarks} />
</FormField>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Time recorded for</p>
<p>{flights?.time_recorded_for ?? 'No data'}</p>
</div>
<BaseDivider />
<BaseButton

158
frontend/src/pages/inspection_intervals/[inspection_intervalsId].tsx Normal file
View File

@ -0,0 +1,158 @@
import { mdiChartTimelineVariant, mdiUpload } from '@mdi/js'
import Head from 'next/head'
import React, { ReactElement, useEffect, useState } from 'react'
import DatePicker from "react-datepicker";
import "react-datepicker/dist/react-datepicker.css";
import dayjs from "dayjs";
import CardBox from '../../components/CardBox'
import LayoutAuthenticated from '../../layouts/Authenticated'
import SectionMain from '../../components/SectionMain'
import SectionTitleLineWithButton from '../../components/SectionTitleLineWithButton'
import { getPageTitle } from '../../config'
import { Field, Form, Formik } from 'formik'
import FormField from '../../components/FormField'
import BaseDivider from '../../components/BaseDivider'
import BaseButtons from '../../components/BaseButtons'
import BaseButton from '../../components/BaseButton'
import FormCheckRadio from '../../components/FormCheckRadio'
import FormCheckRadioGroup from '../../components/FormCheckRadioGroup'
import { SelectField } from "../../components/SelectField";
import { SelectFieldMany } from "../../components/SelectFieldMany";
import { SwitchField } from '../../components/SwitchField'
import {RichTextField} from "../../components/RichTextField";
import { update, fetch } from '../../stores/inspection_intervals/inspection_intervalsSlice'
import { useAppDispatch, useAppSelector } from '../../stores/hooks'
import { useRouter } from 'next/router'
const EditInspection_intervals = () => {
const router = useRouter()
const dispatch = useAppDispatch()
const initVals = {
aircraft: null,
type: '',
interval_hours: '',
interval_months: '',
}
const [initialValues, setInitialValues] = useState(initVals)
const { inspection_intervals } = useAppSelector((state) => state.inspection_intervals)
const { inspection_intervalsId } = router.query
useEffect(() => {
dispatch(fetch({ id: inspection_intervalsId }))
}, [inspection_intervalsId])
useEffect(() => {
if (typeof inspection_intervals === 'object') {
setInitialValues(inspection_intervals)
}
}, [inspection_intervals])
useEffect(() => {
if (typeof inspection_intervals === 'object') {
const newInitialVal = {...initVals};
Object.keys(initVals).forEach(el => newInitialVal[el] = (inspection_intervals)[el])
setInitialValues(newInitialVal);
}
}, [inspection_intervals])
const handleSubmit = async (data) => {
await dispatch(update({ id: inspection_intervalsId, data }))
await router.push('/inspection_intervals/inspection_intervals-list')
}
return (
<>
<Head>
<title>{getPageTitle('Edit inspection_intervals')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton icon={mdiChartTimelineVariant} title={'Edit inspection_intervals'} main>
{''}
</SectionTitleLineWithButton>
<CardBox>
<Formik
enableReinitialize
initialValues={initialValues}
onSubmit={(values) => handleSubmit(values)}
>
<Form>
<FormField label='Aircraft' labelFor='aircraft'>
<Field
name='aircraft'
id='aircraft'
component={SelectField}
options={initialValues.aircraft}
itemRef={'aircrafts'}
showField={'registration_number'}
></Field>
</FormField>
<FormField label="Type">
<FormCheckRadioGroup>
<FormCheckRadio type="radio" label="value">
<Field type="radio" name="type" value="value" />
</FormCheckRadio>
</FormCheckRadioGroup>
</FormField>
<FormField
label="Interval hours"
>
<Field
type="number"
name="interval_hours"
placeholder="Interval hours"
/>
</FormField>
<FormField
label="Interval months"
>
<Field
type="number"
name="interval_months"
placeholder="Interval months"
/>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />
<BaseButton type="reset" color="info" outline label="Reset" />
<BaseButton type='reset' color='danger' outline label='Cancel' onClick={() => router.push('/inspection_intervals/inspection_intervals-list')}/>
</BaseButtons>
</Form>
</Formik>
</CardBox>
</SectionMain>
</>
)
}
EditInspection_intervals.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated>
{page}
</LayoutAuthenticated>
)
}
export default EditInspection_intervals

156
frontend/src/pages/inspection_intervals/inspection_intervals-edit.tsx Normal file
View File

@ -0,0 +1,156 @@
import { mdiChartTimelineVariant, mdiUpload } from '@mdi/js'
import Head from 'next/head'
import React, { ReactElement, useEffect, useState } from 'react'
import DatePicker from "react-datepicker";
import "react-datepicker/dist/react-datepicker.css";
import dayjs from "dayjs";
import CardBox from '../../components/CardBox'
import LayoutAuthenticated from '../../layouts/Authenticated'
import SectionMain from '../../components/SectionMain'
import SectionTitleLineWithButton from '../../components/SectionTitleLineWithButton'
import { getPageTitle } from '../../config'
import { Field, Form, Formik } from 'formik'
import FormField from '../../components/FormField'
import BaseDivider from '../../components/BaseDivider'
import BaseButtons from '../../components/BaseButtons'
import BaseButton from '../../components/BaseButton'
import FormCheckRadio from '../../components/FormCheckRadio'
import FormCheckRadioGroup from '../../components/FormCheckRadioGroup'
import { SelectField } from "../../components/SelectField";
import { SelectFieldMany } from "../../components/SelectFieldMany";
import { SwitchField } from '../../components/SwitchField'
import {RichTextField} from "../../components/RichTextField";
import { update, fetch } from '../../stores/inspection_intervals/inspection_intervalsSlice'
import { useAppDispatch, useAppSelector } from '../../stores/hooks'
import { useRouter } from 'next/router'
import dataFormatter from '../../helpers/dataFormatter';
const EditInspection_intervalsPage = () => {
const router = useRouter()
const dispatch = useAppDispatch()
const initVals = {
aircraft: null,
type: '',
interval_hours: '',
interval_months: '',
}
const [initialValues, setInitialValues] = useState(initVals)
const { inspection_intervals } = useAppSelector((state) => state.inspection_intervals)
const { id } = router.query
useEffect(() => {
dispatch(fetch({ id: id }))
}, [id])
useEffect(() => {
if (typeof inspection_intervals === 'object') {
setInitialValues(inspection_intervals)
}
}, [inspection_intervals])
useEffect(() => {
if (typeof inspection_intervals === 'object') {
const newInitialVal = {...initVals};
Object.keys(initVals).forEach(el => newInitialVal[el] = (inspection_intervals)[el])
setInitialValues(newInitialVal);
}
}, [inspection_intervals])
const handleSubmit = async (data) => {
await dispatch(update({ id: id, data }))
await router.push('/inspection_intervals/inspection_intervals-list')
}
return (
<>
<Head>
<title>{getPageTitle('Edit inspection_intervals')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton icon={mdiChartTimelineVariant} title={'Edit inspection_intervals'} main>
{''}
</SectionTitleLineWithButton>
<CardBox>
<Formik
enableReinitialize
initialValues={initialValues}
onSubmit={(values) => handleSubmit(values)}
>
<Form>
<FormField label='Aircraft' labelFor='aircraft'>
<Field
name='aircraft'
id='aircraft'
component={SelectField}
options={initialValues.aircraft}
itemRef={'aircrafts'}
showField={'registration_number'}
></Field>
</FormField>
<FormField label="Type">
<FormCheckRadioGroup>
<FormCheckRadio type="radio" label="value">
<Field type="radio" name="type" value="value" />
</FormCheckRadio>
</FormCheckRadioGroup>
</FormField>
<FormField
label="Interval hours"
>
<Field
type="number"
name="interval_hours"
placeholder="Interval hours"
/>
</FormField>
<FormField
label="Interval months"
>
<Field
type="number"
name="interval_months"
placeholder="Interval months"
/>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />
<BaseButton type="reset" color="info" outline label="Reset" />
<BaseButton type='reset' color='danger' outline label='Cancel' onClick={() => router.push('/inspection_intervals/inspection_intervals-list')}/>
</BaseButtons>
</Form>
</Formik>
</CardBox>
</SectionMain>
</>
)
}
EditInspection_intervalsPage.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated>
{page}
</LayoutAuthenticated>
)
}
export default EditInspection_intervalsPage

130
frontend/src/pages/inspection_intervals/inspection_intervals-list.tsx Normal file
View File

@ -0,0 +1,130 @@
import { mdiChartTimelineVariant } from '@mdi/js'
import Head from 'next/head'
import { uniqueId } from 'lodash';
import React, { ReactElement, useState } from 'react'
import CardBox from '../../components/CardBox'
import LayoutAuthenticated from '../../layouts/Authenticated'
import SectionMain from '../../components/SectionMain'
import SectionTitleLineWithButton from '../../components/SectionTitleLineWithButton'
import { getPageTitle } from '../../config'
import TableInspection_intervals from '../../components/Inspection_intervals/TableInspection_intervals'
import BaseButton from '../../components/BaseButton'
import axios from "axios";
import {useAppDispatch, useAppSelector} from "../../stores/hooks";
import CardBoxModal from "../../components/CardBoxModal";
import DragDropFilePicker from "../../components/DragDropFilePicker";
import {setRefetch, uploadCsv} from '../../stores/inspection_intervals/inspection_intervalsSlice';
const Inspection_intervalsTablesPage = () => {
const [filterItems, setFilterItems] = useState([]);
const [csvFile, setCsvFile] = useState<File | null>(null);
const [isModalActive, setIsModalActive] = useState(false);
const dispatch = useAppDispatch();
const [filters] = useState([
{label: 'Interval hours', title: 'interval_hours', number: 'true'},{label: 'Interval months', title: 'interval_months', number: 'true'},
{label: 'Type', title: 'type', type: 'enum', options: ['value']},
]);
const addFilter = () => {
const newItem = {
id: uniqueId(),
fields: {
filterValue: '',
filterValueFrom: '',
filterValueTo: '',
selectedField: '',
},
};
newItem.fields.selectedField = filters[0].title;
setFilterItems([...filterItems, newItem]);
};
const getInspection_intervalsCSV = async () => {
const response = await axios({url: '/inspection_intervals?filetype=csv', method: 'GET',responseType: 'blob'});
const type = response.headers['content-type']
const blob = new Blob([response.data], { type: type })
const link = document.createElement('a')
link.href = window.URL.createObjectURL(blob)
link.download = 'inspection_intervalsCSV.csv'
link.click()
};
const onModalConfirm = async () => {
if (!csvFile) return;
await dispatch(uploadCsv(csvFile));
dispatch(setRefetch(true));
setCsvFile(null);
setIsModalActive(false);
};
const onModalCancel = () => {
setCsvFile(null);
setIsModalActive(false);
};
return (
<>
<Head>
<title>{getPageTitle('Inspection_intervals')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton icon={mdiChartTimelineVariant} title="Inspection_intervals" main>
{''}
</SectionTitleLineWithButton>
<CardBox className='mb-6' cardBoxClassName='flex flex-wrap'>
<BaseButton className={'mr-3'} href={'/inspection_intervals/inspection_intervals-new'} color='info' label='New Item' />
<BaseButton
className={'mr-3'}
color='info'
label='Filter'
onClick={addFilter}
/>
<BaseButton className={'mr-3'} color='info' label='Download CSV' onClick={getInspection_intervalsCSV} />
<BaseButton
color='info'
label='Upload CSV'
onClick={() => setIsModalActive(true)}
/>
<div className='md:inline-flex items-center ms-auto'>
<div id='delete-rows-button'></div>
</div>
</CardBox>
<CardBox className="mb-6" hasTable>
<TableInspection_intervals
filterItems={filterItems}
setFilterItems={setFilterItems}
filters={filters}
showGrid={false}
/>
</CardBox>
</SectionMain>
<CardBoxModal
title='Upload CSV'
buttonColor='info'
buttonLabel={'Confirm'}
// buttonLabel={false ? 'Deleting...' : 'Confirm'}
isActive={isModalActive}
onConfirm={onModalConfirm}
onCancel={onModalCancel}
>
<DragDropFilePicker
file={csvFile}
setFile={setCsvFile}
formats={'.csv'}
/>
</CardBoxModal>
</>
)
}
Inspection_intervalsTablesPage.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated>
{page}
</LayoutAuthenticated>
)
}
export default Inspection_intervalsTablesPage

120
frontend/src/pages/inspection_intervals/inspection_intervals-new.tsx Normal file
View File

@ -0,0 +1,120 @@
import { mdiChartTimelineVariant } from '@mdi/js'
import Head from 'next/head'
import React, { ReactElement } from 'react'
import CardBox from '../../components/CardBox'
import LayoutAuthenticated from '../../layouts/Authenticated'
import SectionMain from '../../components/SectionMain'
import SectionTitleLineWithButton from '../../components/SectionTitleLineWithButton'
import { getPageTitle } from '../../config'
import { Field, Form, Formik } from 'formik'
import FormField from '../../components/FormField'
import BaseDivider from '../../components/BaseDivider'
import BaseButtons from '../../components/BaseButtons'
import BaseButton from '../../components/BaseButton'
import FormCheckRadio from '../../components/FormCheckRadio'
import FormCheckRadioGroup from '../../components/FormCheckRadioGroup'
import { SwitchField } from '../../components/SwitchField'
import { SelectField } from '../../components/SelectField'
import {RichTextField} from "../../components/RichTextField";
import { create } from '../../stores/inspection_intervals/inspection_intervalsSlice'
import { useAppDispatch } from '../../stores/hooks'
import { useRouter } from 'next/router'
const initialValues = {
aircraft: '',
type: '',
interval_hours: '',
interval_months: '',
}
const Inspection_intervalsNew = () => {
const router = useRouter()
const dispatch = useAppDispatch()
const handleSubmit = async (data) => {
await dispatch(create(data))
await router.push('/inspection_intervals/inspection_intervals-list')
}
return (
<>
<Head>
<title>{getPageTitle('New Item')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton icon={mdiChartTimelineVariant} title="New Item" main>
{''}
</SectionTitleLineWithButton>
<CardBox>
<Formik
initialValues={
initialValues
}
onSubmit={(values) => handleSubmit(values)}
>
<Form>
<FormField label="Aircraft" labelFor="aircraft">
<Field name="aircraft" id="aircraft" component={SelectField} options={[]} itemRef={'aircrafts'}></Field>
</FormField>
<FormField label="Type">
<FormCheckRadioGroup>
<FormCheckRadio type="radio" label="value">
<Field type="radio" name="type" value="value" />
</FormCheckRadio>
</FormCheckRadioGroup>
</FormField>
<FormField
label="Interval hours"
>
<Field
type="number"
name="interval_hours"
placeholder="Interval hours"
/>
</FormField>
<FormField
label="Interval months"
>
<Field
type="number"
name="interval_months"
placeholder="Interval months"
/>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />
<BaseButton type="reset" color="info" outline label="Reset" />
<BaseButton type='reset' color='danger' outline label='Cancel' onClick={() => router.push('/inspection_intervals/inspection_intervals-list')}/>
</BaseButtons>
</Form>
</Formik>
</CardBox>
</SectionMain>
</>
)
}
Inspection_intervalsNew.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated>
{page}
</LayoutAuthenticated>
)
}
export default Inspection_intervalsNew

131
frontend/src/pages/inspection_intervals/inspection_intervals-table.tsx Normal file
View File

@ -0,0 +1,131 @@
import { mdiChartTimelineVariant } from '@mdi/js'
import Head from 'next/head'
import { uniqueId } from 'lodash';
import React, { ReactElement, useState } from 'react'
import CardBox from '../../components/CardBox'
import LayoutAuthenticated from '../../layouts/Authenticated'
import SectionMain from '../../components/SectionMain'
import SectionTitleLineWithButton from '../../components/SectionTitleLineWithButton'
import { getPageTitle } from '../../config'
import TableInspection_intervals from '../../components/Inspection_intervals/TableInspection_intervals'
import BaseButton from '../../components/BaseButton'
import axios from "axios";
import {useAppDispatch, useAppSelector} from "../../stores/hooks";
import CardBoxModal from "../../components/CardBoxModal";
import DragDropFilePicker from "../../components/DragDropFilePicker";
import {setRefetch, uploadCsv} from '../../stores/inspection_intervals/inspection_intervalsSlice';
const Inspection_intervalsTablesPage = () => {
const [filterItems, setFilterItems] = useState([]);
const [csvFile, setCsvFile] = useState<File | null>(null);
const [isModalActive, setIsModalActive] = useState(false);
const dispatch = useAppDispatch();
const [filters] = useState([
{label: 'Interval hours', title: 'interval_hours', number: 'true'},{label: 'Interval months', title: 'interval_months', number: 'true'},
{label: 'Type', title: 'type', type: 'enum', options: ['value']},
]);
const addFilter = () => {
const newItem = {
id: uniqueId(),
fields: {
filterValue: '',
filterValueFrom: '',
filterValueTo: '',
selectedField: '',
},
};
newItem.fields.selectedField = filters[0].title;
setFilterItems([...filterItems, newItem]);
};
const getInspection_intervalsCSV = async () => {
const response = await axios({url: '/inspection_intervals?filetype=csv', method: 'GET',responseType: 'blob'});
const type = response.headers['content-type']
const blob = new Blob([response.data], { type: type })
const link = document.createElement('a')
link.href = window.URL.createObjectURL(blob)
link.download = 'inspection_intervalsCSV.csv'
link.click()
};
const onModalConfirm = async () => {
if (!csvFile) return;
await dispatch(uploadCsv(csvFile));
dispatch(setRefetch(true));
setCsvFile(null);
setIsModalActive(false);
};
const onModalCancel = () => {
setCsvFile(null);
setIsModalActive(false);
};
return (
<>
<Head>
<title>{getPageTitle('Inspection_intervals')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton icon={mdiChartTimelineVariant} title="Inspection_intervals" main>
{''}
</SectionTitleLineWithButton>
<CardBox className='mb-6' cardBoxClassName='flex flex-wrap'>
<BaseButton className={'mr-3'} href={'/inspection_intervals/inspection_intervals-new'} color='info' label='New Item' />
<BaseButton
className={'mr-3'}
color='info'
label='Filter'
onClick={addFilter}
/>
<BaseButton className={'mr-3'} color='info' label='Download CSV' onClick={getInspection_intervalsCSV} />
<BaseButton
color='info'
label='Upload CSV'
onClick={() => setIsModalActive(true)}
/>
<div className='md:inline-flex items-center ms-auto'>
<div id='delete-rows-button'></div>
</div>
</CardBox>
<CardBox className="mb-6" hasTable>
<TableInspection_intervals
filterItems={filterItems}
setFilterItems={setFilterItems}
filters={filters}
showGrid={true}
/>
</CardBox>
</SectionMain>
<CardBoxModal
title='Upload CSV'
buttonColor='info'
buttonLabel={'Confirm'}
// buttonLabel={false ? 'Deleting...' : 'Confirm'}
isActive={isModalActive}
onConfirm={onModalConfirm}
onCancel={onModalCancel}
>
<DragDropFilePicker
file={csvFile}
setFile={setCsvFile}
formats={'.csv'}
/>
</CardBoxModal>
</>
)
}
Inspection_intervalsTablesPage.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated>
{page}
</LayoutAuthenticated>
)
}
export default Inspection_intervalsTablesPage

95
frontend/src/pages/inspection_intervals/inspection_intervals-view.tsx Normal file
View File

@ -0,0 +1,95 @@
import React, { ReactElement, useEffect } from 'react';
import Head from 'next/head'
import DatePicker from "react-datepicker";
import "react-datepicker/dist/react-datepicker.css";
import dayjs from "dayjs";
import {useAppDispatch, useAppSelector} from "../../stores/hooks";
import {useRouter} from "next/router";
import { fetch } from '../../stores/inspection_intervals/inspection_intervalsSlice'
import dataFormatter from '../../helpers/dataFormatter';
import LayoutAuthenticated from "../../layouts/Authenticated";
import {getPageTitle} from "../../config";
import SectionTitleLineWithButton from "../../components/SectionTitleLineWithButton";
import SectionMain from "../../components/SectionMain";
import CardBox from "../../components/CardBox";
import BaseButton from "../../components/BaseButton";
import BaseDivider from "../../components/BaseDivider";
import {mdiChartTimelineVariant} from "@mdi/js";
import {SwitchField} from "../../components/SwitchField";
import FormField from "../../components/FormField";
const Inspection_intervalsView = () => {
const router = useRouter()
const dispatch = useAppDispatch()
const { inspection_intervals } = useAppSelector((state) => state.inspection_intervals)
const { id } = router.query;
function removeLastCharacter(str) {
console.log(str,`str`)
return str.slice(0, -1);
}
useEffect(() => {
dispatch(fetch({ id }));
}, [dispatch, id]);
return (
<>
<Head>
<title>{getPageTitle('View inspection_intervals')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton icon={mdiChartTimelineVariant} title={removeLastCharacter('View inspection_intervals')} main>
<BaseButton
color='info'
label='Edit'
href={`/inspection_intervals/inspection_intervals-edit/?id=${id}`}
/>
</SectionTitleLineWithButton>
<CardBox>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Aircraft</p>
<p>{inspection_intervals?.aircraft?.registration_number ?? 'No data'}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Type</p>
<p>{inspection_intervals?.type ?? 'No data'}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Interval hours</p>
<p>{inspection_intervals?.interval_hours || 'No data'}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Interval months</p>
<p>{inspection_intervals?.interval_months || 'No data'}</p>
</div>
<BaseDivider />
<BaseButton
color='info'
label='Back'
onClick={() => router.push('/inspection_intervals/inspection_intervals-list')}
/>
</CardBox>
</SectionMain>
</>
);
};
Inspection_intervalsView.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated>
{page}
</LayoutAuthenticated>
)
}
export default Inspection_intervalsView;

32
frontend/src/pages/inspections/[inspectionsId].tsx
View File

@ -40,6 +40,10 @@ const EditInspections = () => {
type: '',
performed_at: new Date(),
performed_by: null,
}
const [initialValues, setInitialValues] = useState(initVals)
@ -147,6 +151,34 @@ const EditInspections = () => {
</Field>
</FormField>
<FormField
label="Performed at"
>
<DatePicker
dateFormat="yyyy-MM-dd hh:mm"
showTimeSelect
selected={initialValues.performed_at ?
new Date(
dayjs(initialValues.performed_at).format('YYYY-MM-DD hh:mm'),
) : null
}
onChange={(date) => setInitialValues({...initialValues, 'performed_at': date})}
/>
</FormField>
<FormField label='Performed_by' labelFor='performed_by'>
<Field
name='performed_by'
id='performed_by'
component={SelectField}
options={initialValues.performed_by}
itemRef={'users'}
showField={'firstName'}
></Field>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />

32
frontend/src/pages/inspections/inspections-edit.tsx
View File

@ -41,6 +41,10 @@ const EditInspectionsPage = () => {
type: '',
performed_at: new Date(),
performed_by: null,
}
const [initialValues, setInitialValues] = useState(initVals)
@ -145,6 +149,34 @@ const EditInspectionsPage = () => {
</Field>
</FormField>
<FormField
label="Performed at"
>
<DatePicker
dateFormat="yyyy-MM-dd hh:mm"
showTimeSelect
selected={initialValues.performed_at ?
new Date(
dayjs(initialValues.performed_at).format('YYYY-MM-DD hh:mm'),
) : null
}
onChange={(date) => setInitialValues({...initialValues, 'performed_at': date})}
/>
</FormField>
<FormField label='Performed_by' labelFor='performed_by'>
<Field
name='performed_by'
id='performed_by'
component={SelectField}
options={initialValues.performed_by}
itemRef={'users'}
showField={'firstName'}
></Field>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />

2
frontend/src/pages/inspections/inspections-list.tsx
View File

@ -24,7 +24,7 @@ const InspectionsTablesPage = () => {
const [filters] = useState([
{label: 'LastPerformed', title: 'last_performed', date: 'true'},{label: 'DueDate', title: 'due_date', date: 'true'},
{label: 'LastPerformed', title: 'last_performed', date: 'true'},{label: 'DueDate', title: 'due_date', date: 'true'},{label: 'Performed at', title: 'performed_at', date: 'true'},
{label: 'Type', title: 'type', type: 'enum', options: ['annual','100_hour','transponder_check','pitot_static_test']},
]);

18
frontend/src/pages/inspections/inspections-new.tsx
View File

@ -33,6 +33,10 @@ const initialValues = {
type: 'annual',
performed_at: '',
performed_by: '',
}
const InspectionsNew = () => {
@ -99,6 +103,20 @@ const InspectionsNew = () => {
</Field>
</FormField>
<FormField
label="Performed at"
>
<Field
type="datetime-local"
name="performed_at"
placeholder="Performed at"
/>
</FormField>
<FormField label="Performed_by" labelFor="performed_by">
<Field name="performed_by" id="performed_by" component={SelectField} options={[]} itemRef={'users'}></Field>
</FormField>
<BaseDivider />
<BaseButtons>
<BaseButton type="submit" color="info" label="Submit" />

2
frontend/src/pages/inspections/inspections-table.tsx
View File

@ -24,7 +24,7 @@ const InspectionsTablesPage = () => {
const [filters] = useState([
{label: 'LastPerformed', title: 'last_performed', date: 'true'},{label: 'DueDate', title: 'due_date', date: 'true'},
{label: 'LastPerformed', title: 'last_performed', date: 'true'},{label: 'DueDate', title: 'due_date', date: 'true'},{label: 'Performed at', title: 'performed_at', date: 'true'},
{label: 'Type', title: 'type', type: 'enum', options: ['annual','100_hour','transponder_check','pitot_static_test']},
]);

20
frontend/src/pages/inspections/inspections-view.tsx
View File

@ -87,6 +87,26 @@ const InspectionsView = () => {
<p>{inspections?.type ?? 'No data'}</p>
</div>
<FormField label='Performed at'>
{inspections.performed_at ? <DatePicker
dateFormat="yyyy-MM-dd hh:mm"
showTimeSelect
selected={inspections.performed_at ?
new Date(
dayjs(inspections.performed_at).format('YYYY-MM-DD hh:mm'),
) : null
}
disabled
/> : <p>No Performed at</p>}
</FormField>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Performed_by</p>
<p>{inspections?.performed_by?.firstName ?? 'No data'}</p>
</div>
<BaseDivider />
<BaseButton

Some files were not shown because too many files have changed in this diff Show More