Top 10 Examples of "simpl-schema in functional component" in JavaScript

// playerIds has changed since it was queried and the lobby might not
        // have any available slots left, loop and retry.
      }
    } catch (error) {
      console.error("Players.methods.ready", error);
    }
  }
});

export const updatePlayerData = new ValidatedMethod({
  name: "Players.methods.updateData",

  validate: new SimpleSchema({
    playerId: {
      type: String,
      regEx: SimpleSchema.RegEx.Id
    },
    key: {
      type: String
    },
    value: {
      type: String
    },
    append: {
      type: Boolean,
      optional: true
    },
    noCallback: {
      type: Boolean,
      optional: true
    }
  }).validator(),

* @param {String} fieldName
 */
Mongo.Collection.prototype.removeField = function (fieldName) {

  var collection = this;
  var schema = _.omit(collection.simpleSchema()._schema, fieldName);

  // add field schema to collection schema
  collection.attachSchema(schema, {replace: true});
};

/**
 * @summary Global schemas object. Note: not reactive, won't be updated after initialization
 */

SimpleSchema.prototype.getProfileFields = function () {
  var schema = this._schema;
  var fields = _.filter(_.keys(schema), function (fieldName) {
    var field = schema[fieldName];
    return !!field.profile;
  });
  return fields;
};

/**
 * @summary Get a list of a schema's private fields
 */
Mongo.Collection.prototype.getPrivateFields = function () {
  var schema = this.simpleSchema()._schema;
  var fields = _.filter(_.keys(schema), function (fieldName) {
    var field = schema[fieldName];
    return field.publish !== true;

import { check } from 'meteor/check'
import { sendMessage } from '/imports/api/activityLog/methods'


SimpleSchema.defineValidationErrorTransform(error => {
  const ddpError = new Meteor.Error(error.message);
  ddpError.error = 'validation-error';
  ddpError.details = error.details[0].message;
  return ddpError;
});



export const newProblem = new ValidatedMethod({
  name: 'newProblem',
	validate: new SimpleSchema(Problems.schema.pick("type","header","text","images","images.$","bounty"), {
		requiredByDefault: developmentValidationEnabledFalse
	}).validator({clean:true}),
  run({ type, header, text, images, bounty }) {
			if (Meteor.userId()) {
				if (bounty > 0) { // check if the user can finance the bounty
					let user = UserData.findOne({
						_id: Meteor.userId()
					})

					if (user.balance < bounty) {
						throw new Meteor.Error('Error.', 'messages.problems.insufficient_funds')
					}
				}

				Problems.insert({
					type: type,

constructor() {
    super('Opportunity', new SimpleSchema({
      name: { type: String },
      slugID: { type: String },
      description: { type: String },
      opportunityTypeID: { type: SimpleSchema.RegEx.Id },
      sponsorID: { type: SimpleSchema.RegEx.Id },
      interestIDs: [SimpleSchema.RegEx.Id],
      semesterIDs: [SimpleSchema.RegEx.Id],
      // Optional data
      eventDate: { type: Date, optional: true },
      ice: { type: Object, optional: true, blackbox: true },
      retired: { type: Boolean, optional: true },
    }));
  }

const linkedinFirstName = Utils.getNestedProperty(user, 'services.linkedin.firstName');
      if (profileName) return profileName;
      if (twitterName) return twitterName;
      if (linkedinFirstName) return `${linkedinFirstName} ${Utils.getNestedProperty(user, 'services.linkedin.lastName')}`;
      if (user.username) return user.username;
      return undefined;
    },
    searchable: true
  },
  /**
    The user's email. Modifiable.
  */
  email: {
    type: String,
    optional: true,
    regEx: SimpleSchema.RegEx.Email,
    mustComplete: true,
    control: "text",
    insertableBy: ['guests'],
    editableBy: ['members'],
    viewableBy: ownsOrIsAdmin,
    order: 20,
    onInsert: (user) => {
      // look in a few places for the user email
      const meteorEmails = Utils.getNestedProperty(user, 'services.meteor-developer.emails');
      const facebookEmail = Utils.getNestedProperty(user, 'services.facebook.email');
      const githubEmail = Utils.getNestedProperty(user, 'services.github.email');
      const googleEmail = Utils.getNestedProperty(user, 'services.google.email');
      const linkedinEmail = Utils.getNestedProperty(user, 'services.linkedin.emailAddress');

      if (meteorEmails) return _.findWhere(meteorEmails, { primary: true }).address;
      if (facebookEmail) return facebookEmail;

type: Array
  },
  'issues.$': {
    type: String
  },
  // 已投票使用者userId
  votes: {
    type: Array,
    defaultValue: []
  },
  'votes.$': {
    type: String
  },
  // 活躍玩家人數
  activeUserCount: {
    type: SimpleSchema.Integer,
    min: 0
  }
});
dbRuleAgendas.attachSchema(schema);

dbRuleAgendas.findByIdOrThrow = function(id, options) {
  const result = dbRuleAgendas.findOne(id, options);

  if (! result) {
    throw new Meteor.Error(404, `找不到識別碼為「${id}」的提案！`);
  }

  return result;
};

const schema = new SimpleSchema({
  // 商業季度
  seasonId: {
    type: String
  },
  // 使用者ID
  userId: {
    type: String
  },
  // 擁有現金
  money: {
    type: SimpleSchema.Integer
  },
  // 持股總價值
  stocksValue: {
    type: SimpleSchema.Integer
  }
});
dbRankUserWealth.attachSchema(schema);

},
  // 結束日期
  endDate: {
    type: Date
  },
  // 當季有多少驗證通過的使用者
  userCount: {
    type: SimpleSchema.Integer
  },
  // 當季起始時有多少未被查封的公司
  companiesCount: {
    type: SimpleSchema.Integer
  },
  // 當季有多少推出的新產品
  productCount: {
    type: SimpleSchema.Integer
  }
});
dbSeason.attachSchema(schema);

// 取得目前商業季度
export function getCurrentSeason() {
  return dbSeason.findOne({}, { sort: { beginDate: -1 } }); // TODO 以實際開始時間取代對齊的開始時間
}

// 取得前一個商業季度
export function getPreviousSeason() {
  return dbSeason.findOne({}, { sort: { beginDate: -1 }, skip: 1 });
}

// 每個使用者在季度一開始有多少推薦票
export function getInitialVoteTicketCount(seasonData) {

* @property {string} transactionId  optional: true, max: 40
 * @property {string} customerId  optional: true, max: 255
 */

/* prettier-ignore */
/**
 * SohaPay checkoutSchema
 * @type {SimpleSchema}
 */
SohaPay.checkoutSchema = new SimpleSchema({
	language				: { type: String, max: 16 },
	orderId					: { type: String, max: 34 },
	customerEmail			: { type: String, max: 24, regEx: SimpleSchema.RegEx.Email },
	customerPhone			: { type: String, max: 15 },
	returnUrl				: { type: String, max: 255 },
	amount					: { type: SimpleSchema.Integer, max: 9999999999 },
	paymentType				: { type: String, max: 1 },
	siteCode				: { type: String, max: 8 },
	transactionInfo			: { type: String, max: 255 },
	version					: { type: String, max: 1 },
	locale					: { type: String, optional: true, max: 2 },
	currency				: { type: String, optional: true, max: 4 },
	billingCity				: { type: String, optional: true, max: 64 },
	billingCountry			: { type: String, optional: true, max: 2 },
	billingPostCode			: { type: String, optional: true, max: 64 },
	billingStateProvince	: { type: String, optional: true, max: 64 },
	billingStreet			: { type: String, optional: true, max: 64 },
	deliveryAddress      	: { type: String, optional: true, max: 255 },
	deliveryCity         	: { type: String, optional: true, max: 255 },
	deliveryCountry      	: { type: String, optional: true, max: 255 },
	deliveryProvince     	: { type: String, optional: true, max: 255 },
	clientIp				: { type: String, optional: true, max: 15 },

// import { Meteor } from 'meteor/meteor'
import { ValidatedMethod } from 'meteor/mdg:validated-method'
import SimpleSchema from 'simpl-schema'

import { ExampleCollection } from './exampleCollection'

SimpleSchema.extendOptions(['autoform'])

// 4. after defining the schema, we have to define methods that will be used by our form
export const newExample = new ValidatedMethod({
    name: 'newExample', // this name is the method name used in quickForm template 
    validate: ExampleCollection.schema.validator({
    	clean: true, // clean has to be used here so autoValues can execute
    	filter: false // but we don't want to filter out other fields
    }),
    run({ name, description, tags, accept, numValue, number, radio, author, createdAt }) {
        // execute any arbitary code here
        
    	ExampleCollection.insert({
    		name: name,
            description: description,
            tags: tags,
            accept: accept,