@syngrisi/syngrisi/dist/server/utils/calculateAcceptedStatus.js

Syngrisi - Visual Testing Tool

// src/server/models/Check.model.ts
import mongoose2, { Schema } from "mongoose";

// src/server/models/plugins/paginate.plugin.ts
var paginate = (schema) => {
  schema.statics.paginate = async function(filter, options) {
    let sort;
    if (options.sortBy) {
      const sortingCriteria = [];
      let primaryOrder = "desc";
      options.sortBy.split(",").forEach((sortOption, index) => {
        const [key, order] = sortOption.split(":");
        if (index === 0) primaryOrder = order || "asc";
        sortingCriteria.push((order === "desc" ? "-" : "") + key);
      });
      if (!sortingCriteria.some((s) => s === "_id" || s === "-_id")) {
        sortingCriteria.push((primaryOrder === "desc" ? "-" : "") + "_id");
      }
      sort = sortingCriteria.join(" ");
    } else {
      sort = { _id: -1 };
    }
    const limit = options.limit && parseInt(options.limit.toString(), 10) >= 0 ? parseInt(options.limit.toString(), 10) : 10;
    const page = options.page && parseInt(options.page.toString(), 10) > 0 ? parseInt(options.page.toString(), 10) : 1;
    const skip = (page - 1) * limit;
    const countStrategy = options.countStrategy ?? (filter && Object.keys(filter).length === 0 ? "estimated" : "exact");
    const countPromise = countStrategy === "estimated" ? this.estimatedDocumentCount().exec() : this.countDocuments(filter).exec();
    let docsPromise = this.find(filter).sort(sort).skip(skip).limit(limit);
    if (options.populate) {
      options.populate.split(",").forEach((populateOption) => {
        docsPromise = docsPromise.populate(
          populateOption.split(".").reverse().reduce((a, b) => ({ path: b, populate: a }))
        );
      });
    }
    docsPromise = docsPromise.exec();
    return Promise.all([countPromise, docsPromise]).then((values) => {
      const [totalResults, results] = values;
      const totalPages = Math.ceil(totalResults / limit);
      const result = {
        results,
        page,
        limit,
        totalPages,
        totalResults,
        timestamp: Number(Date.now() + String(process.hrtime()[1]).slice(3, 6))
      };
      return Promise.resolve(result);
    });
  };
};
var paginate_plugin_default = paginate;

// src/server/models/plugins/toJSON.plugin.ts
var deleteAtPath = (obj, path, index) => {
  if (index === path.length - 1) {
    delete obj[path[index]];
    return;
  }
  deleteAtPath(obj[path[index]], path, index + 1);
};
var toJSON = (schema) => {
  let transform;
  if (schema.options.toJSON && schema.options.toJSON.transform) {
    transform = schema.options.toJSON.transform;
  }
  schema.options.toJSON = Object.assign(schema.options.toJSON || {}, {
    transform(doc, ret, options) {
      Object.keys(schema.paths).forEach((path) => {
        if (schema.paths[path].options && schema.paths[path].options.private) {
          deleteAtPath(ret, path.split("."), 0);
        }
      });
      ret.id = ret._id.toString();
      delete ret.__v;
      delete ret.createdAt;
      delete ret.updatedAt;
      if (transform) {
        return transform(doc, ret, options);
      }
    }
  });
};
var toJSON_plugin_default = toJSON;

// src/server/utils/isJSON.ts
var isJSON = (text) => {
  if (!text) return false;
  const isValid = /^[\],:{}\s]*$/.test(
    text.replace(/\\["\\\/bfnrtu]/g, "@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]").replace(/(?:^|:|,)(?:\s*\[)+/g, "")
  );
  return isValid;
};
var isJSON_default = isJSON;

// src/server/utils/deserializeIfJSON.ts
import mongoose from "mongoose";
var { EJSON } = mongoose.mongo.BSON;
var EXTENDED_JSON_KEYS = [
  "$oid",
  "$date",
  "$numberInt",
  "$numberLong",
  "$numberDouble",
  "$numberDecimal",
  "$regularExpression",
  "$binary",
  "$timestamp"
];
var containsExtendedJsonMarkers = (text) => EXTENDED_JSON_KEYS.some((marker) => text.includes(`"${marker}"`));
var deserializeIfJSON = (text) => {
  if (isJSON_default(text)) {
    if (containsExtendedJsonMarkers(text)) {
      return EJSON.parse(text) || void 0;
    }
    return JSON.parse(text) || void 0;
  }
  return text;
};
var deserializeIfJSON_default = deserializeIfJSON;

// src/server/utils/hash.ts
import { createHash, randomUUID } from "crypto";

// src/server/models/Check.model.ts
var CheckSchema = new Schema({
  name: {
    type: String,
    required: [true, 'CheckSchema: The "name" field must be required']
  },
  test: {
    type: Schema.Types.ObjectId,
    ref: "VRSTest",
    required: [true, 'CheckSchema: The "test" field must be required']
  },
  suite: {
    type: Schema.Types.ObjectId,
    ref: "VRSSuite",
    required: [true, 'CheckSchema: The "suite" field must be required']
  },
  app: {
    type: Schema.Types.ObjectId,
    ref: "VRSApp",
    required: [true, 'CheckSchema: The "app" field must be required']
  },
  branch: {
    type: String
  },
  realBaselineId: {
    type: Schema.Types.ObjectId,
    ref: "VRSBaseline"
  },
  baselineId: {
    type: Schema.Types.ObjectId,
    ref: "VRSSnapshot"
  },
  actualSnapshotId: {
    type: Schema.Types.ObjectId,
    ref: "VRSSnapshot"
  },
  diffId: {
    type: Schema.Types.ObjectId,
    ref: "VRSSnapshot"
  },
  createdDate: {
    type: Date,
    required: true,
    default: Date.now
  },
  updatedDate: {
    type: Date
  },
  status: {
    type: [{
      type: String,
      enum: {
        values: ["new", "pending", "approved", "running", "passed", "failed", "aborted"],
        message: "status is required"
      }
    }],
    default: ["new"]
  },
  browserName: {
    type: String
  },
  browserVersion: {
    type: String
  },
  browserFullVersion: {
    type: String
  },
  viewport: {
    type: String
  },
  os: {
    type: String
  },
  domDump: {
    type: String
  },
  result: {
    type: String,
    default: "{}"
  },
  run: {
    type: Schema.Types.ObjectId
  },
  markedAs: {
    type: String,
    enum: ["bug", "accepted"]
  },
  markedDate: {
    type: Date
  },
  markedById: {
    type: Schema.Types.ObjectId,
    ref: "VRSUser"
  },
  markedByUsername: {
    type: String
  },
  markedBugComment: {
    type: String
  },
  creatorId: {
    type: Schema.Types.ObjectId,
    ref: "VRSUser"
  },
  creatorUsername: {
    type: String
  },
  failReasons: {
    type: [String]
  },
  vOffset: {
    type: String
  },
  topStablePixels: {
    type: String
  },
  toleranceThreshold: {
    type: Number,
    min: 0,
    max: 100
  },
  meta: {
    type: Object
  }
});
CheckSchema.plugin(toJSON_plugin_default);
CheckSchema.plugin(paginate_plugin_default);
var Check = mongoose2.model("VRSCheck", CheckSchema);
var Check_model_default = Check;

// src/server/models/Log.model.ts
import mongoose3, { Schema as Schema2 } from "mongoose";
var LogSchema = new Schema2({
  timestamp: {
    type: Date
  },
  level: {
    type: String
  },
  message: {
    type: String
  },
  meta: {
    type: Object
  },
  hostname: {
    type: Object
  }
});
LogSchema.plugin(toJSON_plugin_default);
LogSchema.plugin(paginate_plugin_default);
var Log = mongoose3.model("VRSLog", LogSchema);

// src/server/models/App.model.ts
import mongoose4, { Schema as Schema3 } from "mongoose";
var AppSchema = new Schema3({
  name: {
    type: String,
    default: "Others",
    unique: true,
    required: [true, 'AppSchema: The "name" field must be required']
  },
  description: {
    type: String
  },
  version: {
    type: String
  },
  updatedDate: {
    type: Date
  },
  createdDate: {
    type: Date
  },
  meta: {
    type: Object
  }
});
AppSchema.plugin(paginate_plugin_default);
AppSchema.plugin(toJSON_plugin_default);
var App = mongoose4.model("VRSApp", AppSchema);

// src/server/models/Snapshot.model.ts
import mongoose5, { Schema as Schema4 } from "mongoose";
var SnapshotSchema = new Schema4({
  name: {
    type: String,
    required: [true, 'SnapshotSchema: The "name" field must be required']
  },
  path: {
    type: String
  },
  filename: {
    type: String
  },
  imghash: {
    type: String,
    required: [true, 'SnapshotSchema: The "imghash" field must be required']
  },
  createdDate: {
    type: Date,
    default: Date.now
  },
  vOffset: {
    type: Number
  },
  hOffset: {
    type: Number
  }
});
SnapshotSchema.plugin(toJSON_plugin_default);
SnapshotSchema.plugin(paginate_plugin_default);
var Snapshot = mongoose5.model("VRSSnapshot", SnapshotSchema);

// src/server/models/AppSettings.model.ts
import mongoose6, { Schema as Schema5 } from "mongoose";
var AppSettingsSchema = new Schema5({
  name: {
    type: String,
    unique: true,
    required: [true, 'AppSettingsSchema: The "name" field must be required']
  },
  label: {
    type: String,
    required: [true, 'AppSettingsSchema: The "label" field must be required']
  },
  description: {
    type: String
  },
  type: {
    type: String,
    required: [true, 'AppSettingsSchema: The "type" field must be required']
  },
  value: {
    type: Schema5.Types.Mixed,
    required: [true, 'AppSettingsSchema: The "value" field must be required']
  },
  env_variable: {
    type: String
  },
  enabled: {
    type: Boolean
  }
});
AppSettingsSchema.plugin(toJSON_plugin_default);
var AppSettings = mongoose6.model("VRSAppSettings", AppSettingsSchema);

// src/server/models/Suite.model.ts
import mongoose7, { Schema as Schema6 } from "mongoose";
var SuiteSchema = new Schema6({
  name: {
    type: String,
    default: "Others",
    unique: true,
    required: [true, 'SuiteSchema: The "name" field must be required']
  },
  tags: {
    type: [String]
  },
  app: {
    type: Schema6.Types.ObjectId,
    ref: "VRSApp",
    required: [true, 'SuiteSchema: The "app" field must be required']
  },
  description: {
    type: String
  },
  updatedDate: {
    type: Date,
    default: Date.now
  },
  createdDate: {
    type: Date
  },
  meta: {
    type: Object
  }
});
SuiteSchema.plugin(paginate_plugin_default);
SuiteSchema.plugin(toJSON_plugin_default);
var Suite = mongoose7.model("VRSSuite", SuiteSchema);

// src/server/models/Run.model.ts
import mongoose8, { Schema as Schema7 } from "mongoose";
var RunSchema = new Schema7({
  name: {
    type: String,
    required: [true, 'RunSchema: The "name" field must be required']
  },
  app: {
    type: Schema7.Types.ObjectId,
    ref: "VRSApp",
    required: [true, 'RunSchema: The "app" field must be required']
  },
  ident: {
    type: String,
    unique: true,
    required: [true, 'RunSchema: The "ident" field must be required']
  },
  description: {
    type: String
  },
  updatedDate: {
    type: Date,
    default: Date.now
  },
  createdDate: {
    type: Date
  },
  parameters: {
    type: [String]
  },
  meta: {
    type: Object
  }
});
RunSchema.plugin(paginate_plugin_default);
RunSchema.plugin(toJSON_plugin_default);
var Run = mongoose8.model("VRSRun", RunSchema);

// src/server/models/User.model.ts
import mongoose9, { Schema as Schema8 } from "mongoose";
import plm from "passport-local-mongoose";
var passportLocalMongoose = plm.default || plm;
var UserSchema = new Schema8({
  username: {
    type: String,
    unique: true,
    required: [true, 'UserSchema: The "username" field must be required']
  },
  firstName: {
    type: String,
    required: [true, 'UserSchema: The "firstName" field must be required']
  },
  lastName: {
    type: String,
    required: [true, 'UserSchema: The "lastName" field must be required']
  },
  role: {
    type: String,
    enum: ["admin", "reviewer", "user"],
    required: [true, 'UserSchema: The "role" field must be required']
  },
  provider: {
    type: String,
    default: "local"
  },
  providerId: {
    type: String
  },
  password: {
    type: String
  },
  token: {
    type: String
  },
  apiKey: {
    type: String
  },
  authSource: {
    type: String,
    enum: ["local", "jwt", "ldap", "api"],
    default: "local"
  },
  createdDate: {
    type: Date
  },
  updatedDate: {
    type: Date
  },
  expiration: {
    type: Date
  },
  meta: {
    type: Object
  }
});
UserSchema.statics.isEmailTaken = async function(username, excludeUserId) {
  const user = await this.findOne({ username, _id: { $ne: excludeUserId } });
  return !!user;
};
UserSchema.plugin(toJSON_plugin_default);
UserSchema.plugin(paginate_plugin_default);
UserSchema.plugin(passportLocalMongoose, { hashField: "password" });
var User = mongoose9.model("VRSUser", UserSchema);

// src/server/models/Baseline.model.ts
import mongoose10, { Schema as Schema9 } from "mongoose";
var BaselineSchema = new Schema9({
  snapshootId: {
    type: Schema9.Types.ObjectId,
    ref: "VRSSnapshot"
  },
  name: {
    type: String,
    required: [true, 'VRSBaselineSchema: The "name" field must be required']
  },
  app: {
    type: Schema9.Types.ObjectId,
    ref: "VRSApp",
    required: [true, 'VRSBaselineSchema: The "app" field must be required']
  },
  branch: {
    type: String
  },
  browserName: {
    type: String
  },
  browserVersion: {
    type: String
  },
  browserFullVersion: {
    type: String
  },
  viewport: {
    type: String
  },
  os: {
    type: String
  },
  markedAs: {
    type: String,
    enum: ["bug", "accepted"]
  },
  lastMarkedDate: {
    type: Date
  },
  createdDate: {
    type: Date
  },
  updatedDate: {
    type: Date
  },
  markedById: {
    type: Schema9.Types.ObjectId,
    ref: "VRSUser"
  },
  markedByUsername: {
    type: String
  },
  ignoreRegions: {
    type: String
  },
  boundRegions: {
    type: String
  },
  matchType: {
    type: String,
    enum: ["antialiasing", "nothing", "colors"]
  },
  toleranceThreshold: {
    type: Number,
    default: 0,
    min: 0,
    max: 100
  },
  meta: {
    type: Object
  }
});
BaselineSchema.set("autoIndex", false);
BaselineSchema.plugin(toJSON_plugin_default);
BaselineSchema.plugin(paginate_plugin_default);
BaselineSchema.index({
  name: 1,
  app: 1,
  branch: 1,
  browserName: 1,
  viewport: 1,
  os: 1,
  snapshootId: 1
}, { unique: true, name: "baseline_ident_snapshot_idx" });
var Baseline = mongoose10.model("VRSBaseline", BaselineSchema);

// src/server/models/Test.model.ts
import mongoose11, { Schema as Schema10 } from "mongoose";
var TestSchema = new Schema10(
  {
    name: {
      type: String,
      required: "TestSchema: the test name is empty"
    },
    description: {
      type: String
    },
    status: {
      type: String
    },
    browserName: {
      type: String
    },
    browserVersion: {
      type: String
    },
    branch: {
      type: String
    },
    tags: {
      type: [String]
    },
    viewport: {
      type: String
    },
    calculatedViewport: {
      type: String
    },
    os: {
      type: String
    },
    app: {
      type: Schema10.Types.ObjectId,
      ref: "VRSApp",
      required: [true, 'TestSchema: The "app" field must be required']
    },
    blinking: {
      type: Number,
      default: 0
    },
    updatedDate: {
      type: Date
    },
    startDate: {
      type: Date
    },
    checks: [
      {
        type: mongoose11.Schema.Types.ObjectId,
        ref: "VRSCheck"
      }
    ],
    suite: {
      type: Schema10.Types.ObjectId,
      ref: "VRSSuite"
    },
    run: {
      type: Schema10.Types.ObjectId,
      ref: "VRSRun"
    },
    markedAs: {
      type: String,
      enum: ["Bug", "Accepted", "Unaccepted", "Partially"]
    },
    creatorId: {
      type: Schema10.Types.ObjectId,
      ref: "VRSUser"
    },
    creatorUsername: {
      type: String
    },
    meta: {
      type: Object
    }
  },
  { strictQuery: true }
);
TestSchema.plugin(toJSON_plugin_default);
TestSchema.plugin(paginate_plugin_default);
TestSchema.statics.paginateDistinct = async function(filter, options) {
  let sort = { _id: -1 };
  if (options.sortBy) {
    sort = {};
    options.sortBy.split(",").forEach((sortOption) => {
      const [key, order] = sortOption.split(":");
      sort[key] = order === "desc" ? -1 : 1;
    });
  }
  let limit = options.limit && parseInt(options.limit.toString(), 10) >= 0 ? parseInt(options.limit.toString(), 10) : 10;
  limit = limit === 0 ? Number.MAX_SAFE_INTEGER : limit;
  const page = options.page && parseInt(options.page.toString(), 10) > 0 ? parseInt(options.page.toString(), 10) : 1;
  const skip = (page - 1) * limit;
  const groupAggregateObj = { $group: { _id: `$${options.field}` } };
  const parsedFilter = typeof filter?.filter === "string" ? deserializeIfJSON_default(filter.filter) || {} : {};
  const documentsCount = (await this.aggregate([{ $match: parsedFilter }, groupAggregateObj]).exec()).length;
  const aggregatedDocs = (await this.aggregate([
    { $match: parsedFilter },
    groupAggregateObj,
    { $sort: sort },
    { $skip: skip },
    { $limit: limit }
  ])).filter((x) => x._id).map((x) => {
    const fieldValue = options.field ? x[options.field] : void 0;
    if (Array.isArray(fieldValue) && fieldValue.length > 0) {
      return fieldValue[0];
    }
    return { name: x._id };
  });
  const totalPages = Math.ceil(documentsCount / limit);
  return {
    results: aggregatedDocs,
    page,
    limit,
    totalPages,
    totalResults: documentsCount,
    timestamp: Date.now()
  };
};
var Test = mongoose11.model("VRSTest", TestSchema);

// src/server/models/Webhook.model.ts
import mongoose12, { Schema as Schema11 } from "mongoose";
var WebhookSchema = new Schema11({
  url: {
    type: String,
    required: [true, 'WebhookSchema: The "url" field must be required']
  },
  events: {
    type: [String],
    default: ["check.updated", "check.created"]
  },
  secret: {
    type: String
  },
  createdDate: {
    type: Date,
    default: Date.now
  },
  meta: {
    type: Object
  }
});
WebhookSchema.plugin(paginate_plugin_default);
WebhookSchema.plugin(toJSON_plugin_default);
var Webhook = mongoose12.model("VRSWebhook", WebhookSchema);

// src/server/models/ShareToken.model.ts
import mongoose13, { Schema as Schema12 } from "mongoose";
var ShareTokenSchema = new Schema12({
  checkId: {
    type: Schema12.Types.ObjectId,
    ref: "VRSCheck",
    required: [true, 'ShareTokenSchema: The "checkId" field is required'],
    index: true
  },
  token: {
    type: String,
    required: [true, 'ShareTokenSchema: The "token" field is required'],
    unique: true,
    index: true
  },
  createdById: {
    type: Schema12.Types.ObjectId,
    ref: "VRSUser",
    required: [true, 'ShareTokenSchema: The "createdById" field is required']
  },
  createdByUsername: {
    type: String,
    required: [true, 'ShareTokenSchema: The "createdByUsername" field is required']
  },
  createdDate: {
    type: Date,
    required: true,
    default: Date.now
  },
  isRevoked: {
    type: Boolean,
    default: false
  },
  revokedDate: {
    type: Date
  },
  revokedById: {
    type: Schema12.Types.ObjectId,
    ref: "VRSUser"
  },
  revokedByUsername: {
    type: String
  }
});
ShareTokenSchema.plugin(toJSON_plugin_default);
ShareTokenSchema.plugin(paginate_plugin_default);
var ShareToken = mongoose13.model("VRSShareToken", ShareTokenSchema);

// src/server/models/DomSnapshot.model.ts
import mongoose14, { Schema as Schema13 } from "mongoose";
var DomSnapshotSchema = new Schema13({
  checkId: {
    type: Schema13.Types.ObjectId,
    ref: "VRSCheck",
    required: [true, 'DomSnapshotSchema: The "checkId" field is required'],
    index: true
  },
  baselineId: {
    type: Schema13.Types.ObjectId,
    ref: "VRSBaseline",
    index: true
  },
  type: {
    type: String,
    enum: ["actual", "baseline"],
    required: [true, 'DomSnapshotSchema: The "type" field is required']
  },
  filename: {
    type: String,
    required: [true, 'DomSnapshotSchema: The "filename" field is required']
  },
  hash: {
    type: String,
    required: [true, 'DomSnapshotSchema: The "hash" field is required'],
    index: true
  },
  compressed: {
    type: Boolean,
    default: false
  },
  originalSize: {
    type: Number,
    required: [true, 'DomSnapshotSchema: The "originalSize" field is required']
  },
  compressedSize: {
    type: Number
  },
  createdDate: {
    type: Date,
    default: Date.now
  }
});
DomSnapshotSchema.index({ checkId: 1, type: 1 });
DomSnapshotSchema.index({ baselineId: 1, type: 1 });
DomSnapshotSchema.plugin(toJSON_plugin_default);
DomSnapshotSchema.plugin(paginate_plugin_default);
var DomSnapshot = mongoose14.model("VRSDomSnapshot", DomSnapshotSchema);

// src/server/models/PluginSettings.model.ts
import mongoose15, { Schema as Schema14 } from "mongoose";
var PluginSettingSchemaDefinition = new Schema14({
  key: { type: String, required: true },
  label: { type: String, required: true },
  description: { type: String },
  type: {
    type: String,
    enum: ["string", "number", "boolean", "select", "password"],
    required: true
  },
  defaultValue: { type: Schema14.Types.Mixed },
  envVariable: { type: String },
  options: [{ value: String, label: String }],
  required: { type: Boolean, default: false }
}, { _id: false });
var PluginSettingsSchema = new Schema14({
  pluginName: {
    type: String,
    unique: true,
    required: [true, "PluginSettings: pluginName is required"],
    index: true
  },
  displayName: {
    type: String,
    required: [true, "PluginSettings: displayName is required"]
  },
  description: {
    type: String
  },
  enabled: {
    type: Boolean,
    default: false
  },
  settings: {
    type: Schema14.Types.Mixed,
    default: {}
  },
  settingsSchema: {
    type: [PluginSettingSchemaDefinition],
    default: []
  }
}, {
  timestamps: true
});
PluginSettingsSchema.plugin(toJSON_plugin_default);
PluginSettingsSchema.statics.getEffectiveConfig = async function(pluginName, envPrefix = "SYNGRISI_PLUGIN_") {
  const doc = await this.findOne({ pluginName });
  const envPluginKey = pluginName.toUpperCase().replace(/-/g, "_");
  const envEnabledKey = `${envPrefix}${envPluginKey}_ENABLED`;
  const envEnabled = process.env[envEnabledKey]?.toLowerCase() === "true";
  const dbEnabled = doc?.enabled;
  const enabled = doc ? dbEnabled : envEnabled;
  const config = {};
  const schema = doc?.settingsSchema || [];
  if (schema.length === 0 && doc?.settings && Object.keys(doc.settings).length > 0) {
    for (const [key, value] of Object.entries(doc.settings)) {
      config[key] = { value, source: "db" };
    }
    return { config, enabled };
  }
  for (const field of schema) {
    const envKey = field.envVariable || `${envPrefix}${envPluginKey}_${field.key.toUpperCase()}`;
    const envValue = process.env[envKey];
    const dbValue = doc?.settings?.[field.key];
    if (dbValue !== void 0) {
      config[field.key] = { value: dbValue, source: "db" };
    } else if (envValue !== void 0) {
      let parsedValue = envValue;
      if (field.type === "boolean") {
        parsedValue = envValue.toLowerCase() === "true";
      } else if (field.type === "number") {
        parsedValue = parseFloat(envValue);
      }
      config[field.key] = { value: parsedValue, source: "env" };
    } else if (field.defaultValue !== void 0) {
      config[field.key] = { value: field.defaultValue, source: "default" };
    }
  }
  return { config, enabled };
};
PluginSettingsSchema.statics.upsertSettings = async function(pluginName, updates) {
  return this.findOneAndUpdate(
    { pluginName },
    { $set: updates },
    { upsert: true, new: true, runValidators: true }
  );
};
var PluginSettings = mongoose15.model(
  "VRSPluginSettings",
  PluginSettingsSchema
);

// src/server/utils/calculateAcceptedStatus.ts
var calculateAcceptedStatus = async function calculateAcceptedStatus2(testId) {
  const checksInTest = await Check_model_default.find({ test: testId });
  const statuses = checksInTest.map((x) => x.markedAs);
  if (statuses.length < 1) {
    return "Unaccepted";
  }
  let testCalculatedStatus = "Unaccepted";
  if (statuses.some((x) => x === "accepted")) {
    testCalculatedStatus = "Partially";
  }
  if (statuses.every((x) => x === "accepted")) {
    testCalculatedStatus = "Accepted";
  }
  return testCalculatedStatus;
};
export {
  calculateAcceptedStatus
};
//# sourceMappingURL=calculateAcceptedStatus.js.map