spee.ch/public/assets/js/validationFunctions.js

240 lines
8.5 KiB
JavaScript
Raw Normal View History

// validation function which checks the proposed file's type, size, and name
function validateFile(file) {
if (!file) {
console.log('no file found');
throw new Error('no file provided');
}
if (/'/.test(file.name)) {
console.log('file name had apostrophe in it');
throw new Error('apostrophes are not allowed in the file name');
}
// validate size and type
switch (file.type) {
case 'image/jpeg':
case 'image/jpg':
case 'image/png':
if (file.size > 10000000){
console.log('file was too big');
throw new Error('Sorry, images are limited to 10 megabytes.');
}
break;
case 'image/gif':
if (file.size > 50000000){
console.log('file was too big');
throw new Error('Sorry, .gifs are limited to 50 megabytes.');
}
break;
case 'video/mp4':
if (file.size > 50000000){
console.log('file was too big');
throw new Error('Sorry, videos are limited to 50 megabytes.');
}
break;
default:
console.log('file type is not supported');
throw new Error(file.type + ' is not a supported file type. Only, .jpeg, .png, .gif, and .mp4 files are currently supported.')
}
}
2017-10-10 19:14:43 +02:00
2017-09-19 21:54:23 +02:00
// validation function that checks to make sure the claim name is valid
function validateClaimName (name) {
// ensure a name was entered
if (name.length < 1) {
throw new NameError("You must enter a name for your url");
}
// validate the characters in the 'name' field
const invalidCharacters = /[^A-Za-z0-9,-]/g.exec(name);
if (invalidCharacters) {
2017-10-12 23:37:25 +02:00
throw new NameError('"' + invalidCharacters + '" characters are not allowed');
}
2017-09-19 17:47:24 +02:00
}
function validateChannelName (name) {
name = name.substring(name.indexOf('@') + 1);
// ensure a name was entered
if (name.length < 1) {
2017-09-20 18:49:05 +02:00
throw new ChannelNameError("You must enter a name for your channel");
}
// validate the characters in the 'name' field
const invalidCharacters = /[^A-Za-z0-9,-,@]/g.exec(name);
if (invalidCharacters) {
2017-10-12 23:37:25 +02:00
throw new ChannelNameError('"' + invalidCharacters + '" characters are not allowed');
}
}
function validatePassword (password) {
if (password.length < 1) {
2017-09-20 19:14:00 +02:00
throw new ChannelPasswordError("You must enter a password for you channel");
}
}
2017-09-19 21:54:23 +02:00
function cleanseClaimName(name) {
name = name.replace(/\s+/g, '-'); // replace spaces with dashes
name = name.replace(/[^A-Za-z0-9-]/g, ''); // remove all characters that are not A-Z, a-z, 0-9, or '-'
return name;
2017-09-19 21:54:23 +02:00
}
// validation functions to check claim & channel name eligibility as the inputs change
function isNameAvailable (name, apiUrl) {
2017-09-29 00:47:55 +02:00
const url = apiUrl + name;
return getRequest(url)
}
2017-09-19 17:47:24 +02:00
2017-09-19 21:54:23 +02:00
function showError(errorDisplay, errorMsg) {
errorDisplay.hidden = false;
errorDisplay.innerText = errorMsg;
}
2017-09-19 21:54:23 +02:00
function hideError(errorDisplay) {
errorDisplay.hidden = true;
errorDisplay.innerText = '';
}
2017-09-19 21:54:23 +02:00
function showSuccess (successElement) {
successElement.hidden = false;
successElement.innerHTML = "&#x2714";
}
2017-09-19 17:47:24 +02:00
2017-09-19 21:54:23 +02:00
function hideSuccess (successElement) {
successElement.hidden = true;
successElement.innerHTML = "";
}
2017-09-19 17:47:24 +02:00
2017-09-29 00:47:55 +02:00
function checkAvailability(name, successDisplayElement, errorDisplayElement, validateName, isNameAvailable, errorMessage, apiUrl) {
2017-09-19 17:47:24 +02:00
try {
2017-09-19 21:54:23 +02:00
// check to make sure the characters are valid
validateName(name);
2017-09-19 17:47:24 +02:00
// check to make sure it is available
2017-09-19 21:54:23 +02:00
isNameAvailable(name, apiUrl)
2017-09-29 00:47:55 +02:00
.then(result => {
console.log('result:', result)
if (result === true) {
2017-09-29 00:47:55 +02:00
hideError(errorDisplayElement);
showSuccess(successDisplayElement)
} else {
2017-09-29 00:47:55 +02:00
hideSuccess(successDisplayElement);
showError(errorDisplayElement, errorMessage);
}
2017-09-19 17:47:24 +02:00
})
2017-09-29 00:47:55 +02:00
.catch(error => {
2017-09-19 21:54:23 +02:00
hideSuccess(successDisplayElement);
showError(errorDisplayElement, error.message);
2017-09-19 17:47:24 +02:00
});
} catch (error) {
2017-09-19 21:54:23 +02:00
hideSuccess(successDisplayElement);
showError(errorDisplayElement, error.message);
2017-09-19 17:47:24 +02:00
}
}
2017-09-19 21:54:23 +02:00
function checkClaimName(name){
const successDisplayElement = document.getElementById('input-success-claim-name');
const errorDisplayElement = document.getElementById('input-error-claim-name');
2017-10-12 18:28:39 +02:00
checkAvailability(name, successDisplayElement, errorDisplayElement, validateClaimName, isNameAvailable, 'Sorry, that ending is already taken', '/api/isClaimAvailable/');
2017-09-19 21:54:23 +02:00
}
function checkChannelName(name){
2017-09-20 00:39:54 +02:00
const successDisplayElement = document.getElementById('input-success-channel-name');
const errorDisplayElement = document.getElementById('input-error-channel-name');
name = `@${name}`;
2017-10-12 18:28:39 +02:00
checkAvailability(name, successDisplayElement, errorDisplayElement, validateChannelName, isNameAvailable, 'Sorry, that name is already taken', '/api/isChannelAvailable/');
2017-09-19 21:54:23 +02:00
}
// validation function which checks all aspects of the publish submission
2017-09-20 18:49:05 +02:00
function validateFilePublishSubmission(stagedFiles, claimName, channelName){
console.log(`validating publish submission > name: ${claimName} channel: ${channelName} file:`, stagedFiles);
return new Promise(function (resolve, reject) {
// 1. make sure 1 file was staged
if (!stagedFiles) {
reject(new FileError("Please select a file"));
return;
} else if (stagedFiles.length > 1) {
reject(new FileError("Only one file is allowed at a time"));
return;
}
// 2. validate the file's name, type, and size
try {
validateFile(stagedFiles[0]);
} catch (error) {
reject(error);
return;
}
// 3. validate that a channel was chosen
if (channelName === 'new' || channelName === 'login') {
reject(new ChannelNameError("Please log in to a channel"));
return;
2017-09-20 00:39:54 +02:00
};
// 4. validate the claim name
try {
validateClaimName(claimName);
} catch (error) {
reject(error);
return;
}
// if all validation passes, check availability of the name (note: do we need to re-validate channel name vs. credentials as well?)
return isNameAvailable(claimName, '/api/isClaimAvailable/')
.then(result => {
if (result) {
resolve();
} else {
reject(new NameError('Sorry, that ending is already taken'));
}
})
.catch(error => {
reject(error);
});
});
2017-09-20 18:49:05 +02:00
}
// validation function which checks all aspects of a new channel submission
function validateNewChannelSubmission(userName, password){
const channelName = `@${userName}`;
2017-09-20 18:49:05 +02:00
return new Promise(function (resolve, reject) {
// 1. validate name
2017-09-20 18:49:05 +02:00
try {
validateChannelName(channelName);
} catch (error) {
return reject(error);
}
// 2. validate password
try {
validatePassword(password);
} catch (error) {
return reject(error);
}
// 3. if all validation passes, check availability of the name
isNameAvailable(channelName, '/api/isChannelAvailable/') // validate the availability
.then(result => {
if (result) {
console.log('channel is available');
resolve();
} else {
console.log('channel is not available');
reject(new ChannelNameError('Sorry, that name is already taken'));
}
2017-09-20 18:49:05 +02:00
})
2017-09-20 19:14:00 +02:00
.catch( error => {
console.log('error evaluating channel name availability', error);
2017-09-20 18:49:05 +02:00
reject(error);
});
});
2017-10-12 23:37:25 +02:00
}
// validation function which checks all aspects of a new channel login
function validateNewChannelLogin(userName, password){
const channelName = `@${userName}`;
return new Promise(function (resolve, reject) {
// 1. validate name
try {
validateChannelName(channelName);
} catch (error) {
return reject(error);
}
// 2. validate password
try {
validatePassword(password);
} catch (error) {
return reject(error);
}
resolve();
});
}