function getTv4() {
var tv4 = require('tv4');
var vesselSchema = require('../schemas/vessel.json');
tv4.addSchema('https://signalk.org/specification/1.0.0/schemas/vessel.json', vesselSchema);
var aircraftSchema = require('../schemas/aircraft.json');
tv4.addSchema('https://signalk.org/specification/1.0.0/schemas/aircraft.json', aircraftSchema);
var atonSchema = require('../schemas/aton.json');
tv4.addSchema('https://signalk.org/specification/1.0.0/schemas/aton.json', atonSchema);
var sarSchema = require('../schemas/sar.json');
tv4.addSchema('https://signalk.org/specification/1.0.0/schemas/sar.json', sarSchema);
var definitions = require('../schemas/definitions.json');
tv4.addSchema('https://signalk.org/specification/1.0.0/schemas/definitions.json', definitions);
for (var schema in subSchemas) {
tv4.addSchema('https://signalk.org/specification/1.0.0/schemas/groups/' + schema + '.json', subSchemas[schema]);
}
// HACK! two different IDs should not point to the same schema
var externalGeometry = require('../schemas/external/geojson/geometry.json');
tv4.addSchema('https://signalk.org/specification/1.0.0/schemas/external/geojson/geometry.json', externalGeometry);
tv4.addSchema('http://json-schema.org/geojson/geometry.json', externalGeometry);
tv4.addFormat(require('tv4-formats'))
return tv4;
}
describe('with additional tv4 formats', function() {
tv4.addFormat(require('tv4-formats'));
describe('validating an email address with format property', function() {
var emailValidation = validator(tv4, {
type: 'object',
properties: {
email: {
type: 'string',
format: 'email'
}
}
});
it('should reject invalid email addresses', function() {
var result = emailValidation({ email: 'test@example'});
expect(result.name).to.eql('ValidationError');
});
it('should accept valid email addresses', function() {
var result = emailValidation({ email: '*****@*****.**' });
expect(result).to.eql(null);
});
});
});
function registerCustomFormats() {
tv4.addFormat('email', validateEmail);
}
'use strict';
// For react
import React from 'react';
window.React = React;
import injectTapPlugin from 'react-tap-event-plugin';
injectTapPlugin();
import tv4 from 'tv4';
import i18n from './i18n';
tv4.addFormat('datetime', function(value) {
let time = Date.parse(value);
if (isNaN(time)) {
return i18n('Date time format failed');
} else {
return null;
}
});
import Router from 'react-router';
import routes from './components/Routes.jsx';
Router
.create({
routes: routes,
scrollBehavior: Router.ScrollTopBehavior
})
.run(Handler => {
React.render(<Handler />, document.body);
});
index.addAdditionalFormatForValidationSchemas = function(ref, fn) {
tv4.addFormat(ref, fn);
};
var JSV = require('jsvgcom').JSV;
var _ = require('lodash');
var jsonPath = require('json-path');
var traverse = require('traverse');
var tv4 = require('tv4');
tv4.addFormat(require('tv4-formats'));
var config = require('../support/config');
function JsonSchemaValidator(schemaVersion) {
schemaVersion = typeof schemaVersion !== 'undefined' ? schemaVersion : 'http://json-schema.org/draft-04/hyper-schema#';
this.version = schemaVersion;
}
JsonSchemaValidator.prototype.validate = function(schema, model) {
var data = removeNullUndefinedProperties(model.toObject());
if (this.version === 'http://json-schema.org/draft-04/hyper-schema#') {
return Draft4.validate(schema, data);
} else if (this.version === 'http://json-schema.org/draft-03/hyper-schema#') {
return Draft3.validate(schema, data);
} else {
return null;
}
};
var Draft3 = (function(){
function formatError(result) {
var errors = [];
import $ from 'jquery'
import cookie from 'cookies-js'
import Select from 'react-select'
import { Clearfix, Form, Glyphicon, ControlLabel, FormControl, FormGroup, HelpBlock, ButtonGroup, Well, Accordion, Button, ListGroupItem, ListGroup, Col, Row, PanelGroup, Panel } from 'react-bootstrap'
import { BigInput, SmallInput, Scaler } from './components.js'
import DateTimeField from "react-bootstrap-datetimepicker"
import 'react-bootstrap-datetimepicker/css/bootstrap-datetimepicker.min.css'
import 'react-select/dist/react-select.min.css'
import moment from 'moment'
import uuid from 'uuid'
import tv4 from 'tv4'
tv4.addFormat('datetime', function (data, schema) {
let datetimeRegex = /^\d\d\d\d-(0?[1-9]|1[0-2])-(0?[1-9]|[12][0-9]|3[01])T(00|[0-9]|1[0-9]|2[0-3]):([0-9]|[0-5][0-9]):([0-9]|[0-5][0-9])Z$/
if (typeof data !== 'string' || !datetimeRegex.test(data)) {
// return error message
return 'value must be string of the form: YYYY-MM-DD[T]HH:mm:ss[Z]'
}
return null
})
let structureSchema = {
"$schema": "http://json-schema.org/draft-04/schema#",
"definitions": {
"heading": {
"type": "object",
"properties": {
"type": {
"type": "string",
"enum": ["section", "title"],
},
"q_uuid": {
"type": "string",
var assert = require('assert');
var jsonValidator = require('tv4');
var validate = jsonValidator.validateMultiple;
var templates = require('../../lib/templates.json');
// Localization strings
var localeFile = require('../../locale/en_US/webmaker-app.json');
var localizedStrings = [];
Object.keys(localeFile).forEach(function (localizedStr) {
localizedStrings.push(localizedStr.toLowerCase());
});
jsonValidator.addFormat('localized', function (data) {
if(typeof data === 'string' && localizedStrings.indexOf(data.toLowerCase()) !== -1) {
// No error
return null;
}
return 'must be localized';
});
/*
* JSON schemas
*/
// Type schemas
var stringSchema = {
type: 'string'
};
var nonEmptyStringSchema = {
type: 'string',
minLength: 1
};
req.on('end', function(){
//Parse request body to JSON
try {
order = JSON.parse(order);
} catch(err){
//Ends a error response
common.sendResponse(res,false,common.buildErrorJSON("Couldn't parse the request body as a JSON."));
}
//Formatters for date/time format
tv4.addFormat({
'date-format': function (data,schema) {
if((data.length === 10) && !(null === data.match('[0-9]{2}-[0-9]{2}-[0-9]{4}'))){
return null;
} else {
return "Not a valid date"
}
},
'time-format': function (data) {
if((data.length === 9) && !(null === data.match('[0-9]{2}:[0-9]{2} CST'))){
return null;
} else {
return "Not a valid time"
}
}
});
//Verify JSON Schema for restaurant
var schema = {
"id": "Order",
"type": "object",
"properties": {
jsonId : {"type": "integer"},
jsonUser : {"type": "integer"},
jsonRestaurantId : {"type": "integer"},
jsonItemsToOrder : {"type": "string"},
jsonEstimatedCost : {"type": "number"},
jsonDesired : {
"type": "string"
},
jsonIsOrderOpen : {"type": "boolean"},
jsonDate : {
"type": "string"
},
},
"required": [ jsonUser, jsonRestaurantId, jsonItemsToOrder, jsonEstimatedCost, jsonDesiredTime, jsonIsOrderOpen, jsonDate ]
};
success = tv4.validate(order, schema);
if(success){
success = tv4.validateResult(order.date, {"format": "date-format"}).valid;
error = "JSON value for date has incorrect format should be: mm-dd-yyyy"
}
if(success){
success = tv4.validateResult(order.desiredTime, {"format": "time-format"}).valid;
error = "JSON value for desired time has incorrect format should be: HH:mm CST"
}
//If it is a valid JSON request
if(success){
//Format dates to SQL acceptable format
order.desiredTime = order.desiredTime.split(" ")[0]; // 12:20 CST -> 12:20
var parts = order.date.split("-");
order.date = parts[2]+'-'+parts[0]+'-'+parts[1]; //01-31-2015 -> 2015-01-31
if(type === 'PUT'){
//Verify the last url part is a number (If not success stays false)
if(!(isNaN(parseInt(lastRequestPath)))){
//For PUTs it calls a stored procedure it update the order if it exists
error = "Error updating restaurant: "+lastRequestPath;
queryStr = "CALL lunch_lady_land.updateOrder("+con.escape(order.id)+","+con.escape(order.itemsToOrder)+","+con.escape(order.estimatedCost)+","+con.escape(order.desiredTime)+","+con.escape(order.isOrderOpen)+","+con.escape(order.date)+","+con.escape(order.restaurantId)+","+con.escape(order.user)+")";
} else {
error = "Bad update restaurant request";
queryStr = "";
}
} else{
queryStr = "INSERT INTO lunch_lady_land.order (items_to_order,estimated_cost,desired_time,open,date,resturant_id,user_id) VALUES ("+con.escape(order.itemsToOrder)+"," + con.escape(order.estimatedCost) + ", "+con.escape(order.desiredTime)+","+con.escape(order.isOrderOpen)+", "+con.escape(order.date)+","+con.escape(order.restaurantId)+","+con.escape(order.user)+")";
error = "Error adding restaurant";
}
} else {
if(error === ""){
error = "JSON request body has an inncorect schema"
}
}
common.saveOrUpdateDB(res,con,order,queryStr,error);
});
'use strict';
var validationConstants = require('../../validationConstants');
var utils = require('../../../common/utils');
var fs = require('fs'),
path = require('path'),
tv4 = require('tv4');
tv4.addFormat('uri', function (data) {
if (!utils.isURL(data)) {
return '\'' + data + '\' is not a valid URL.';
}
return null;
});
var errorCodeLookup = {};
for (var key in tv4.errorCodes) {
errorCodeLookup[tv4.errorCodes[key]] = key.toLowerCase();
}
module.exports = function (manifestContent, callback) {
var schemaFile = path.resolve(__dirname, '..', '..', 'assets', 'web-manifest.json');
var schema = JSON.parse(fs.readFileSync(schemaFile).toString());
var extendedSchemaFile = path.resolve(__dirname, '..', '..', 'assets', 'web-manifest-extended.json');
var extendedSchema = JSON.parse(fs.readFileSync(extendedSchemaFile).toString());
// merge the extended schema with the standard schema
for (var property in extendedSchema.properties) { schema.properties[property] = extendedSchema.properties[property]; }
for (var definition in extendedSchema.definitions) { schema.definitions[definition] = extendedSchema.definitions[definition]; }
'use strict';
require('colors');
var util = require('util');
var _ = require('underscore');
var schemas = require('./Schemas');
var tv4 = require('tv4');
var formats = require('tv4-formats');
var flatten = require('flat').flatten;
tv4.addFormat(formats);
schemas.forEach(tv4.addSchema.bind(tv4));
var log;
if (global.Ninja && Ninja.getLog) {
log = Ninja.getLog('SchemaValidator');
} else {
// XXX: Add server logging framework (debug?)
log = {};
[['trace', 'cyan'], ['debug', 'white'], ['info', 'blue'], ['warn', 'yellow'], ['error', 'red']].forEach(function(level) {
log[level[0]] = console.log.bind(console, 'Schemas', level[0][level[1]] + '>');
});
}
/*
* On two occasions I have been asked,
* – "Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?"
*
* I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.
*
import API from 'api';
import moment from 'moment'
import tv4 from 'tv4';
import Vue from 'vue';
for (let key of Object.keys(API.definitions)) {
let schema = API.definitions[key];
tv4.addSchema('#/definitions/' + key, schema);
}
tv4.addFormat({
date: function(data, schema) {
var m = moment(data, 'YYYY-MM-DD'),
flags = m.parsingFlags();
if (!m.isValid() || (flags.unusedInput + flags.unusedTokens).length) {
return Vue._('Unsupported ISO-8601 date format');
}
},
'date-time': function(data, schema) {
if (!moment(data, moment.ISO_8601).isValid()) {
return Vue._('Unsupported ISO-8601 date-time format');
}
}
});
export default tv4;
function schemaApiServiceFactory(
configuration,
Logger,
Promise,
_,
nodeFs
) {
var logger = Logger.initialize(schemaApiServiceFactory);
var fs = Promise.promisifyAll(nodeFs);
var tv4 = require('tv4');
var schemaNsMap = {};
var schemaTitle = {};
tv4.addFormat("ipv4", function (input) {
var validator = require('validator');
if (validator.isIP(input,4))
{
return null;
} else
{
return input + " is not a valid IPv4 address!";
}
});
function SchemaApiService() {
}
SchemaApiService.prototype.addNamespace = function( filePath, namespace ) {
return fs.readdirAsync(filePath).filter(function(entry) {
return (path.extname(entry) === '.json');
}).map(function(entry) {
return fs.readFileAsync(filePath + '/' + entry)
.then(function(contents) {
try {
var json = JSON.parse(contents);
tv4.addSchema(namespace + entry, json);
schemaNsMap[entry] = namespace;
if( _.has(json, 'title')) {
schemaTitle[json.title] = namespace + entry;
} else {
logger.warning('no title found in ' + entry);
}
} catch(err) {
logger.warning('error loading schema:' + entry, { error: err } );
}
});
});
};
SchemaApiService.prototype.validate = function(obj, schemaName) {
return Promise.resolve().then(function() {
var basename;
// If a schemaName is specified, then validate against that
if(schemaName) {
basename = schemaName.split('#')[0];
if (!_.has(schemaNsMap, basename)) {
return Promise.reject(schemaName + ' is not loaded');
}
return tv4.validateResult(obj, tv4.getSchema(schemaNsMap[basename] + schemaName));
}
}).then(function(result) {
// Validate against all @odata.type fields declared
var objResults = _(getObjectsWithKey(obj, '@odata.type'))
.map(function(item) {
if(_.has(schemaTitle, item['@odata.type'])) {
schemaName = schemaTitle[item['@odata.type']];
return tv4.validateResult(item, tv4.getSchema(schemaName));
}
})
.unshift(result)
.compact()
.value();
return _.transform(objResults, function(result, item) {
if(result.valid === undefined) {
result.valid = item.valid;
} else {
result.valid = item.valid ? result.valid : item.valid;
}
if(item.error) {
result.error = result.error || [];
result.error.push(item.error);
}
if(item.missing) {
result.missing = result.missing || [];
result.missing.push.apply(result.missing, item.missing);
}
});
});
};
SchemaApiService.prototype.getNamespace = function( namespace ) {
var re = new RegExp(namespace);
var arr = tv4.getSchemaUris(re);
return arr;
};
SchemaApiService.prototype.getSchema = function( identifier ) {
var schemaContent = tv4.getSchema(identifier);
return schemaContent;
};
function getObjectsWithKey(obj_, keys) {
var res = [];
var match = _.intersection(_.keys(obj_), _.isArray(keys) ? keys : [keys]);
if (!_.isEmpty(match)) {
res.push(obj_);
}
_.forEach(obj_, function(v) {
if (typeof v === "object" && (v = getObjectsWithKey(v, keys)).length) {
res.push.apply(res, v);
}
});
return res;
}
return new SchemaApiService();
}