Form.submitForm = function (form, message, container, autoClose, e) {
e.preventDefault();
displayLoading(form, container);
let formData = serialize(form);
let request = new XMLHttpRequest();
request.open('post', encodeURI('/'), true);
request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
request.onreadystatechange = function () {
if (request.status === 200 && request.readyState === 4) {
displayFormSuccess(form, message, container);
if (autoClose) {
let body = document.getElementsByTagName('body')[0];
setTimeout(function () {
Utils.toggleClass(container, 'is-active');
Utils.toggleClass(body, 'is-locked');
}, 1200);
}
} else if (request.status === 200 && request.readyState !== 4) {
displayLoading(form, container);
} else {
// console.log("Failed");
}
};
request.send(formData);
};
onSubmit: function onDialogSubmit (e) {
e.preventDefault()
if (this.options.input) {
this.value = serialize(this.form, { hash: true })
}
return this.close()
},
_submitHandlerDefault(form) {
const { autoClose, autoCloseDelay, onSuccess } = this.options;
let params = serialize(form);
fetch(form.getAttribute('action'), 'POST', {}, params).then(response => {
// Redirect if possible
if ([301, 302, 278].indexOf(response.status) != -1) {
window.location = response.getResponseHeader('location');
}
let data = response.data;
try {
data = JSON.parse(data);
if (data.close) {
this.close();
}
this.setContent(data['content'] || data['title']);
} catch (e) {
onSuccess(data);
this.setContent(data);
}
if (autoClose) {
setTimeout(this.close.bind(this), autoCloseDelay);
}
});
}
handleSubmit: function(event) {
var target = event.target;
// Skip POST forms
if (target.method != 'get') return;
// Skip forms with a data-bypass attribute.
if (target.getAttribute('data-bypass')) return;
// Skip external forms
if (!origin.same(target.action)) return;
var options = {};
var action_url = url.parse(url.resolve(this.props.href, target.action));
options.replace = action_url.pathname == url.parse(this.props.href).pathname;
var search = serialize(target);
if (target.getAttribute('data-removeempty')) {
search = search.split('&').filter(function (item) {
return item.slice(-1) != '=';
}).join('&');
}
var href = action_url.pathname;
if (search) {
href += '?' + search;
}
options.skipRequest = target.getAttribute('data-skiprequest');
if (this.historyEnabled) {
event.preventDefault();
this.navigate(href, options);
}
},
function onsubmit (e) {
e.preventDefault()
var form = e.target
var data = serialize(form, { hash: true })
data.form = form
send('account:register', data)
}
handleSubmit = (event) => {
event.preventDefault()
const values = serializeForm(event.target, { hash: true })
console.log(values)
}
handleFormSubmit(event) {
event.preventDefault();
fetch(this.props.action, {
method: 'POST',
body: serialize(event.target),
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
},
})
.then(checkStatus)
.then((dataResponse) => {
let answer = {
subscriptionError: false,
message: this.props.successMessage,
};
if (dataResponse.errorMessage) {
answer = {
subscriptionError: true,
message: dataResponse.errorMessage,
};
}
this.setState({
answer,
});
}).catch((connectionError) => {
const answer = {
subscriptionError: true,
message: `Error communicating with the server: ${ connectionError.message }`,
};
this.setState({ answer });
});
}
onSubmit: function (e) {
e.preventDefault();
var form = this.refs.feedbackForm;
var serial = serialize(form, {hash: true});
var ok = true;
var errors = {
name: '',
email: '',
subject: '',
message: ''
};
if (!serial.name || _.trim(serial.name) === '') {
ok = false;
errors.name = 'Please provide a valid name.';
}
if (serial.email && serial.email.indexOf('@') === -1) {
ok = false;
errors.email = 'Please provide a valid email.';
}
if (!serial.subject || serial.subject === '--') {
ok = false;
errors.subject = 'Please select a subject.';
}
if (!serial.message || _.trim(serial.message) === '') {
ok = false;
errors.message = 'Please provide some feedback.';
}
this.setState({errors});
if (ok) {
serial.path = window.location.href;
console.log('serial', serial);
this.setState({
lockSubmit: true,
response: null
});
$.ajax({
dataType: 'jsonp',
url: config.feedbackSubmissionURL,
data: serial
})
.always(() => {
this.setState({lockSubmit: false});
})
.done(() => {
this.setState({response: 'Your feedback has been submitted. Thank you.'});
form.reset();
})
.fail(() => {
this.setState({response: 'There was a problem during submission. Please try again.'});
});
}
},
postForm: function(form, callback) {
var self = this;
var postData = serialize(form);
var postUrl = form.getAttribute('action') || window.location.pathname;
var token = self.getToken();
var options = callback.options || {};
request
.post(postUrl)
.type('form')
.set({
'authorization': 'Bearer ' + token,
'X-Requested-With': 'XMLHttpRequest'
})
.send(postData)
.end(function(res) {
if (res.ok) {
var userData;
// If auth token needs to be stored
if (options.setToken) {
// Store token in cookie that expires in a week
self.setToken(res.body.token, 7);
}
// If user needs to be updated
if (options.updateUser) {
userData = res.body.user;
userData.loggedIn = true;
self.setUser(userData);
}
// If user needs to be destroyed
if (options.destroyUser) {
// Log user out
self.logout();
}
if (callback && callback.success) {
callback.success(res);
}
if (options.successUrl) {
routeActions.setRoute(options.successUrl);
}
}
else {
if (callback && callback.error) {
callback.error(res);
}
if (options.errorUrl) {
routeActions.setRoute(options.errorUrl);
}
}
// Show global messages
messagesActions.setMessages(res.body);
if (callback && callback.complete) {
callback.complete(res);
}
});
},
goLogin(e) {
e.preventDefault();
const loginData = Serialize(e.target, { hash: true });
if (!loginData.username || !loginData.password) {
this.triggerError("Both username and password are required");
return;
}
AuthActions.login(loginData.username, loginData.password);
}
function onsubmit (e) {
e.preventDefault()
var fields = serialize(e.target, { hash: true, empty: true })
store({ type: 'form:submit', fields: fields })
var opts = { github: state.github, token: state.user.token, user: state.user.profile.login }
github.forkAndBranch(opts, function (err, res) {
})
}
function handleSubmit(e) {
e.preventDefault();
const { title } = serialize(form, { hash: true });
if (!title || !title.length) return;
onSubmit(title);
input.value = '';
}
Form.prototype.serialize = function (fieldset, transformer) {
if (typeof fieldset === "function") {
transformer = fieldset;
fieldset = null;
}
var el = fieldset ? formElement(this.element, fieldset) : this.element;
return serialize(el, transformer);
};
bean.on($('#form')[0], 'submit', function (event) {
var submission = formSerialize($('#form')[0], {hash: true});
var answer = submission.option;
event.preventDefault();
if (answer) {
submitPoll(id, answer);
} else {
// eslint-disable-next-line
console && console.warn('no answer submitted');
}
});
async handleForm(e) {
e.preventDefault();
let formData = serialize(this.refs.form, {'hash': true});
const response = await xr.post('/api/form/submit', formData);
if (response.data.success) {
this.setState({'success': true});
} else {
this.setState({'fail': true});
}
}
return dispatch => {
fetch('/api/updateCard?id=' + id, {
method: 'post',
credentials: 'same-origin',
headers: {
Accept: 'application/json',
'Content-Type': 'application/json'
},
body: JSON.stringify(serialize(form, { hash: true }))
})
.then(response => response.json()).then(data => {
dispatch(collectionLoaded(data));
});
};
function handleFormSubmit(event) {
event.preventDefault();
const container = this.arg;
const url = this.el.getAttribute('action');
const method = this.el.getAttribute('method') || 'POST';
const data = serialize(this.el);
request(container, { url, method, data })
.then(response => {
this.vm.$broadcast('pjax-loaded', {
url,
container,
content: response.data,
});
}, () => {
window.location = url;
});
}
submit.addEventListener('click', (e) => {
e.preventDefault();
fetch('/api/shorten', {
method: 'POST',
headers: {
'Accept': '*/*',
'Content-Type': 'application/x-www-form-urlencoded'
},
body: serialize(this.form)
}).
then((response) => response.json()).
then((result) => {
if (result && result.hash) {
urlShow.trigger('item', result);
this.showNext();
}
}).
catch((ex) => console.error(ex));
});
onSubmit = async event => {
try {
event.preventDefault();
this.setState({isSubmitting: true});
const form = event.target;
const data = serialize(form, {hash: true});
await this.props.onSubmit(data);
this.setState({isSubmitting: false});
notify({
type: 'success',
text: this.props.successMessage,
});
} catch (error) {
notify({
type: 'error',
text: getErrorMessage(error),
});
this.setState({isSubmitting: false});
}
};
_submitPost: function(e) {
var form = this.refs.form.getDOMNode();
var data = serialize(form, {hash: true});
this.setState({reqInFlight: true})
var reqwest = require('reqwest');
reqwest({
url: '/post',
method: 'post',
data: data,
success: function (resp) {
this.setState({
reqState: reqState.SUCCESS,
});
}.bind(this),
error: function(err) {
this.setState({
reqState: reqState.FAILURE,
});
}.bind(this),
});
e.stopPropagation();
},
formValidate() {
let formData = serialize(this.refs.form, {hash: true, empty: true});
let form = this.state.form;
_.forEach(formData, function(val, key) {
if (key == 'email') {
if (isEmail(val)) {
form[key] = true;
} else {
form[key] = false;
}
} else {
if (val != '') {
form[key] = true;
} else {
form[key] = false;
}
}
}.bind(this));
this.setState({'form': form});
}
function get_opts() {
return serialize(form, {
hash: true
});
}
import React from 'react'
import { render } from 'react-dom'
import serializeForm from 'form-serialize'
const CheckoutForm = React.createClass({
getInitialState() {
return {
billing: {},
shippingSameAsBilling: false,
shipping: {}
}
},
handleChange() {
const formNode = this.refs.form
const nextState = serializeForm(formNode, { hash: true })
nextState.shippingSameAsBilling = (nextState.shippingSameAsBilling === 'on')
if (nextState.shippingSameAsBilling)
nextState.shipping = nextState.billing || {}
// If the checkbox changed, back up shipping so we can preserve it.
if (nextState.shippingSameAsBilling !== this.state.shippingSameAsBilling) {
if (nextState.shippingSameAsBilling) {
this.shippingBackup = this.state.shipping
} else {
nextState.shipping = this.shippingBackup
}
}
Form.prototype.getSerializedData = function() {
return serialize(this.element);
};
handleSubmit (e) {
e.preventDefault()
const { dispatch } = this.props
const data = serialize(this.page.form, { hash: true, empty: true })
dispatch(updateUserGroup(this.usergroup._id, data))
}
Form.prototype.getData = function() {
return serialize(this.element, { hash: true });
};
import serializeForm from 'form-serialize'
const TransparentDataURL = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'
function generateId() {
return Math.random().toString(36).substring(7)
}
const CreateContactForm = React.createClass({
propTypes: {
onCreate: PropTypes.func.isRequired
},
handleSubmit(event) {
event.preventDefault()
const contact = serializeForm(event.target, { hash: true })
contact.id = generateId()
this.props.onCreate(contact)
event.target.reset()
},
render() {
return (
<form onSubmit={this.handleSubmit} style={{ display: 'inline' }}>
<img style={{ background: '#ccc' }} height="50" width="50" src={TransparentDataURL}/>{' '}
<input name="first" type="text" placeholder="first name" size="8"/>
<input name="last" type="text" placeholder="last name" size="15"/>
<input name="avatar" type="text" placeholder="avatar url" size="15"/>
<button type="submit">Create</button>
</form>
)
let serializeForm = function(evt) {
return serialize(evt.target.form, {hash: true});
};
this.getData = function() {
return serialize(form.element, { hash: true });
};
this.getSerializedData = function() {
return serialize(form.element);
};