version1

.gitignore

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

backend/src/db/api/photos.js

@@ -11,17 +11,19 @@ module.exports = class PhotosDBApi {
     const currentUser = (options && options.currentUser) || { id: null };
     const transaction = (options && options.transaction) || undefined;
 
-    const photos = await db.photos.create(
+        const generatedCode = data.code || crypto.randomBytes(2).toString('hex').toUpperCase();
-      {
+        const photos = await db.photos.create(
-        id: data.id || undefined,
+          {
+            id: data.id || undefined,
 
-        url: data.url || null,
+            url: data.url || null,
-        locked: data.locked || false,
+            locked: data.locked || false,
 
-        importHash: data.importHash || null,
+            code: generatedCode,
-        createdById: currentUser.id,
+            importHash: data.importHash || null,
-        updatedById: currentUser.id,
+            createdById: currentUser.id,
-      },
+            updatedById: currentUser.id,
+          },
       { transaction },
     );
 

backend/src/db/api/photos.js.temp

@@ -0,0 +1,307 @@
+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 PhotosDBApi {
+  static async create(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+        const generatedCode = data.code || crypto.randomBytes(2).toString('hex').toUpperCase();
+        const photos = await db.photos.create(
+          {
+            id: data.id || undefined,
+
+            url: data.url || null,
+            locked: data.locked || false,
+
+            code: generatedCode,
+            importHash: data.importHash || null,
+            createdById: currentUser.id,
+            updatedById: currentUser.id,
+          },
+      { transaction },
+    );
+
+    await photos.setClient(data.client || null, {
+      transaction,
+    });
+
+    return photos;
+  }
+
+  static async bulkImport(data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    // Prepare data - wrapping individual data transformations in a map() method
+    const photosData = data.map((item, index) => {
+      const generatedCode = crypto.randomBytes(2).toString('hex').toUpperCase();
+      return {
+        id: item.id || undefined,
+
+        url: item.url || null,
+        locked: item.locked || false,
+
+        code: item.code || generatedCode,
+        importHash: item.importHash || null,
+        createdById: currentUser.id,
+        updatedById: currentUser.id,
+        createdAt: new Date(Date.now() + index * 1000),
+      };
+    });
+      createdAt: new Date(Date.now() + index * 1000),
+    }));
+
+    // Bulk create items
+    const photos = await db.photos.bulkCreate(photosData, { transaction });
+
+    // For each item created, replace relation files
+
+    return photos;
+  }
+
+  static async update(id, data, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const photos = await db.photos.findByPk(id, {}, { transaction });
+
+    const updatePayload = {};
+
+    if (data.url !== undefined) updatePayload.url = data.url;
+
+    if (data.locked !== undefined) updatePayload.locked = data.locked;
+
+    updatePayload.updatedById = currentUser.id;
+
+    await photos.update(updatePayload, { transaction });
+
+    if (data.client !== undefined) {
+      await photos.setClient(
+        data.client,
+
+        { transaction },
+      );
+    }
+
+    return photos;
+  }
+
+  static async deleteByIds(ids, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const photos = await db.photos.findAll({
+      where: {
+        id: {
+          [Op.in]: ids,
+        },
+      },
+      transaction,
+    });
+
+    await db.sequelize.transaction(async (transaction) => {
+      for (const record of photos) {
+        await record.update({ deletedBy: currentUser.id }, { transaction });
+      }
+      for (const record of photos) {
+        await record.destroy({ transaction });
+      }
+    });
+
+    return photos;
+  }
+
+  static async remove(id, options) {
+    const currentUser = (options && options.currentUser) || { id: null };
+    const transaction = (options && options.transaction) || undefined;
+
+    const photos = await db.photos.findByPk(id, options);
+
+    await photos.update(
+      {
+        deletedBy: currentUser.id,
+      },
+      {
+        transaction,
+      },
+    );
+
+    await photos.destroy({
+      transaction,
+    });
+
+    return photos;
+  }
+
+  static async findBy(where, options) {
+    const transaction = (options && options.transaction) || undefined;
+
+    const photos = await db.photos.findOne({ where }, { transaction });
+
+    if (!photos) {
+      return photos;
+    }
+
+    const output = photos.get({ plain: true });
+
+    output.client = await photos.getClient({
+      transaction,
+    });
+
+    return output;
+  }
+
+  static async findAll(filter, options) {
+    const limit = filter.limit || 0;
+    let offset = 0;
+    let where = {};
+    const currentPage = +filter.page;
+
+    offset = currentPage * limit;
+
+    const orderBy = null;
+
+    const transaction = (options && options.transaction) || undefined;
+
+    let include = [
+      {
+        model: db.clients,
+        as: 'client',
+
+        where: filter.client
+          ? {
+              [Op.or]: [
+                {
+                  id: {
+                    [Op.in]: filter.client
+                      .split('|')
+                      .map((term) => Utils.uuid(term)),
+                  },
+                },
+                {
+                  name: {
+                    [Op.or]: filter.client
+                      .split('|')
+                      .map((term) => ({ [Op.iLike]: `%${term}%` })),
+                  },
+                },
+              ],
+            }
+          : {},
+      },
+    ];
+
+    if (filter) {
+      if (filter.id) {
+        where = {
+          ...where,
+          ['id']: Utils.uuid(filter.id),
+        };
+      }
+
+      if (filter.url) {
+        where = {
+          ...where,
+          [Op.and]: Utils.ilike('photos', 'url', filter.url),
+        };
+      }
+
+      if (filter.active !== undefined) {
+        where = {
+          ...where,
+          active: filter.active === true || filter.active === 'true',
+        };
+      }
+
+      if (filter.locked) {
+        where = {
+          ...where,
+          locked: filter.locked,
+        };
+      }
+
+      if (filter.createdAtRange) {
+        const [start, end] = filter.createdAtRange;
+
+        if (start !== undefined && start !== null && start !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.gte]: start,
+            },
+          };
+        }
+
+        if (end !== undefined && end !== null && end !== '') {
+          where = {
+            ...where,
+            ['createdAt']: {
+              ...where.createdAt,
+              [Op.lte]: end,
+            },
+          };
+        }
+      }
+    }
+
+    const queryOptions = {
+      where,
+      include,
+      distinct: true,
+      order:
+        filter.field && filter.sort
+          ? [[filter.field, filter.sort]]
+          : [['createdAt', 'desc']],
+      transaction: options?.transaction,
+      logging: console.log,
+    };
+
+    if (!options?.countOnly) {
+      queryOptions.limit = limit ? Number(limit) : undefined;
+      queryOptions.offset = offset ? Number(offset) : undefined;
+    }
+
+    try {
+      const { rows, count } = await db.photos.findAndCountAll(queryOptions);
+
+      return {
+        rows: options?.countOnly ? [] : rows,
+        count: count,
+      };
+    } catch (error) {
+      console.error('Error executing query:', error);
+      throw error;
+    }
+  }
+
+  static async findAllAutocomplete(query, limit, offset) {
+    let where = {};
+
+    if (query) {
+      where = {
+        [Op.or]: [
+          { ['id']: Utils.uuid(query) },
+          Utils.ilike('photos', 'url', query),
+        ],
+      };
+    }
+
+    const records = await db.photos.findAll({
+      attributes: ['id', 'url'],
+      where,
+      limit: limit ? Number(limit) : undefined,
+      offset: offset ? Number(offset) : undefined,
+      orderBy: [['url', 'ASC']],
+    });
+
+    return records.map((record) => ({
+      id: record.id,
+      label: record.url,
+    }));
+  }
+};

frontend/src/pages/photos/photos-new.tsx

@@ -77,8 +77,15 @@ const PhotosNew = () => {
                 ></Field>
               </FormField>
 
-              <FormField label='URL'>
+              <FormField label='Photo' labelFor='url'>
-                <Field name='url' placeholder='URL' />
+                <Field
+                  name='url'
+                  component={FormFilePicker}
+                  accept='image/*'
+                  color='info'
+                  path='photos'
+                  schema={{}}
+                />
               </FormField>
 
               <FormField label='Locked' labelFor='locked'>