Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/usr/local/lib/node_modules/strapi/node_modules/strapi-utils/lib/   drwxr-xr-x
Free 13.24 GB of 57.97 GB (22.84%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     models.js (13.11 KB)      -rw-r--r--

'use strict';

/**
 * Module dependencies
 */

// Public node modules.
const _ = require('lodash');
const pluralize = require('pluralize');

/*
 * Set of utils for models
 */
module.exports = {
  /**
   * Initialize to prevent some mistakes
   */

  initialize: cb => {
    cb();
  },

  /**
   * Retrieve the value based on the primary key
   */

  getValuePrimaryKey: (value, defaultKey) => {
    return value[defaultKey] || value.id || value._id;
  },

  /**
   * Find relation nature with verbose
   */

  getNature: ({ attribute, attributeName, modelName }) => {
    const types = {
      current: '',
      other: '',
    };

    const models = strapi.db.getModelsByPluginName(attribute.plugin);

    const pluginModels = Object.values(strapi.plugins).reduce((acc, plugin) => {
      return acc.concat(Object.values(plugin.models));
    }, []);

    const allModels = Object.values(strapi.models).concat(pluginModels);

    if (
      (_.has(attribute, 'collection') && attribute.collection === '*') ||
      (_.has(attribute, 'model') && attribute.model === '*')
    ) {
      if (attribute.model) {
        types.current = 'morphToD';
      } else {
        types.current = 'morphTo';
      }

      // We have to find if they are a model linked to this key
      _.forEach(allModels, model => {
        _.forIn(model.attributes, attribute => {
          if (_.has(attribute, 'via') && attribute.via === attributeName) {
            if (_.has(attribute, 'collection') && attribute.collection === modelName) {
              types.other = 'collection';

              // Break loop
              return false;
            } else if (_.has(attribute, 'model') && attribute.model === modelName) {
              types.other = 'modelD';

              // Break loop
              return false;
            }
          }
        });
      });
    } else if (_.has(attribute, 'via') && _.has(attribute, 'collection')) {
      const relatedAttribute = models[attribute.collection].attributes[attribute.via];

      if (!relatedAttribute) {
        throw new Error(
          `The attribute \`${attribute.via}\` is missing in the model ${_.upperFirst(
            attribute.collection
          )} ${attribute.plugin ? '(plugin - ' + attribute.plugin + ')' : ''}`
        );
      }

      types.current = 'collection';

      if (
        _.has(relatedAttribute, 'collection') &&
        relatedAttribute.collection !== '*' &&
        _.has(relatedAttribute, 'via')
      ) {
        types.other = 'collection';
      } else if (
        _.has(relatedAttribute, 'collection') &&
        relatedAttribute.collection !== '*' &&
        !_.has(relatedAttribute, 'via')
      ) {
        types.other = 'collectionD';
      } else if (_.has(relatedAttribute, 'model') && relatedAttribute.model !== '*') {
        types.other = 'model';
      } else if (_.has(relatedAttribute, 'collection') || _.has(relatedAttribute, 'model')) {
        types.other = 'morphTo';
      }
    } else if (_.has(attribute, 'via') && _.has(attribute, 'model')) {
      types.current = 'modelD';

      // We have to find if they are a model linked to this attributeName
      const model = models[attribute.model];

      const reverseAttribute = model.attributes[attribute.via];

      if (
        _.has(reverseAttribute, 'via') &&
        reverseAttribute.via === attributeName &&
        _.has(reverseAttribute, 'collection') &&
        reverseAttribute.collection !== '*'
      ) {
        types.other = 'collection';
      } else if (_.has(reverseAttribute, 'model') && reverseAttribute.model !== '*') {
        types.other = 'model';
      } else if (_.has(reverseAttribute, 'collection') || _.has(reverseAttribute, 'model')) {
        types.other = 'morphTo';
      }
    } else if (_.has(attribute, 'model')) {
      types.current = 'model';

      // We have to find if they are a model linked to this attributeName
      _.forIn(models, model => {
        _.forIn(model.attributes, attribute => {
          if (_.has(attribute, 'via') && attribute.via === attributeName) {
            if (_.has(attribute, 'collection') && attribute.collection === modelName) {
              types.other = 'collection';

              // Break loop
              return false;
            } else if (_.has(attribute, 'model') && attribute.model === modelName) {
              types.other = 'modelD';

              // Break loop
              return false;
            }
          }
        });
      });
    } else if (_.has(attribute, 'collection')) {
      types.current = 'collectionD';

      // We have to find if they are a model linked to this attributeName
      _.forIn(models, model => {
        _.forIn(model.attributes, attribute => {
          if (_.has(attribute, 'via') && attribute.via === attributeName) {
            if (_.has(attribute, 'collection') && attribute.collection === modelName) {
              types.other = 'collection';

              // Break loop
              return false;
            } else if (_.has(attribute, 'model') && attribute.model === modelName) {
              types.other = 'modelD';

              // Break loop
              return false;
            }
          }
        });
      });
    }

    if (types.current === 'collection' && types.other === 'morphTo') {
      return {
        nature: 'manyToManyMorph',
        verbose: 'morphMany',
      };
    } else if (types.current === 'collection' && types.other === 'morphToD') {
      return {
        nature: 'manyToOneMorph',
        verbose: 'morphMany',
      };
    } else if (types.current === 'modelD' && types.other === 'morphTo') {
      return {
        nature: 'oneToManyMorph',
        verbose: 'morphOne',
      };
    } else if (types.current === 'modelD' && types.other === 'morphToD') {
      return {
        nature: 'oneToOneMorph',
        verbose: 'morphOne',
      };
    } else if (types.current === 'morphToD' && types.other === 'collection') {
      return {
        nature: 'oneMorphToMany',
        verbose: 'belongsToMorph',
      };
    } else if (types.current === 'morphToD' && types.other === 'model') {
      return {
        nature: 'oneMorphToOne',
        verbose: 'belongsToMorph',
      };
    } else if (
      types.current === 'morphTo' &&
      (types.other === 'model' || _.has(attribute, 'model'))
    ) {
      return {
        nature: 'manyMorphToOne',
        verbose: 'belongsToManyMorph',
      };
    } else if (
      types.current === 'morphTo' &&
      (types.other === 'collection' || _.has(attribute, 'collection'))
    ) {
      return {
        nature: 'manyMorphToMany',
        verbose: 'belongsToManyMorph',
      };
    } else if (types.current === 'modelD' && types.other === 'model') {
      return {
        nature: 'oneToOne',
        verbose: 'belongsTo',
      };
    } else if (types.current === 'model' && types.other === 'modelD') {
      return {
        nature: 'oneToOne',
        verbose: 'hasOne',
      };
    } else if (
      (types.current === 'model' || types.current === 'modelD') &&
      types.other === 'collection'
    ) {
      return {
        nature: 'manyToOne',
        verbose: 'belongsTo',
      };
    } else if (types.current === 'modelD' && types.other === 'collection') {
      return {
        nature: 'oneToMany',
        verbose: 'hasMany',
      };
    } else if (types.current === 'collection' && types.other === 'model') {
      return {
        nature: 'oneToMany',
        verbose: 'hasMany',
      };
    } else if (types.current === 'collection' && types.other === 'collection') {
      return {
        nature: 'manyToMany',
        verbose: 'belongsToMany',
      };
    } else if (
      (types.current === 'collectionD' && types.other === 'collection') ||
      (types.current === 'collection' && types.other === 'collectionD')
    ) {
      return {
        nature: 'manyToMany',
        verbose: 'belongsToMany',
      };
    } else if (types.current === 'collectionD' && types.other === '') {
      return {
        nature: 'manyWay',
        verbose: 'belongsToMany',
      };
    } else if (types.current === 'model' && types.other === '') {
      return {
        nature: 'oneWay',
        verbose: 'belongsTo',
      };
    }

    return undefined;
  },

  /**
   * Return table name for a collection many-to-many
   */
  getCollectionName: (associationA, associationB) => {
    if (associationA.dominant && _.has(associationA, 'collectionName')) {
      return associationA.collectionName;
    }

    if (associationB.dominant && _.has(associationB, 'collectionName')) {
      return associationB.collectionName;
    }

    return [associationA, associationB]
      .sort((a, b) => {
        if (a.collection === b.collection) {
          if (a.dominant) return 1;
          else return -1;
        }
        return a.collection < b.collection ? -1 : 1;
      })
      .map(table =>
        _.snakeCase(`${pluralize.plural(table.collection)} ${pluralize.plural(table.via)}`)
      )
      .join('__');
  },

  /**
   * Define associations key to models
   */

  defineAssociations: function(model, definition, association, key) {
    try {
      // Initialize associations object
      if (definition.associations === undefined) {
        definition.associations = [];
      }

      // Exclude non-relational attribute
      if (!_.has(association, 'collection') && !_.has(association, 'model')) {
        return;
      }

      // Get relation nature
      let details;
      const targetName = association.model || association.collection || '';
      const infos = this.getNature({
        attribute: association,
        attributeName: key,
        modelName: model.toLowerCase(),
      });

      if (targetName !== '*') {
        const model = strapi.db.getModel(targetName, association.plugin);
        details = _.get(model, ['attributes', association.via], {});
      }

      // Build associations object
      if (_.has(association, 'collection') && association.collection !== '*') {
        const ast = {
          alias: key,
          type: 'collection',
          collection: association.collection,
          via: association.via || undefined,
          nature: infos.nature,
          autoPopulate: _.get(association, 'autoPopulate', true),
          dominant: details.dominant !== true,
          plugin: association.plugin || undefined,
          filter: details.filter,
        };

        if (infos.nature === 'manyToMany' && definition.orm === 'bookshelf') {
          ast.tableCollectionName = this.getCollectionName(details, association);
        }

        if (infos.nature === 'manyWay' && definition.orm === 'bookshelf') {
          ast.tableCollectionName =
            _.get(association, 'collectionName') ||
            `${definition.collectionName}__${_.snakeCase(key)}`;
        }
        definition.associations.push(ast);
        return;
      }

      if (_.has(association, 'model') && association.model !== '*') {
        definition.associations.push({
          alias: key,
          type: 'model',
          model: association.model,
          via: association.via || undefined,
          nature: infos.nature,
          autoPopulate: _.get(association, 'autoPopulate', true),
          dominant: details.dominant !== true,
          plugin: association.plugin || undefined,
          filter: details.filter,
        });
        return;
      }

      const pluginsModels = Object.keys(strapi.plugins).reduce((acc, current) => {
        Object.keys(strapi.plugins[current].models).forEach(entity => {
          Object.keys(strapi.plugins[current].models[entity].attributes).forEach(attribute => {
            const attr = strapi.plugins[current].models[entity].attributes[attribute];

            if ((attr.collection || attr.model || '').toLowerCase() === model.toLowerCase()) {
              acc.push(strapi.plugins[current].models[entity].globalId);
            }
          });
        });

        return acc;
      }, []);

      const appModels = Object.keys(strapi.models).reduce((acc, entity) => {
        Object.keys(strapi.models[entity].attributes).forEach(attribute => {
          const attr = strapi.models[entity].attributes[attribute];

          if ((attr.collection || attr.model || '').toLowerCase() === model.toLowerCase()) {
            acc.push(strapi.models[entity].globalId);
          }
        });

        return acc;
      }, []);

      const componentModels = Object.keys(strapi.components).reduce((acc, entity) => {
        Object.keys(strapi.components[entity].attributes).forEach(attribute => {
          const attr = strapi.components[entity].attributes[attribute];

          if ((attr.collection || attr.model || '').toLowerCase() === model.toLowerCase()) {
            acc.push(strapi.components[entity].globalId);
          }
        });

        return acc;
      }, []);

      const models = _.uniq(appModels.concat(pluginsModels).concat(componentModels));

      definition.associations.push({
        alias: key,
        type: association.model ? 'model' : 'collection',
        related: models,
        nature: infos.nature,
        autoPopulate: _.get(association, 'autoPopulate', true),
        filter: association.filter,
      });
    } catch (e) {
      strapi.log.error(
        `Something went wrong in the model \`${_.upperFirst(model)}\` with the attribute \`${key}\``
      );
      strapi.log.error(e);
      strapi.stop();
    }
  },
};