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

Compare commits

base: admin:4f963518d28cdc0465eb72d072471733a532f920
Branches Tags
admin:master
admin:ai-dev
..
compare: admin:fb49684942ca856a0e3aa63aaa316b800669ae56
Branches Tags
admin:ai-dev
admin:master

No commits in common. "4f963518d28cdc0465eb72d072471733a532f920" and "fb49684942ca856a0e3aa63aaa316b800669ae56" have entirely different histories.
4f963518d2 ... fb49684942

53 changed files with 15 additions and 3776 deletions
Show Stats Expand all files Collapse all files

5
.gitignore vendored
View File

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

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

File diff suppressed because one or more lines are too long

42
backend/src/db/api/ai_agents.js
View File

@ -29,10 +29,6 @@ module.exports = class Ai_agentsDBApi {
transaction, transaction,
}); });
await ai_agents.setWebsite(data.website || null, {
transaction,
});
return ai_agents; return ai_agents;
} }
@ -92,14 +88,6 @@ module.exports = class Ai_agentsDBApi {
); );
} }
if (data.website !== undefined) {
await ai_agents.setWebsite(
data.website,
{ transaction },
);
}
return ai_agents; return ai_agents;
} }
@ -169,10 +157,6 @@ module.exports = class Ai_agentsDBApi {
transaction, transaction,
}); });
output.website = await ai_agents.getWebsite({
transaction,
});
return output; return output;
} }
@ -202,32 +186,6 @@ module.exports = class Ai_agentsDBApi {
model: db.organizations, model: db.organizations,
as: 'organizations', as: 'organizations',
}, },
{
model: db.websites,
as: 'website',
where: filter.website
? {
[Op.or]: [
{
id: {
[Op.in]: filter.website
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
name: {
[Op.or]: filter.website
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
]; ];
if (filter) { if (filter) {

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

@ -148,11 +148,6 @@ module.exports = class OrganizationsDBApi {
transaction, transaction,
}); });
output.websites_organizations =
await organizations.getWebsites_organizations({
transaction,
});
return output; return output;
} }

331
backend/src/db/api/websites.js
View File

@ -1,331 +0,0 @@
const db = require('../models');
const FileDBApi = require('./file');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class WebsitesDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const websites = await db.websites.create(
{
id: data.id || undefined,
name: data.name || null,
url: data.url || null,
description: data.description || null,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
await websites.setOrganizations(data.organizations || null, {
transaction,
});
return websites;
}
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 websitesData = data.map((item, index) => ({
id: item.id || undefined,
name: item.name || null,
url: item.url || null,
description: item.description || null,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const websites = await db.websites.bulkCreate(websitesData, {
transaction,
});
// For each item created, replace relation files
return websites;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const globalAccess = currentUser.app_role?.globalAccess;
const websites = await db.websites.findByPk(id, {}, { transaction });
const updatePayload = {};
if (data.name !== undefined) updatePayload.name = data.name;
if (data.url !== undefined) updatePayload.url = data.url;
if (data.description !== undefined)
updatePayload.description = data.description;
updatePayload.updatedById = currentUser.id;
await websites.update(updatePayload, { transaction });
if (data.organizations !== undefined) {
await websites.setOrganizations(
data.organizations,
{ transaction },
);
}
return websites;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const websites = await db.websites.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of websites) {
await record.update({ deletedBy: currentUser.id }, { transaction });
}
for (const record of websites) {
await record.destroy({ transaction });
}
});
return websites;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const websites = await db.websites.findByPk(id, options);
await websites.update(
{
deletedBy: currentUser.id,
},
{
transaction,
},
);
await websites.destroy({
transaction,
});
return websites;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const websites = await db.websites.findOne({ where }, { transaction });
if (!websites) {
return websites;
}
const output = websites.get({ plain: true });
output.ai_agents_website = await websites.getAi_agents_website({
transaction,
});
output.organizations = await websites.getOrganizations({
transaction,
});
return output;
}
static async findAll(filter, globalAccess, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
const user = (options && options.currentUser) || null;
const userOrganizations = (user && user.organizations?.id) || null;
if (userOrganizations) {
if (options?.currentUser?.organizationsId) {
where.organizationsId = options.currentUser.organizationsId;
}
}
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [
{
model: db.organizations,
as: 'organizations',
},
];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.name) {
where = {
...where,
[Op.and]: Utils.ilike('websites', 'name', filter.name),
};
}
if (filter.url) {
where = {
...where,
[Op.and]: Utils.ilike('websites', 'url', filter.url),
};
}
if (filter.description) {
where = {
...where,
[Op.and]: Utils.ilike('websites', 'description', filter.description),
};
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true',
};
}
if (filter.organizations) {
const listItems = filter.organizations.split('|').map((item) => {
return Utils.uuid(item);
});
where = {
...where,
organizationsId: { [Op.or]: listItems },
};
}
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,
},
};
}
}
}
if (globalAccess) {
delete where.organizationsId;
}
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.websites.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,
globalAccess,
organizationId,
) {
let where = {};
if (!globalAccess && organizationId) {
where.organizationId = organizationId;
}
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike('websites', 'name', query),
],
};
}
const records = await db.websites.findAll({
attributes: ['id', 'name'],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['name', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.name,
}));
}
};

90
backend/src/db/migrations/1746045849977.js
View File

@ -1,90 +0,0 @@
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(
'websites',
{
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 queryInterface.addColumn(
'websites',
'organizationsId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'organizations',
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('websites', 'organizationsId', {
transaction,
});
await queryInterface.dropTable('websites', { transaction });
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
};

47
backend/src/db/migrations/1746045881783.js
View File

@ -1,47 +0,0 @@
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(
'websites',
'name',
{
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('websites', 'name', { transaction });
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
};

47
backend/src/db/migrations/1746045903232.js
View File

@ -1,47 +0,0 @@
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(
'websites',
'url',
{
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('websites', 'url', { transaction });
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
};

49
backend/src/db/migrations/1746045929263.js
View File

@ -1,49 +0,0 @@
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(
'websites',
'description',
{
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('websites', 'description', {
transaction,
});
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
};

54
backend/src/db/migrations/1746045953413.js
View File

@ -1,54 +0,0 @@
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(
'ai_agents',
'websiteId',
{
type: Sequelize.DataTypes.UUID,
references: {
model: 'websites',
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('ai_agents', 'websiteId', {
transaction,
});
await transaction.commit();
} catch (err) {
await transaction.rollback();
throw err;
}
},
};

8
backend/src/db/models/ai_agents.js
View File

@ -60,14 +60,6 @@ module.exports = function (sequelize, DataTypes) {
constraints: false, constraints: false,
}); });
db.ai_agents.belongsTo(db.websites, {
as: 'website',
foreignKey: {
name: 'websiteId',
},
constraints: false,
});
db.ai_agents.belongsTo(db.users, { db.ai_agents.belongsTo(db.users, {
as: 'createdBy', as: 'createdBy',
}); });

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

@ -58,14 +58,6 @@ module.exports = function (sequelize, DataTypes) {
constraints: false, constraints: false,
}); });
db.organizations.hasMany(db.websites, {
as: 'websites_organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
//end loop //end loop
db.organizations.belongsTo(db.users, { db.organizations.belongsTo(db.users, {

73
backend/src/db/models/websites.js
View File

@ -1,73 +0,0 @@
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 websites = sequelize.define(
'websites',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
name: {
type: DataTypes.TEXT,
},
url: {
type: DataTypes.TEXT,
},
description: {
type: DataTypes.TEXT,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
websites.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
db.websites.hasMany(db.ai_agents, {
as: 'ai_agents_website',
foreignKey: {
name: 'websiteId',
},
constraints: false,
});
//end loop
db.websites.belongsTo(db.organizations, {
as: 'organizations',
foreignKey: {
name: 'organizationsId',
},
constraints: false,
});
db.websites.belongsTo(db.users, {
as: 'createdBy',
});
db.websites.belongsTo(db.users, {
as: 'updatedBy',
});
};
return websites;
};

51
backend/src/db/seeders/20200430130760-user-roles.js
View File

@ -110,7 +110,6 @@ module.exports = {
'roles', 'roles',
'permissions', 'permissions',
'organizations', 'organizations',
'websites',
, ,
]; ];
await queryInterface.bulkInsert( await queryInterface.bulkInsert(
@ -548,31 +547,6 @@ primary key ("roles_permissionsId", "permissionId")
permissionId: getId('DELETE_INTERACTIONS'), permissionId: getId('DELETE_INTERACTIONS'),
}, },
{
createdAt,
updatedAt,
roles_permissionsId: getId('Administrator'),
permissionId: getId('CREATE_WEBSITES'),
},
{
createdAt,
updatedAt,
roles_permissionsId: getId('Administrator'),
permissionId: getId('READ_WEBSITES'),
},
{
createdAt,
updatedAt,
roles_permissionsId: getId('Administrator'),
permissionId: getId('UPDATE_WEBSITES'),
},
{
createdAt,
updatedAt,
roles_permissionsId: getId('Administrator'),
permissionId: getId('DELETE_WEBSITES'),
},
{ {
createdAt, createdAt,
updatedAt, updatedAt,
@ -723,31 +697,6 @@ primary key ("roles_permissionsId", "permissionId")
permissionId: getId('DELETE_ORGANIZATIONS'), permissionId: getId('DELETE_ORGANIZATIONS'),
}, },
{
createdAt,
updatedAt,
roles_permissionsId: getId('SuperAdmin'),
permissionId: getId('CREATE_WEBSITES'),
},
{
createdAt,
updatedAt,
roles_permissionsId: getId('SuperAdmin'),
permissionId: getId('READ_WEBSITES'),
},
{
createdAt,
updatedAt,
roles_permissionsId: getId('SuperAdmin'),
permissionId: getId('UPDATE_WEBSITES'),
},
{
createdAt,
updatedAt,
roles_permissionsId: getId('SuperAdmin'),
permissionId: getId('DELETE_WEBSITES'),
},
{ {
createdAt, createdAt,
updatedAt, updatedAt,

134
backend/src/db/seeders/20231127130745-sample-data.js
View File

@ -7,8 +7,6 @@ const Interactions = db.interactions;
const Organizations = db.organizations; const Organizations = db.organizations;
const Websites = db.websites;
const AiAgentsData = [ const AiAgentsData = [
{ {
name: 'NavigatorBot', name: 'NavigatorBot',
@ -18,8 +16,6 @@ const AiAgentsData = [
description: 'A bot that navigates the website and provides information.', description: 'A bot that navigates the website and provides information.',
// type code here for "relation_one" field // type code here for "relation_one" field
// type code here for "relation_one" field
}, },
{ {
@ -30,8 +26,6 @@ const AiAgentsData = [
description: 'Retrieves information based on user queries.', description: 'Retrieves information based on user queries.',
// type code here for "relation_one" field // type code here for "relation_one" field
// type code here for "relation_one" field
}, },
{ {
@ -42,8 +36,6 @@ const AiAgentsData = [
description: 'Assists users with chat-based interactions.', description: 'Assists users with chat-based interactions.',
// type code here for "relation_one" field // type code here for "relation_one" field
// type code here for "relation_one" field
}, },
]; ];
@ -93,53 +85,15 @@ const InteractionsData = [
const OrganizationsData = [ const OrganizationsData = [
{ {
name: 'Richard Feynman', name: 'Anton van Leeuwenhoek',
}, },
{ {
name: 'John Bardeen', name: 'Hans Selye',
}, },
{ {
name: 'Antoine Laurent Lavoisier', name: 'Max Delbruck',
},
];
const WebsitesData = [
{
// type code here for "relation_one" field
name: 'Claude Levi-Strauss',
url: 'J. Robert Oppenheimer',
description: 'Marie Curie',
// type code here for "relation_many" field
},
{
// type code here for "relation_one" field
name: 'Charles Darwin',
url: 'Carl Linnaeus',
description: 'Charles Darwin',
// type code here for "relation_many" field
},
{
// type code here for "relation_one" field
name: 'Justus Liebig',
url: 'Rudolf Virchow',
description: 'Karl Landsteiner',
// type code here for "relation_many" field
}, },
]; ];
@ -215,41 +169,6 @@ async function associateAiAgentWithOrganization() {
} }
} }
async function associateAiAgentWithWebsite() {
const relatedWebsite0 = await Websites.findOne({
offset: Math.floor(Math.random() * (await Websites.count())),
});
const AiAgent0 = await AiAgents.findOne({
order: [['id', 'ASC']],
offset: 0,
});
if (AiAgent0?.setWebsite) {
await AiAgent0.setWebsite(relatedWebsite0);
}
const relatedWebsite1 = await Websites.findOne({
offset: Math.floor(Math.random() * (await Websites.count())),
});
const AiAgent1 = await AiAgents.findOne({
order: [['id', 'ASC']],
offset: 1,
});
if (AiAgent1?.setWebsite) {
await AiAgent1.setWebsite(relatedWebsite1);
}
const relatedWebsite2 = await Websites.findOne({
offset: Math.floor(Math.random() * (await Websites.count())),
});
const AiAgent2 = await AiAgents.findOne({
order: [['id', 'ASC']],
offset: 2,
});
if (AiAgent2?.setWebsite) {
await AiAgent2.setWebsite(relatedWebsite2);
}
}
async function associateInteractionWithAgent() { async function associateInteractionWithAgent() {
const relatedAgent0 = await AiAgents.findOne({ const relatedAgent0 = await AiAgents.findOne({
offset: Math.floor(Math.random() * (await AiAgents.count())), offset: Math.floor(Math.random() * (await AiAgents.count())),
@ -355,43 +274,6 @@ async function associateInteractionWithOrganization() {
} }
} }
async function associateWebsiteWithOrganization() {
const relatedOrganization0 = await Organizations.findOne({
offset: Math.floor(Math.random() * (await Organizations.count())),
});
const Website0 = await Websites.findOne({
order: [['id', 'ASC']],
offset: 0,
});
if (Website0?.setOrganization) {
await Website0.setOrganization(relatedOrganization0);
}
const relatedOrganization1 = await Organizations.findOne({
offset: Math.floor(Math.random() * (await Organizations.count())),
});
const Website1 = await Websites.findOne({
order: [['id', 'ASC']],
offset: 1,
});
if (Website1?.setOrganization) {
await Website1.setOrganization(relatedOrganization1);
}
const relatedOrganization2 = await Organizations.findOne({
offset: Math.floor(Math.random() * (await Organizations.count())),
});
const Website2 = await Websites.findOne({
order: [['id', 'ASC']],
offset: 2,
});
if (Website2?.setOrganization) {
await Website2.setOrganization(relatedOrganization2);
}
}
// Similar logic for "relation_many"
module.exports = { module.exports = {
up: async (queryInterface, Sequelize) => { up: async (queryInterface, Sequelize) => {
await AiAgents.bulkCreate(AiAgentsData); await AiAgents.bulkCreate(AiAgentsData);
@ -400,8 +282,6 @@ module.exports = {
await Organizations.bulkCreate(OrganizationsData); await Organizations.bulkCreate(OrganizationsData);
await Websites.bulkCreate(WebsitesData);
await Promise.all([ await Promise.all([
// Similar logic for "relation_many" // Similar logic for "relation_many"
@ -409,17 +289,11 @@ module.exports = {
await associateAiAgentWithOrganization(), await associateAiAgentWithOrganization(),
await associateAiAgentWithWebsite(),
await associateInteractionWithAgent(), await associateInteractionWithAgent(),
await associateInteractionWithUser(), await associateInteractionWithUser(),
await associateInteractionWithOrganization(), await associateInteractionWithOrganization(),
await associateWebsiteWithOrganization(),
// Similar logic for "relation_many"
]); ]);
}, },
@ -429,7 +303,5 @@ module.exports = {
await queryInterface.bulkDelete('interactions', null, {}); await queryInterface.bulkDelete('interactions', null, {});
await queryInterface.bulkDelete('organizations', null, {}); await queryInterface.bulkDelete('organizations', null, {});
await queryInterface.bulkDelete('websites', null, {});
}, },
}; };

87
backend/src/db/seeders/20250430204409.js
View File

@ -1,87 +0,0 @@
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 = ['websites'];
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.super_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

@ -33,8 +33,6 @@ const permissionsRoutes = require('./routes/permissions');
const organizationsRoutes = require('./routes/organizations'); const organizationsRoutes = require('./routes/organizations');
const websitesRoutes = require('./routes/websites');
const getBaseUrl = (url) => { const getBaseUrl = (url) => {
if (!url) return ''; if (!url) return '';
return url.endsWith('/api') ? url.slice(0, -4) : url; return url.endsWith('/api') ? url.slice(0, -4) : url;
@ -136,12 +134,6 @@ app.use(
organizationsRoutes, organizationsRoutes,
); );
app.use(
'/api/websites',
passport.authenticate('jwt', { session: false }),
websitesRoutes,
);
app.use( app.use(
'/api/openai', '/api/openai',
passport.authenticate('jwt', { session: false }), passport.authenticate('jwt', { session: false }),

458
backend/src/routes/websites.js
View File

@ -1,458 +0,0 @@
const express = require('express');
const WebsitesService = require('../services/websites');
const WebsitesDBApi = require('../db/api/websites');
const wrapAsync = require('../helpers').wrapAsync;
const config = require('../config');
const router = express.Router();
const { parse } = require('json2csv');
const { checkCrudPermissions } = require('../middlewares/check-permissions');
router.use(checkCrudPermissions('websites'));
/**
* @swagger
* components:
* schemas:
* Websites:
* type: object
* properties:
* name:
* type: string
* default: name
* url:
* type: string
* default: url
* description:
* type: string
* default: description
*/
/**
* @swagger
* tags:
* name: Websites
* description: The Websites managing API
*/
/**
* @swagger
* /api/websites:
* post:
* security:
* - bearerAuth: []
* tags: [Websites]
* 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/Websites"
* responses:
* 200:
* description: The item was successfully added
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Websites"
* 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 WebsitesService.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: [Websites]
* 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/Websites"
* responses:
* 200:
* description: The items were successfully imported
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Websites"
* 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 WebsitesService.bulkImport(req, res, true, link.host);
const payload = true;
res.status(200).send(payload);
}),
);
/**
* @swagger
* /api/websites/{id}:
* put:
* security:
* - bearerAuth: []
* tags: [Websites]
* 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/Websites"
* required:
* - id
* responses:
* 200:
* description: The item data was successfully updated
* content:
* application/json:
* schema:
* $ref: "#/components/schemas/Websites"
* 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 WebsitesService.update(req.body.data, req.body.id, req.currentUser);
const payload = true;
res.status(200).send(payload);
}),
);
/**
* @swagger
* /api/websites/{id}:
* delete:
* security:
* - bearerAuth: []
* tags: [Websites]
* 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/Websites"
* 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 WebsitesService.remove(req.params.id, req.currentUser);
const payload = true;
res.status(200).send(payload);
}),
);
/**
* @swagger
* /api/websites/deleteByIds:
* post:
* security:
* - bearerAuth: []
* tags: [Websites]
* 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/Websites"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Items not found
* 500:
* description: Some server error
*/
router.post(
'/deleteByIds',
wrapAsync(async (req, res) => {
await WebsitesService.deleteByIds(req.body.data, req.currentUser);
const payload = true;
res.status(200).send(payload);
}),
);
/**
* @swagger
* /api/websites:
* get:
* security:
* - bearerAuth: []
* tags: [Websites]
* summary: Get all websites
* description: Get all websites
* responses:
* 200:
* description: Websites list successfully received
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Websites"
* 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 globalAccess = req.currentUser.app_role.globalAccess;
const currentUser = req.currentUser;
const payload = await WebsitesDBApi.findAll(req.query, globalAccess, {
currentUser,
});
if (filetype && filetype === 'csv') {
const fields = ['id', 'name', 'url', 'description'];
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/websites/count:
* get:
* security:
* - bearerAuth: []
* tags: [Websites]
* summary: Count all websites
* description: Count all websites
* responses:
* 200:
* description: Websites count successfully received
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Websites"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Data not found
* 500:
* description: Some server error
*/
router.get(
'/count',
wrapAsync(async (req, res) => {
const globalAccess = req.currentUser.app_role.globalAccess;
const currentUser = req.currentUser;
const payload = await WebsitesDBApi.findAll(req.query, globalAccess, {
countOnly: true,
currentUser,
});
res.status(200).send(payload);
}),
);
/**
* @swagger
* /api/websites/autocomplete:
* get:
* security:
* - bearerAuth: []
* tags: [Websites]
* summary: Find all websites that match search criteria
* description: Find all websites that match search criteria
* responses:
* 200:
* description: Websites list successfully received
* content:
* application/json:
* schema:
* type: array
* items:
* $ref: "#/components/schemas/Websites"
* 401:
* $ref: "#/components/responses/UnauthorizedError"
* 404:
* description: Data not found
* 500:
* description: Some server error
*/
router.get('/autocomplete', async (req, res) => {
const globalAccess = req.currentUser.app_role.globalAccess;
const organizationId = req.currentUser.organization?.id;
const payload = await WebsitesDBApi.findAllAutocomplete(
req.query.query,
req.query.limit,
req.query.offset,
globalAccess,
organizationId,
);
res.status(200).send(payload);
});
/**
* @swagger
* /api/websites/{id}:
* get:
* security:
* - bearerAuth: []
* tags: [Websites]
* 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/Websites"
* 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 WebsitesDBApi.findBy({ id: req.params.id });
res.status(200).send(payload);
}),
);
router.use('/', require('../helpers').commonErrorHandler);
module.exports = router;

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

@ -48,8 +48,6 @@ module.exports = class SearchService {
interactions: ['transcript'], interactions: ['transcript'],
organizations: ['name'], organizations: ['name'],
websites: ['name', 'url', 'description'],
}; };
const columnsInt = {}; const columnsInt = {};

114
backend/src/services/websites.js
View File

@ -1,114 +0,0 @@
const db = require('../db/models');
const WebsitesDBApi = require('../db/api/websites');
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 WebsitesService {
static async create(data, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await WebsitesDBApi.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 WebsitesDBApi.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 websites = await WebsitesDBApi.findBy({ id }, { transaction });
if (!websites) {
throw new ValidationError('websitesNotFound');
}
const updatedWebsites = await WebsitesDBApi.update(id, data, {
currentUser,
transaction,
});
await transaction.commit();
return updatedWebsites;
} catch (error) {
await transaction.rollback();
throw error;
}
}
static async deleteByIds(ids, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await WebsitesDBApi.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 WebsitesDBApi.remove(id, {
currentUser,
transaction,
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
};

1
frontend/json/runtimeError.json
View File

@ -1 +0,0 @@
{}

11
frontend/src/components/Ai_agents/CardAi_agents.tsx
View File

@ -106,17 +106,6 @@ const CardAi_agents = ({
</div> </div>
</dd> </dd>
</div> </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'>
{dataFormatter.websitesOneListFormatter(item.website)}
</div>
</dd>
</div>
</dl> </dl>
</li> </li>
))} ))}

7
frontend/src/components/Ai_agents/ListAi_agents.tsx
View File

@ -69,13 +69,6 @@ const ListAi_agents = ({
<p className={'text-xs text-gray-500 '}>Description</p> <p className={'text-xs text-gray-500 '}>Description</p>
<p className={'line-clamp-2'}>{item.description}</p> <p className={'line-clamp-2'}>{item.description}</p>
</div> </div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500 '}>Website</p>
<p className={'line-clamp-2'}>
{dataFormatter.websitesOneListFormatter(item.website)}
</p>
</div>
</Link> </Link>
<ListActionsPopover <ListActionsPopover
onDelete={onDelete} onDelete={onDelete}

15
frontend/src/components/Ai_agents/TableAi_agents.tsx
View File

@ -20,8 +20,6 @@ import _ from 'lodash';
import dataFormatter from '../../helpers/dataFormatter'; import dataFormatter from '../../helpers/dataFormatter';
import { dataGridStyles } from '../../styles'; import { dataGridStyles } from '../../styles';
import CardAi_agents from './CardAi_agents';
const perPage = 10; const perPage = 10;
const TableSampleAi_agents = ({ const TableSampleAi_agents = ({
@ -466,18 +464,7 @@ const TableSampleAi_agents = ({
<p>Are you sure you want to delete this item?</p> <p>Are you sure you want to delete this item?</p>
</CardBoxModal> </CardBoxModal>
{ai_agents && Array.isArray(ai_agents) && !showGrid && ( {dataGrid}
<CardAi_agents
ai_agents={ai_agents}
loading={loading}
onDelete={handleDeleteModalAction}
currentPage={currentPage}
numPages={numPages}
onPageChange={onPageChange}
/>
)}
{showGrid && dataGrid}
{selectedRows.length > 0 && {selectedRows.length > 0 &&
createPortal( createPortal(

20
frontend/src/components/Ai_agents/configureAi_agentsCols.tsx
View File

@ -74,26 +74,6 @@ export const loadColumns = async (
editable: hasUpdatePermission, editable: hasUpdatePermission,
}, },
{
field: 'website',
headerName: 'Website',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: hasUpdatePermission,
sortable: false,
type: 'singleSelect',
getOptionValue: (value: any) => value?.id,
getOptionLabel: (value: any) => value?.label,
valueOptions: await callOptionsApi('websites'),
valueGetter: (params: GridValueGetterParams) =>
params?.value?.id ?? params?.value,
},
{ {
field: 'actions', field: 'actions',
type: 'actions', type: 'actions',

2
frontend/src/components/AsideMenuItem.tsx
View File

@ -78,7 +78,7 @@ const AsideMenuItem = ({ item, isDropdownList = false }: Props) => {
isDropdownList ? 'px-6 text-sm' : '', isDropdownList ? 'px-6 text-sm' : '',
item.color item.color
? getButtonColor(item.color, false, true) ? getButtonColor(item.color, false, true)
: `${asideMenuItemStyle} text-white dark:text-white`, : `${asideMenuItemStyle}`,
isLinkActive isLinkActive
? `text-black ${activeLinkColor} dark:text-white dark:bg-dark-800` ? `text-black ${activeLinkColor} dark:text-white dark:bg-dark-800`
: '', : '',

2
frontend/src/components/AsideMenuLayer.tsx
View File

@ -68,7 +68,7 @@ export default function AsideMenuLayer({
className={`${className} zzz lg:py-2 lg:pl-2 w-60 fixed flex z-40 top-0 h-screen transition-position overflow-hidden`} className={`${className} zzz lg:py-2 lg:pl-2 w-60 fixed flex z-40 top-0 h-screen transition-position overflow-hidden`}
> >
<div <div
className={`flex-1 flex flex-col overflow-hidden !bg-blue-600 dark:!bg-blue-800 ${asideStyle}`} className={`flex-1 flex flex-col overflow-hidden dark:bg-dark-900 ${asideStyle}`}
> >
<div <div
className={`flex flex-row h-14 items-center justify-between ${asideBrandStyle}`} className={`flex flex-row h-14 items-center justify-between ${asideBrandStyle}`}

2
frontend/src/components/WebPageComponents/Footer.tsx
View File

@ -20,7 +20,7 @@ export default function WebSiteFooter({
const style = FooterStyle.WITH_PROJECT_NAME; const style = FooterStyle.WITH_PROJECT_NAME;
const design = FooterDesigns.DESIGN_DIVERSITY; const design = FooterDesigns.DEFAULT_DESIGN;
return ( return (
<div <div

2
frontend/src/components/WebPageComponents/Header.tsx
View File

@ -21,7 +21,7 @@ export default function WebSiteHeader({
const style = HeaderStyle.PAGES_LEFT; const style = HeaderStyle.PAGES_LEFT;
const design = HeaderDesigns.DEFAULT_DESIGN; const design = HeaderDesigns.DESIGN_DIVERSITY;
return ( return (
<header id='websiteHeader' className='overflow-hidden'> <header id='websiteHeader' className='overflow-hidden'>
<div <div

123
frontend/src/components/Websites/CardWebsites.tsx
View File

@ -1,123 +0,0 @@
import React from 'react';
import ImageField from '../ImageField';
import ListActionsPopover from '../ListActionsPopover';
import { useAppSelector } from '../../stores/hooks';
import dataFormatter from '../../helpers/dataFormatter';
import { Pagination } from '../Pagination';
import { saveFile } from '../../helpers/fileSaver';
import LoadingSpinner from '../LoadingSpinner';
import Link from 'next/link';
import { hasPermission } from '../../helpers/userPermissions';
type Props = {
websites: any[];
loading: boolean;
onDelete: (id: string) => void;
currentPage: number;
numPages: number;
onPageChange: (page: number) => void;
};
const CardWebsites = ({
websites,
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);
const currentUser = useAppSelector((state) => state.auth.currentUser);
const hasUpdatePermission = hasPermission(currentUser, 'UPDATE_WEBSITES');
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 &&
websites.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
}`}
>
<div
className={`flex items-center ${bgColor} p-6 gap-x-4 border-b border-gray-900/5 bg-gray-50 dark:bg-dark-800 relative`}
>
<Link
href={`/websites/websites-view/?id=${item.id}`}
className='text-lg font-bold leading-6 line-clamp-1'
>
{item.name}
</Link>
<div className='ml-auto '>
<ListActionsPopover
onDelete={onDelete}
itemId={item.id}
pathEdit={`/websites/websites-edit/?id=${item.id}`}
pathView={`/websites/websites-view/?id=${item.id}`}
hasUpdatePermission={hasUpdatePermission}
/>
</div>
</div>
<dl className='divide-y divide-stone-300 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'>Name</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>{item.name}</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className=' text-gray-500 dark:text-dark-600'>Url</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>{item.url}</div>
</dd>
</div>
<div className='flex justify-between gap-x-4 py-3'>
<dt className=' text-gray-500 dark:text-dark-600'>
Description
</dt>
<dd className='flex items-start gap-x-2'>
<div className='font-medium line-clamp-4'>
{item.description}
</div>
</dd>
</div>
</dl>
</li>
))}
{!loading && websites.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 CardWebsites;

100
frontend/src/components/Websites/ListWebsites.tsx
View File

@ -1,100 +0,0 @@
import React from 'react';
import CardBox from '../CardBox';
import ImageField from '../ImageField';
import dataFormatter from '../../helpers/dataFormatter';
import { saveFile } from '../../helpers/fileSaver';
import ListActionsPopover from '../ListActionsPopover';
import { useAppSelector } from '../../stores/hooks';
import { Pagination } from '../Pagination';
import LoadingSpinner from '../LoadingSpinner';
import Link from 'next/link';
import { hasPermission } from '../../helpers/userPermissions';
type Props = {
websites: any[];
loading: boolean;
onDelete: (id: string) => void;
currentPage: number;
numPages: number;
onPageChange: (page: number) => void;
};
const ListWebsites = ({
websites,
loading,
onDelete,
currentPage,
numPages,
onPageChange,
}: Props) => {
const currentUser = useAppSelector((state) => state.auth.currentUser);
const hasUpdatePermission = hasPermission(currentUser, 'UPDATE_WEBSITES');
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 &&
websites.map((item) => (
<CardBox
hasTable
isList
key={item.id}
className={'rounded shadow-none'}
>
<div
className={`flex rounded dark:bg-dark-900 border border-stone-300 items-center overflow-hidden`}
>
<Link
href={`/websites/websites-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 '}>Name</p>
<p className={'line-clamp-2'}>{item.name}</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500 '}>Url</p>
<p className={'line-clamp-2'}>{item.url}</p>
</div>
<div className={'flex-1 px-3'}>
<p className={'text-xs text-gray-500 '}>Description</p>
<p className={'line-clamp-2'}>{item.description}</p>
</div>
</Link>
<ListActionsPopover
onDelete={onDelete}
itemId={item.id}
pathEdit={`/websites/websites-edit/?id=${item.id}`}
pathView={`/websites/websites-view/?id=${item.id}`}
hasUpdatePermission={hasUpdatePermission}
/>
</div>
</CardBox>
))}
{!loading && websites.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 ListWebsites;

481
frontend/src/components/Websites/TableWebsites.tsx
View File

@ -1,481 +0,0 @@
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/websites/websitesSlice';
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 './configureWebsitesCols';
import _ from 'lodash';
import dataFormatter from '../../helpers/dataFormatter';
import { dataGridStyles } from '../../styles';
const perPage = 10;
const TableSampleWebsites = ({
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 {
websites,
loading,
count,
notify: websitesNotify,
refetch,
} = useAppSelector((state) => state.websites);
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 (websitesNotify.showNotification) {
notify(websitesNotify.typeNotification, websitesNotify.textNotification);
}
}, [websitesNotify.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(() => {
if (!currentUser) return;
loadColumns(handleDeleteModalAction, `websites`, currentUser).then(
(newCols) => setColumns(newCols),
);
}, [currentUser]);
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 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={websites ?? []}
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 TableSampleWebsites;

97
frontend/src/components/Websites/configureWebsitesCols.tsx
View File

@ -1,97 +0,0 @@
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 ImageField from '../ImageField';
import { saveFile } from '../../helpers/fileSaver';
import dataFormatter from '../../helpers/dataFormatter';
import DataGridMultiSelect from '../DataGridMultiSelect';
import ListActionsPopover from '../ListActionsPopover';
import { hasPermission } from '../../helpers/userPermissions';
type Params = (id: string) => void;
export const loadColumns = async (
onDelete: Params,
entityName: string,
user,
) => {
async function callOptionsApi(entityName: string) {
if (!hasPermission(user, 'READ_' + entityName.toUpperCase())) return [];
try {
const data = await axios(`/${entityName}/autocomplete?limit=100`);
return data.data;
} catch (error) {
console.log(error);
return [];
}
}
const hasUpdatePermission = hasPermission(user, 'UPDATE_WEBSITES');
return [
{
field: 'name',
headerName: 'Name',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: hasUpdatePermission,
},
{
field: 'url',
headerName: 'Url',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: hasUpdatePermission,
},
{
field: 'description',
headerName: 'Description',
flex: 1,
minWidth: 120,
filterable: false,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
editable: hasUpdatePermission,
},
{
field: 'actions',
type: 'actions',
minWidth: 30,
headerClassName: 'datagrid--header',
cellClassName: 'datagrid--cell',
getActions: (params: GridRowParams) => {
return [
<ListActionsPopover
onDelete={onDelete}
itemId={params?.row?.id}
pathEdit={`/websites/websites-edit/?id=${params?.row?.id}`}
pathView={`/websites/websites-view/?id=${params?.row?.id}`}
key={1}
hasUpdatePermission={hasUpdatePermission}
/>,
];
},
},
];
};

2
frontend/src/components/WidgetCreator/WidgetCreator.tsx
View File

@ -53,7 +53,7 @@ export const WidgetCreator = ({
resetForm: any, resetForm: any,
) => { ) => {
const description = values.description; const description = values.description;
const projectId = ''; const projectId = '31127';
const payload = { const payload = {
roleId: widgetsRole?.role?.value, roleId: widgetsRole?.role?.value,

19
frontend/src/helpers/dataFormatter.js
View File

@ -133,23 +133,4 @@ export default {
if (!val) return ''; if (!val) return '';
return { label: val.name, id: val.id }; return { label: val.name, id: val.id };
}, },
websitesManyListFormatter(val) {
if (!val || !val.length) return [];
return val.map((item) => item.name);
},
websitesOneListFormatter(val) {
if (!val) return '';
return val.name;
},
websitesManyListFormatterEdit(val) {
if (!val || !val.length) return [];
return val.map((item) => {
return { id: item.id, label: item.name };
});
},
websitesOneListFormatterEdit(val) {
if (!val) return '';
return { label: val.name, id: val.id };
},
}; };

8
frontend/src/menuAside.ts
View File

@ -62,14 +62,6 @@ const menuAside: MenuAsideItem[] = [
icon: icon.mdiTable ?? icon.mdiTable, icon: icon.mdiTable ?? icon.mdiTable,
permissions: 'READ_ORGANIZATIONS', permissions: 'READ_ORGANIZATIONS',
}, },
{
href: '/websites/websites-list',
label: 'Websites',
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
icon: icon.mdiWeb ?? icon.mdiTable,
permissions: 'READ_WEBSITES',
},
{ {
href: '/profile', href: '/profile',
label: 'Profile', label: 'Profile',

13
frontend/src/pages/ai_agents/[ai_agentsId].tsx
View File

@ -45,8 +45,6 @@ const EditAi_agents = () => {
description: '', description: '',
organizations: null, organizations: null,
website: null,
}; };
const [initialValues, setInitialValues] = useState(initVals); const [initialValues, setInitialValues] = useState(initVals);
@ -130,17 +128,6 @@ const EditAi_agents = () => {
></Field> ></Field>
</FormField> </FormField>
<FormField label='Website' labelFor='website'>
<Field
name='website'
id='website'
component={SelectField}
options={initialValues.website}
itemRef={'websites'}
showField={'name'}
></Field>
</FormField>
<BaseDivider /> <BaseDivider />
<BaseButtons> <BaseButtons>
<BaseButton type='submit' color='info' label='Submit' /> <BaseButton type='submit' color='info' label='Submit' />

13
frontend/src/pages/ai_agents/ai_agents-edit.tsx
View File

@ -45,8 +45,6 @@ const EditAi_agentsPage = () => {
description: '', description: '',
organizations: null, organizations: null,
website: null,
}; };
const [initialValues, setInitialValues] = useState(initVals); const [initialValues, setInitialValues] = useState(initVals);
@ -128,17 +126,6 @@ const EditAi_agentsPage = () => {
></Field> ></Field>
</FormField> </FormField>
<FormField label='Website' labelFor='website'>
<Field
name='website'
id='website'
component={SelectField}
options={initialValues.website}
itemRef={'websites'}
showField={'name'}
></Field>
</FormField>
<BaseDivider /> <BaseDivider />
<BaseButtons> <BaseButtons>
<BaseButton type='submit' color='info' label='Submit' /> <BaseButton type='submit' color='info' label='Submit' />

6
frontend/src/pages/ai_agents/ai_agents-list.tsx
View File

@ -32,8 +32,6 @@ const Ai_agentsTablesPage = () => {
{ label: 'AgentName', title: 'name' }, { label: 'AgentName', title: 'name' },
{ label: 'SitemapURL', title: 'sitemap_url' }, { label: 'SitemapURL', title: 'sitemap_url' },
{ label: 'Description', title: 'description' }, { label: 'Description', title: 'description' },
{ label: 'Website', title: 'website' },
]); ]);
const hasCreatePermission = const hasCreatePermission =
@ -127,10 +125,6 @@ const Ai_agentsTablesPage = () => {
<div className='md:inline-flex items-center ms-auto'> <div className='md:inline-flex items-center ms-auto'>
<div id='delete-rows-button'></div> <div id='delete-rows-button'></div>
</div> </div>
<div className='md:inline-flex items-center ms-auto'>
<Link href={'/ai_agents/ai_agents-table'}>Switch to Table</Link>
</div>
</CardBox> </CardBox>
<CardBox className='mb-6' hasTable> <CardBox className='mb-6' hasTable>

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

@ -40,8 +40,6 @@ const initialValues = {
description: '', description: '',
organizations: '', organizations: '',
website: '',
}; };
const Ai_agentsNew = () => { const Ai_agentsNew = () => {
@ -97,16 +95,6 @@ const Ai_agentsNew = () => {
></Field> ></Field>
</FormField> </FormField>
<FormField label='Website' labelFor='website'>
<Field
name='website'
id='website'
component={SelectField}
options={[]}
itemRef={'websites'}
></Field>
</FormField>
<BaseDivider /> <BaseDivider />
<BaseButtons> <BaseButtons>
<BaseButton type='submit' color='info' label='Submit' /> <BaseButton type='submit' color='info' label='Submit' />

4
frontend/src/pages/ai_agents/ai_agents-table.tsx
View File

@ -32,8 +32,6 @@ const Ai_agentsTablesPage = () => {
{ label: 'AgentName', title: 'name' }, { label: 'AgentName', title: 'name' },
{ label: 'SitemapURL', title: 'sitemap_url' }, { label: 'SitemapURL', title: 'sitemap_url' },
{ label: 'Description', title: 'description' }, { label: 'Description', title: 'description' },
{ label: 'Website', title: 'website' },
]); ]);
const hasCreatePermission = const hasCreatePermission =
@ -128,7 +126,7 @@ const Ai_agentsTablesPage = () => {
<div id='delete-rows-button'></div> <div id='delete-rows-button'></div>
<Link href={'/ai_agents/ai_agents-list'}> <Link href={'/ai_agents/ai_agents-list'}>
Back to <span className='capitalize'>card</span> Back to <span className='capitalize'>table</span>
</Link> </Link>
</div> </div>
</CardBox> </CardBox>

6
frontend/src/pages/ai_agents/ai_agents-view.tsx
View File

@ -83,12 +83,6 @@ const Ai_agentsView = () => {
<p>{ai_agents?.organizations?.name ?? 'No data'}</p> <p>{ai_agents?.organizations?.name ?? 'No data'}</p>
</div> </div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Website</p>
<p>{ai_agents?.website?.name ?? 'No data'}</p>
</div>
<> <>
<p className={'block font-bold mb-2'}>Interactions Agent</p> <p className={'block font-bold mb-2'}>Interactions Agent</p>
<CardBox <CardBox

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

@ -28,7 +28,6 @@ const Dashboard = () => {
const [roles, setRoles] = React.useState('Loading...'); const [roles, setRoles] = React.useState('Loading...');
const [permissions, setPermissions] = React.useState('Loading...'); const [permissions, setPermissions] = React.useState('Loading...');
const [organizations, setOrganizations] = React.useState('Loading...'); const [organizations, setOrganizations] = React.useState('Loading...');
const [websites, setWebsites] = React.useState('Loading...');
const [widgetsRole, setWidgetsRole] = React.useState({ const [widgetsRole, setWidgetsRole] = React.useState({
role: { value: '', label: '' }, role: { value: '', label: '' },
@ -48,7 +47,6 @@ const Dashboard = () => {
'roles', 'roles',
'permissions', 'permissions',
'organizations', 'organizations',
'websites',
]; ];
const fns = [ const fns = [
setUsers, setUsers,
@ -57,7 +55,6 @@ const Dashboard = () => {
setRoles, setRoles,
setPermissions, setPermissions,
setOrganizations, setOrganizations,
setWebsites,
]; ];
const requests = entities.map((entity, index) => { const requests = entities.map((entity, index) => {
@ -365,38 +362,6 @@ const Dashboard = () => {
</div> </div>
</Link> </Link>
)} )}
{hasPermission(currentUser, 'READ_WEBSITES') && (
<Link href={'/websites/websites-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'>
Websites
</div>
<div className='text-3xl leading-tight font-semibold'>
{websites}
</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> </div>
</SectionMain> </SectionMain>
</> </>

2
frontend/src/pages/index.tsx
View File

@ -134,7 +134,7 @@ export default function WebSite() {
<FeaturesSection <FeaturesSection
projectName={'website-ai-agents'} projectName={'website-ai-agents'}
image={['AI agents enhancing user experience']} image={['AI agents enhancing user experience']}
withBg={1} withBg={0}
features={features_points} features={features_points}
mainText={`Discover the Power of ${projectName}`} mainText={`Discover the Power of ${projectName}`}
subTitle={`Explore the innovative features of ${projectName} that enhance your website's functionality and user engagement.`} subTitle={`Explore the innovative features of ${projectName} that enhance your website's functionality and user engagement.`}

45
frontend/src/pages/organizations/organizations-view.tsx
View File

@ -208,51 +208,6 @@ const OrganizationsView = () => {
</CardBox> </CardBox>
</> </>
<>
<p className={'block font-bold mb-2'}>Websites organizations</p>
<CardBox
className='mb-6 border border-gray-300 rounded overflow-hidden'
hasTable
>
<div className='overflow-x-auto'>
<table>
<thead>
<tr>
<th>Name</th>
<th>Url</th>
<th>Description</th>
</tr>
</thead>
<tbody>
{organizations.websites_organizations &&
Array.isArray(organizations.websites_organizations) &&
organizations.websites_organizations.map((item: any) => (
<tr
key={item.id}
onClick={() =>
router.push(
`/websites/websites-view/?id=${item.id}`,
)
}
>
<td data-label='name'>{item.name}</td>
<td data-label='url'>{item.url}</td>
<td data-label='description'>{item.description}</td>
</tr>
))}
</tbody>
</table>
</div>
{!organizations?.websites_organizations?.length && (
<div className={'text-center py-4'}>No data</div>
)}
</CardBox>
</>
<BaseDivider /> <BaseDivider />
<BaseButton <BaseButton

153
frontend/src/pages/websites/[websitesId].tsx
View File

@ -1,153 +0,0 @@
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 FormFilePicker from '../../components/FormFilePicker';
import FormImagePicker from '../../components/FormImagePicker';
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/websites/websitesSlice';
import { useAppDispatch, useAppSelector } from '../../stores/hooks';
import { useRouter } from 'next/router';
import { saveFile } from '../../helpers/fileSaver';
import dataFormatter from '../../helpers/dataFormatter';
import ImageField from '../../components/ImageField';
import { hasPermission } from '../../helpers/userPermissions';
const EditWebsites = () => {
const router = useRouter();
const dispatch = useAppDispatch();
const initVals = {
organizations: null,
name: '',
url: '',
description: '',
};
const [initialValues, setInitialValues] = useState(initVals);
const { websites } = useAppSelector((state) => state.websites);
const { currentUser } = useAppSelector((state) => state.auth);
const { websitesId } = router.query;
useEffect(() => {
dispatch(fetch({ id: websitesId }));
}, [websitesId]);
useEffect(() => {
if (typeof websites === 'object') {
setInitialValues(websites);
}
}, [websites]);
useEffect(() => {
if (typeof websites === 'object') {
const newInitialVal = { ...initVals };
Object.keys(initVals).forEach((el) => (newInitialVal[el] = websites[el]));
setInitialValues(newInitialVal);
}
}, [websites]);
const handleSubmit = async (data) => {
await dispatch(update({ id: websitesId, data }));
await router.push('/websites/websites-list');
};
return (
<>
<Head>
<title>{getPageTitle('Edit websites')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton
icon={mdiChartTimelineVariant}
title={'Edit websites'}
main
>
{''}
</SectionTitleLineWithButton>
<CardBox>
<Formik
enableReinitialize
initialValues={initialValues}
onSubmit={(values) => handleSubmit(values)}
>
<Form>
<FormField label='organizations' labelFor='organizations'>
<Field
name='organizations'
id='organizations'
component={SelectField}
options={initialValues.organizations}
itemRef={'organizations'}
showField={'name'}
></Field>
</FormField>
<FormField label='Name'>
<Field name='name' placeholder='Name' />
</FormField>
<FormField label='Url'>
<Field name='url' placeholder='Url' />
</FormField>
<FormField label='Description'>
<Field name='description' placeholder='Description' />
</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('/websites/websites-list')}
/>
</BaseButtons>
</Form>
</Formik>
</CardBox>
</SectionMain>
</>
);
};
EditWebsites.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated permission={'UPDATE_WEBSITES'}>
{page}
</LayoutAuthenticated>
);
};
export default EditWebsites;

151
frontend/src/pages/websites/websites-edit.tsx
View File

@ -1,151 +0,0 @@
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 FormFilePicker from '../../components/FormFilePicker';
import FormImagePicker from '../../components/FormImagePicker';
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/websites/websitesSlice';
import { useAppDispatch, useAppSelector } from '../../stores/hooks';
import { useRouter } from 'next/router';
import { saveFile } from '../../helpers/fileSaver';
import dataFormatter from '../../helpers/dataFormatter';
import ImageField from '../../components/ImageField';
import { hasPermission } from '../../helpers/userPermissions';
const EditWebsitesPage = () => {
const router = useRouter();
const dispatch = useAppDispatch();
const initVals = {
organizations: null,
name: '',
url: '',
description: '',
};
const [initialValues, setInitialValues] = useState(initVals);
const { websites } = useAppSelector((state) => state.websites);
const { currentUser } = useAppSelector((state) => state.auth);
const { id } = router.query;
useEffect(() => {
dispatch(fetch({ id: id }));
}, [id]);
useEffect(() => {
if (typeof websites === 'object') {
setInitialValues(websites);
}
}, [websites]);
useEffect(() => {
if (typeof websites === 'object') {
const newInitialVal = { ...initVals };
Object.keys(initVals).forEach((el) => (newInitialVal[el] = websites[el]));
setInitialValues(newInitialVal);
}
}, [websites]);
const handleSubmit = async (data) => {
await dispatch(update({ id: id, data }));
await router.push('/websites/websites-list');
};
return (
<>
<Head>
<title>{getPageTitle('Edit websites')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton
icon={mdiChartTimelineVariant}
title={'Edit websites'}
main
>
{''}
</SectionTitleLineWithButton>
<CardBox>
<Formik
enableReinitialize
initialValues={initialValues}
onSubmit={(values) => handleSubmit(values)}
>
<Form>
<FormField label='organizations' labelFor='organizations'>
<Field
name='organizations'
id='organizations'
component={SelectField}
options={initialValues.organizations}
itemRef={'organizations'}
showField={'name'}
></Field>
</FormField>
<FormField label='Name'>
<Field name='name' placeholder='Name' />
</FormField>
<FormField label='Url'>
<Field name='url' placeholder='Url' />
</FormField>
<FormField label='Description'>
<Field name='description' placeholder='Description' />
</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('/websites/websites-list')}
/>
</BaseButtons>
</Form>
</Formik>
</CardBox>
</SectionMain>
</>
);
};
EditWebsitesPage.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated permission={'UPDATE_WEBSITES'}>
{page}
</LayoutAuthenticated>
);
};
export default EditWebsitesPage;

166
frontend/src/pages/websites/websites-list.tsx
View File

@ -1,166 +0,0 @@
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 TableWebsites from '../../components/Websites/TableWebsites';
import BaseButton from '../../components/BaseButton';
import axios from 'axios';
import Link from 'next/link';
import { useAppDispatch, useAppSelector } from '../../stores/hooks';
import CardBoxModal from '../../components/CardBoxModal';
import DragDropFilePicker from '../../components/DragDropFilePicker';
import { setRefetch, uploadCsv } from '../../stores/websites/websitesSlice';
import { hasPermission } from '../../helpers/userPermissions';
const WebsitesTablesPage = () => {
const [filterItems, setFilterItems] = useState([]);
const [csvFile, setCsvFile] = useState<File | null>(null);
const [isModalActive, setIsModalActive] = useState(false);
const [showTableView, setShowTableView] = useState(false);
const { currentUser } = useAppSelector((state) => state.auth);
const dispatch = useAppDispatch();
const [filters] = useState([
{ label: 'Name', title: 'name' },
{ label: 'Url', title: 'url' },
{ label: 'Description', title: 'description' },
]);
const hasCreatePermission =
currentUser && hasPermission(currentUser, 'CREATE_WEBSITES');
const addFilter = () => {
const newItem = {
id: uniqueId(),
fields: {
filterValue: '',
filterValueFrom: '',
filterValueTo: '',
selectedField: '',
},
};
newItem.fields.selectedField = filters[0].title;
setFilterItems([...filterItems, newItem]);
};
const getWebsitesCSV = async () => {
const response = await axios({
url: '/websites?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 = 'websitesCSV.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('Websites')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton
icon={mdiChartTimelineVariant}
title='Websites'
main
>
{''}
</SectionTitleLineWithButton>
<CardBox className='mb-6' cardBoxClassName='flex flex-wrap'>
{hasCreatePermission && (
<BaseButton
className={'mr-3'}
href={'/websites/websites-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={getWebsitesCSV}
/>
{hasCreatePermission && (
<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>
<TableWebsites
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>
</>
);
};
WebsitesTablesPage.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated permission={'READ_WEBSITES'}>
{page}
</LayoutAuthenticated>
);
};
export default WebsitesTablesPage;

122
frontend/src/pages/websites/websites-new.tsx
View File

@ -1,122 +0,0 @@
import {
mdiAccount,
mdiChartTimelineVariant,
mdiMail,
mdiUpload,
} 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 FormFilePicker from '../../components/FormFilePicker';
import FormImagePicker from '../../components/FormImagePicker';
import { SwitchField } from '../../components/SwitchField';
import { SelectField } from '../../components/SelectField';
import { SelectFieldMany } from '../../components/SelectFieldMany';
import { RichTextField } from '../../components/RichTextField';
import { create } from '../../stores/websites/websitesSlice';
import { useAppDispatch } from '../../stores/hooks';
import { useRouter } from 'next/router';
import moment from 'moment';
const initialValues = {
organizations: '',
name: '',
url: '',
description: '',
};
const WebsitesNew = () => {
const router = useRouter();
const dispatch = useAppDispatch();
const handleSubmit = async (data) => {
await dispatch(create(data));
await router.push('/websites/websites-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='organizations' labelFor='organizations'>
<Field
name='organizations'
id='organizations'
component={SelectField}
options={[]}
itemRef={'organizations'}
></Field>
</FormField>
<FormField label='Name'>
<Field name='name' placeholder='Name' />
</FormField>
<FormField label='Url'>
<Field name='url' placeholder='Url' />
</FormField>
<FormField label='Description'>
<Field name='description' placeholder='Description' />
</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('/websites/websites-list')}
/>
</BaseButtons>
</Form>
</Formik>
</CardBox>
</SectionMain>
</>
);
};
WebsitesNew.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated permission={'CREATE_WEBSITES'}>
{page}
</LayoutAuthenticated>
);
};
export default WebsitesNew;

165
frontend/src/pages/websites/websites-table.tsx
View File

@ -1,165 +0,0 @@
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 TableWebsites from '../../components/Websites/TableWebsites';
import BaseButton from '../../components/BaseButton';
import axios from 'axios';
import Link from 'next/link';
import { useAppDispatch, useAppSelector } from '../../stores/hooks';
import CardBoxModal from '../../components/CardBoxModal';
import DragDropFilePicker from '../../components/DragDropFilePicker';
import { setRefetch, uploadCsv } from '../../stores/websites/websitesSlice';
import { hasPermission } from '../../helpers/userPermissions';
const WebsitesTablesPage = () => {
const [filterItems, setFilterItems] = useState([]);
const [csvFile, setCsvFile] = useState<File | null>(null);
const [isModalActive, setIsModalActive] = useState(false);
const [showTableView, setShowTableView] = useState(false);
const { currentUser } = useAppSelector((state) => state.auth);
const dispatch = useAppDispatch();
const [filters] = useState([
{ label: 'Name', title: 'name' },
{ label: 'Url', title: 'url' },
{ label: 'Description', title: 'description' },
]);
const hasCreatePermission =
currentUser && hasPermission(currentUser, 'CREATE_WEBSITES');
const addFilter = () => {
const newItem = {
id: uniqueId(),
fields: {
filterValue: '',
filterValueFrom: '',
filterValueTo: '',
selectedField: '',
},
};
newItem.fields.selectedField = filters[0].title;
setFilterItems([...filterItems, newItem]);
};
const getWebsitesCSV = async () => {
const response = await axios({
url: '/websites?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 = 'websitesCSV.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('Websites')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton
icon={mdiChartTimelineVariant}
title='Websites'
main
>
{''}
</SectionTitleLineWithButton>
<CardBox className='mb-6' cardBoxClassName='flex flex-wrap'>
{hasCreatePermission && (
<BaseButton
className={'mr-3'}
href={'/websites/websites-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={getWebsitesCSV}
/>
{hasCreatePermission && (
<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>
<TableWebsites
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>
</>
);
};
WebsitesTablesPage.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated permission={'READ_WEBSITES'}>
{page}
</LayoutAuthenticated>
);
};
export default WebsitesTablesPage;

144
frontend/src/pages/websites/websites-view.tsx
View File

@ -1,144 +0,0 @@
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/websites/websitesSlice';
import { saveFile } from '../../helpers/fileSaver';
import dataFormatter from '../../helpers/dataFormatter';
import ImageField from '../../components/ImageField';
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';
import { hasPermission } from '../../helpers/userPermissions';
const WebsitesView = () => {
const router = useRouter();
const dispatch = useAppDispatch();
const { websites } = useAppSelector((state) => state.websites);
const { currentUser } = useAppSelector((state) => state.auth);
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 websites')}</title>
</Head>
<SectionMain>
<SectionTitleLineWithButton
icon={mdiChartTimelineVariant}
title={removeLastCharacter('View websites')}
main
>
<BaseButton
color='info'
label='Edit'
href={`/websites/websites-edit/?id=${id}`}
/>
</SectionTitleLineWithButton>
<CardBox>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>organizations</p>
<p>{websites?.organizations?.name ?? 'No data'}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Name</p>
<p>{websites?.name}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Url</p>
<p>{websites?.url}</p>
</div>
<div className={'mb-4'}>
<p className={'block font-bold mb-2'}>Description</p>
<p>{websites?.description}</p>
</div>
<>
<p className={'block font-bold mb-2'}>Ai_agents Website</p>
<CardBox
className='mb-6 border border-gray-300 rounded overflow-hidden'
hasTable
>
<div className='overflow-x-auto'>
<table>
<thead>
<tr>
<th>AgentName</th>
<th>SitemapURL</th>
</tr>
</thead>
<tbody>
{websites.ai_agents_website &&
Array.isArray(websites.ai_agents_website) &&
websites.ai_agents_website.map((item: any) => (
<tr
key={item.id}
onClick={() =>
router.push(
`/ai_agents/ai_agents-view/?id=${item.id}`,
)
}
>
<td data-label='name'>{item.name}</td>
<td data-label='sitemap_url'>{item.sitemap_url}</td>
</tr>
))}
</tbody>
</table>
</div>
{!websites?.ai_agents_website?.length && (
<div className={'text-center py-4'}>No data</div>
)}
</CardBox>
</>
<BaseDivider />
<BaseButton
color='info'
label='Back'
onClick={() => router.push('/websites/websites-list')}
/>
</CardBox>
</SectionMain>
</>
);
};
WebsitesView.getLayout = function getLayout(page: ReactElement) {
return (
<LayoutAuthenticated permission={'READ_WEBSITES'}>
{page}
</LayoutAuthenticated>
);
};
export default WebsitesView;

2
frontend/src/stores/store.ts
View File

@ -10,7 +10,6 @@ import interactionsSlice from './interactions/interactionsSlice';
import rolesSlice from './roles/rolesSlice'; import rolesSlice from './roles/rolesSlice';
import permissionsSlice from './permissions/permissionsSlice'; import permissionsSlice from './permissions/permissionsSlice';
import organizationsSlice from './organizations/organizationsSlice'; import organizationsSlice from './organizations/organizationsSlice';
import websitesSlice from './websites/websitesSlice';
export const store = configureStore({ export const store = configureStore({
reducer: { reducer: {
@ -25,7 +24,6 @@ export const store = configureStore({
roles: rolesSlice, roles: rolesSlice,
permissions: permissionsSlice, permissions: permissionsSlice,
organizations: organizationsSlice, organizations: organizationsSlice,
websites: websitesSlice,
}, },
}); });

236
frontend/src/stores/websites/websitesSlice.ts
View File

@ -1,236 +0,0 @@
import { createSlice, createAsyncThunk, PayloadAction } from '@reduxjs/toolkit';
import axios from 'axios';
import {
fulfilledNotify,
rejectNotify,
resetNotify,
} from '../../helpers/notifyStateHandler';
interface MainState {
websites: any;
loading: boolean;
count: number;
refetch: boolean;
rolesWidgets: any[];
notify: {
showNotification: boolean;
textNotification: string;
typeNotification: string;
};
}
const initialState: MainState = {
websites: [],
loading: false,
count: 0,
refetch: false,
rolesWidgets: [],
notify: {
showNotification: false,
textNotification: '',
typeNotification: 'warn',
},
};
export const fetch = createAsyncThunk('websites/fetch', async (data: any) => {
const { id, query } = data;
const result = await axios.get(`websites${query || (id ? `/${id}` : '')}`);
return id
? result.data
: { rows: result.data.rows, count: result.data.count };
});
export const deleteItemsByIds = createAsyncThunk(
'websites/deleteByIds',
async (data: any, { rejectWithValue }) => {
try {
await axios.post('websites/deleteByIds', { data });
} catch (error) {
if (!error.response) {
throw error;
}
return rejectWithValue(error.response.data);
}
},
);
export const deleteItem = createAsyncThunk(
'websites/deleteWebsites',
async (id: string, { rejectWithValue }) => {
try {
await axios.delete(`websites/${id}`);
} catch (error) {
if (!error.response) {
throw error;
}
return rejectWithValue(error.response.data);
}
},
);
export const create = createAsyncThunk(
'websites/createWebsites',
async (data: any, { rejectWithValue }) => {
try {
const result = await axios.post('websites', { data });
return result.data;
} catch (error) {
if (!error.response) {
throw error;
}
return rejectWithValue(error.response.data);
}
},
);
export const uploadCsv = createAsyncThunk(
'websites/uploadCsv',
async (file: File, { rejectWithValue }) => {
try {
const data = new FormData();
data.append('file', file);
data.append('filename', file.name);
const result = await axios.post('websites/bulk-import', data, {
headers: {
'Content-Type': 'multipart/form-data',
},
});
return result.data;
} catch (error) {
if (!error.response) {
throw error;
}
return rejectWithValue(error.response.data);
}
},
);
export const update = createAsyncThunk(
'websites/updateWebsites',
async (payload: any, { rejectWithValue }) => {
try {
const result = await axios.put(`websites/${payload.id}`, {
id: payload.id,
data: payload.data,
});
return result.data;
} catch (error) {
if (!error.response) {
throw error;
}
return rejectWithValue(error.response.data);
}
},
);
export const websitesSlice = createSlice({
name: 'websites',
initialState,
reducers: {
setRefetch: (state, action: PayloadAction<boolean>) => {
state.refetch = action.payload;
},
},
extraReducers: (builder) => {
builder.addCase(fetch.pending, (state) => {
state.loading = true;
resetNotify(state);
});
builder.addCase(fetch.rejected, (state, action) => {
state.loading = false;
rejectNotify(state, action);
});
builder.addCase(fetch.fulfilled, (state, action) => {
if (action.payload.rows && action.payload.count >= 0) {
state.websites = action.payload.rows;
state.count = action.payload.count;
} else {
state.websites = action.payload;
}
state.loading = false;
});
builder.addCase(deleteItemsByIds.pending, (state) => {
state.loading = true;
resetNotify(state);
});
builder.addCase(deleteItemsByIds.fulfilled, (state) => {
state.loading = false;
fulfilledNotify(state, 'Websites has been deleted');
});
builder.addCase(deleteItemsByIds.rejected, (state, action) => {
state.loading = false;
rejectNotify(state, action);
});
builder.addCase(deleteItem.pending, (state) => {
state.loading = true;
resetNotify(state);
});
builder.addCase(deleteItem.fulfilled, (state) => {
state.loading = false;
fulfilledNotify(state, `${'Websites'.slice(0, -1)} has been deleted`);
});
builder.addCase(deleteItem.rejected, (state, action) => {
state.loading = false;
rejectNotify(state, action);
});
builder.addCase(create.pending, (state) => {
state.loading = true;
resetNotify(state);
});
builder.addCase(create.rejected, (state, action) => {
state.loading = false;
rejectNotify(state, action);
});
builder.addCase(create.fulfilled, (state) => {
state.loading = false;
fulfilledNotify(state, `${'Websites'.slice(0, -1)} has been created`);
});
builder.addCase(update.pending, (state) => {
state.loading = true;
resetNotify(state);
});
builder.addCase(update.fulfilled, (state) => {
state.loading = false;
fulfilledNotify(state, `${'Websites'.slice(0, -1)} has been updated`);
});
builder.addCase(update.rejected, (state, action) => {
state.loading = false;
rejectNotify(state, action);
});
builder.addCase(uploadCsv.pending, (state) => {
state.loading = true;
resetNotify(state);
});
builder.addCase(uploadCsv.fulfilled, (state) => {
state.loading = false;
fulfilledNotify(state, 'Websites has been uploaded');
});
builder.addCase(uploadCsv.rejected, (state, action) => {
state.loading = false;
rejectNotify(state, action);
});
},
});
// Action creators are generated for each case reducer function
export const { setRefetch } = websitesSlice.actions;
export default websitesSlice.reducer;