text
stringlengths 7
3.69M
|
|---|
var rules_tests = require('./rules_functions.js');
var h = require('./helpers.js');
module.exports = [
{
rule_name: 'required',
no_varname_msg: function(to_test, rules_arg) {
return 'Required';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' is required';
},
test: function(to_test, rules_arg) {
return rules_tests.required(to_test, rules_arg);
},
},
{
rule_name: 'same',
no_varname_msg: function(to_test, rules_arg) {
const name = rules_arg.same.name;
return 'Must be the same as ' + name;
},
varname_msg: function(to_test, rules_arg, var_name) {
const name = rules_arg.same.name;
return var_name + ' must be the same as ' + name;
},
test: function(to_test, rules_arg) {
if (rules_arg.same === false) {
return true;
}
if (!h.isObject(rules_arg.same)) {
throw new Error("The same rule must be an object");
}
const value = rules_arg.same.value;
return to_test === value;
},
},
{
rule_name: 'different',
no_varname_msg: function(to_test, rules_arg) {
const name = rules_arg.different.name;
return 'Must not be the same as ' + name;
},
varname_msg: function(to_test, rules_arg, var_name) {
const name = rules_arg.different.name;
return var_name + ' must not be the same as ' + name;
},
test: function(to_test, rules_arg) {
if (rules_arg.different === false) {
return true;
}
if (!h.isObject(rules_arg.different)) {
throw new Error("The different rule must be an object");
}
const value = rules_arg.different.value;
return to_test !== value;
},
},
{
rule_name: 'min',
no_varname_msg: function(to_test, rules_arg) {
var min_length = rules_arg.min;
if (h.isNumber(to_test)) {
return 'Must be ' + min_length + ' or larger';
}
return 'Must be ' + min_length + ' or longer';
},
varname_msg: function(to_test, rules_arg, var_name) {
var min_length = rules_arg.min;
if (h.isNumber(to_test)) {
return var_name + ' must be ' + min_length + ' or larger';
}
return var_name + ' must be ' + min_length + ' or longer';
},
test: function(to_test, rules_arg) {
return rules_tests.min(to_test, rules_arg);
}
},
{
rule_name: 'max',
no_varname_msg: function(to_test, rules_arg) {
var max_length = rules_arg.max;
if (h.isNumber(to_test)) {
return 'Must be ' + max_length + ' or smaller';
}
return 'Must be ' + max_length + ' or shorter';
},
varname_msg: function(to_test, rules_arg, var_name) {
var max_length = rules_arg.max;
if (h.isNumber(to_test)) {
return var_name + ' must be ' + max_length + ' or smaller';
}
return var_name + ' must be ' + max_length + ' or shorter';
},
test: function(to_test, rules_arg) {
return rules_tests.max(to_test, rules_arg);
}
},
{
rule_name: 'alpha',
no_varname_msg: function(to_test, rules_arg) {
return 'Please enter letters only';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' may only contain letters';
},
test: function(to_test, rules_arg) {
return rules_tests.alpha(to_test, rules_arg);
}
},
{
rule_name: 'name',
no_varname_msg: function(to_test, rules_arg) {
return 'Please enter letters, apostrophes, dashes and/or spaces';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' may only contain letters, apostrophes, dashes and/or spaces';
},
test: function(to_test, rules_arg) {
return rules_tests.name(to_test, rules_arg);
}
},
{
rule_name: 'alphanumeric',
no_varname_msg: function(to_test, rules_arg) {
return 'Please enter letters or numbers only';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' may only contain letters or numbers';
},
test: function(to_test, rules_arg) {
return rules_tests.alphanumeric(to_test, rules_arg);
}
},
{
rule_name: 'numeric',
no_varname_msg: function(to_test, rules_arg) {
return 'The input must be a number';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' must be a number';
},
test: function(to_test, rules_arg) {
return rules_tests.numeric(to_test, rules_arg);
}
},
{
rule_name: 'number',
no_varname_msg: function(to_test, rules_arg) {
return 'The input must be a number';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' must be a number';
},
test: function(to_test, rules_arg) {
return rules_tests.isNumber(to_test, rules_arg);
}
},
{
rule_name: 'string',
no_varname_msg: function(to_test, rules_arg) {
return 'The input must be a string';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' must be a string';
},
test: function(to_test, rules_arg) {
return rules_tests.isString(to_test, rules_arg);
}
},
{
rule_name: 'date',
no_varname_msg: function(to_test, rules_arg) {
return 'Please enter a valid date';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' must be a valid date';
},
test: function(to_test, rules_arg) {
return rules_tests.isDate(to_test, rules_arg);
}
},
{
rule_name: 'datetime',
no_varname_msg: function(to_test, rules_arg) {
return 'Please enter a valid date and time';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' must be a date and time';
},
test: function(to_test, rules_arg) {
return rules_tests.isDateTime(to_test, rules_arg);
}
},
{
rule_name: 'email',
no_varname_msg: function(to_test, rules_arg) {
return 'Please enter a valid email address';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' must be a valid email address';
},
test: function(to_test, rules_arg) {
return rules_tests.isEmail(to_test, rules_arg);
}
},
{
rule_name: 'po_box',
no_varname_msg: function(to_test, rules_arg) {
return 'Invalid P.O. Box';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' must be a P.O. Box';
},
test: function(to_test, rules_arg) {
if (rules_arg.po_box === false) {
return true;
}
return rules_tests.isPoBox(to_test, rules_arg);
}
},
{
rule_name: 'not_po_box',
no_varname_msg: function(to_test, rules_arg) {
return 'P.O. Box not allowed';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' must not be a P.O. Box';
},
test: function(to_test, rules_arg) {
if (rules_arg.not_po_box === false) {
return true;
}
return !rules_tests.isPoBox(to_test, rules_arg);
}
},
{
rule_name: 'in',
no_varname_msg: function(to_test, rules_arg) {
return 'Please enter a valid option';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' is not a valid option';
},
test: function(to_test, rules_arg) {
if (rules_arg.in === false) {
return true;
}
return rules_tests.in(to_test, rules_arg);
}
},
{
rule_name: 'not_in',
no_varname_msg: function(to_test, rules_arg) {
return 'That option is not allowed';
},
varname_msg: function(to_test, rules_arg, var_name) {
return var_name + ' is not a valid option';
},
test: function(to_test, rules_arg) {
if (rules_arg.not_in === false) {
return true;
}
return rules_tests.notIn(to_test, rules_arg);
}
},
{
rule_name: 'before',
no_varname_msg: function(to_test, rules_arg) {
var time_string = rules_arg.before.toString();
time_string = time_string.split(' 00:00:00')[0];
return 'Please enter a date prior to ' + time_string;
},
varname_msg: function(to_test, rules_arg, var_name) {
var time_string = rules_arg.before.toString();
time_string = time_string.split(' 00:00:00')[0];
return var_name + ' must be prior to ' + time_string;
},
test: function(to_test, rules_arg) {
return rules_tests.before(to_test, rules_arg);
}
},
{
rule_name: 'before_or',
no_varname_msg: function(to_test, rules_arg) {
var time_string = rules_arg.before_or.toString();
time_string = time_string.split(' 00:00:00')[0];
return 'Please enter a date on or prior to ' + time_string;
},
varname_msg: function(to_test, rules_arg, var_name) {
var time_string = rules_arg.before_or.toString();
time_string = time_string.split(' 00:00:00')[0];
return var_name + ' must be on or prior to ' + time_string;
},
test: function(to_test, rules_arg) {
return rules_tests.beforeOr(to_test, rules_arg);
}
},
{
rule_name: 'after',
no_varname_msg: function(to_test, rules_arg) {
var time_string = rules_arg.after.toString();
time_string = time_string.split(' 00:00:00')[0];
return 'Please enter a date after ' + time_string;
},
varname_msg: function(to_test, rules_arg, var_name) {
var time_string = rules_arg.after.toString();
time_string = time_string.split(' 00:00:00')[0];
return var_name + ' must be after ' + time_string;
},
test: function(to_test, rules_arg) {
return rules_tests.after(to_test, rules_arg);
}
},
{
rule_name: 'after_or',
no_varname_msg: function(to_test, rules_arg) {
var time_string = rules_arg.after_or.toString();
time_string = time_string.split(' 00:00:00')[0];
return 'Please enter a date on or after ' + time_string;
},
varname_msg: function(to_test, rules_arg, var_name) {
var time_string = rules_arg.after_or.toString();
time_string = time_string.split(' 00:00:00')[0];
return var_name + ' must be on or after ' + time_string;
},
test: function(to_test, rules_arg) {
return rules_tests.afterOr(to_test, rules_arg);
}
},
];
|
// Manage saves and updates
export class DBObject {
constructor(properties, doc) {
for(let p in properties) {
this[p] = doc[p] || properties[p];
}
// make sure that _id is set
this._id = doc._id || properties._id || Random.id();
// console.log('DBObject', this);
if(!doc.type && !properties.type) console.log('no type ?', doc);
}
objToSave() {
throw new Error('objToSave needs to be overridden')
}
saveToDB() {
Meteor.call('mapInsert', this.objToSave());
}
updateDB() {
Meteor.call('mapUpdate', this._id, this.objToSave());
}
removeFromDB() {
Meteor.call('mapRemove', this._id);
}
}
|
import * as echartsModule from './echarts/echarts.js';
/**
* This is the echarts module.
*
* @type {{LineChart?: LineChart}}
*/
export var echarts = echartsModule;
|
const express = require('express');
const router = express.Router();
const ChatController = require('./ChatController');
router.get('/', ChatController.run);
module.exports = router;
|
import React from 'react';
import { faCheck, faCog, faHome, faPlus, faSearch, faSlidersH } from '@fortawesome/free-solid-svg-icons';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { Breadcrumb, Button, ButtonGroup, Dropdown, Form, InputGroup, Row, Col, Card, Table, Image } from '@themesberg/react-bootstrap';
import users from '../data/users';
export default () => {
return (
<>
<div className="d-lg-flex justify-content-between flex-wrap flex-md-nowrap align-items-center py-4">
<div className="mb-4 mb-lg-0">
<Breadcrumb className="d-none d-md-inline-block" listProps={{ className: "breadcrumb-dark breadcrumb-transparent" }}>
<Breadcrumb.Item><FontAwesomeIcon icon={faHome} /></Breadcrumb.Item>
<Breadcrumb.Item>Albertsons</Breadcrumb.Item>
<Breadcrumb.Item active>Users List</Breadcrumb.Item>
</Breadcrumb>
<h4>Users List</h4>
<p className="mb-0">Your Albertsons dashboard template.</p>
</div>
<div className="btn-toolbar mb-2 mb-md-0">
<Button variant="primary" size="sm">
<FontAwesomeIcon icon={faPlus} className="me-2" /> Add New User
</Button>
<ButtonGroup className="ms-3">
<Button variant="outline-primary" size="sm">Share</Button>
<Button variant="outline-primary" size="sm">Export</Button>
</ButtonGroup>
</div>
</div>
<div className="table-settings mb-4">
<Row className="justify-content-between align-items-center">
<Col xs={9} lg={4} className="d-flex">
<InputGroup className="me-2 me-lg-3">
<InputGroup.Text>
<FontAwesomeIcon icon={faSearch} />
</InputGroup.Text>
<Form.Control type="text" placeholder="Search" />
</InputGroup>
<Form.Select className="w-25">
<option defaultChecked>All</option>
<option value="1">Active</option>
<option value="2">Inactive</option>
<option value="3">Pending</option>
<option value="3">Canceled</option>
</Form.Select>
</Col>
<Col xs={3} lg={8} className="text-end">
<Dropdown as={ButtonGroup} className="me-2">
<Dropdown.Toggle split as={Button} variant="link" className="text-dark m-0 p-0">
<span className="icon icon-sm icon-gray">
<FontAwesomeIcon icon={faSlidersH} />
</span>
</Dropdown.Toggle>
<Dropdown.Menu className="dropdown-menu-right">
<Dropdown.Item className="fw-bold text-dark">Show</Dropdown.Item>
<Dropdown.Item className="d-flex fw-bold">
10 <span className="icon icon-small ms-auto"><FontAwesomeIcon icon={faCheck} /></span>
</Dropdown.Item>
<Dropdown.Item className="fw-bold">20</Dropdown.Item>
<Dropdown.Item className="fw-bold">30</Dropdown.Item>
</Dropdown.Menu>
</Dropdown>
<Dropdown as={ButtonGroup}>
<Dropdown.Toggle split as={Button} variant="link" className="text-dark m-0 p-0">
<span className="icon icon-sm icon-gray">
<FontAwesomeIcon icon={faCog} />
</span>
</Dropdown.Toggle>
<Dropdown.Menu className="dropdown-menu-right">
<Dropdown.Item className="fw-bold text-dark">Show</Dropdown.Item>
<Dropdown.Item className="d-flex fw-bold">
10 <span className="icon icon-small ms-auto"><FontAwesomeIcon icon={faCheck} /></span>
</Dropdown.Item>
<Dropdown.Item className="fw-bold">20</Dropdown.Item>
<Dropdown.Item className="fw-bold">30</Dropdown.Item>
</Dropdown.Menu>
</Dropdown>
</Col>
</Row>
</div>
<Card border="light" className="table-wrapper table-responsive shadow-sm">
<Card.Body>
<Table hover className="user-table align-items-center">
<thead>
<tr>
<th className="border-bottom">Name</th>
<th className="border-bottom">Email</th>
<th className="border-bottom">Position</th>
<th className="border-bottom">User Created at</th>
</tr>
</thead>
<tbody>
{users.map(u => (
<tr key={u.key}>
<td>
<Card.Link className="d-flex align-items-center">
<Image src={u.image} className="user-avatar rounded-circle me-3" />
<div className="d-block">
<span className="fw-bold">{u.name}</span>
</div>
</Card.Link>
</td>
<td><span className="fw-normal"><div className="small text-gray">{u.email}</div></span></td>
<td><span className="fw-normal"><div className="small text-gray">{u.position}</div></span></td>
<td><span className="fw-normal">{u.dateCreated}</span></td>
</tr>
))}
</tbody>
</Table>
</Card.Body>
</Card>
</>
)
}
|
import React from "react";
import { Marker } from "react-google-maps";
export default class NewMarker extends React.Component {
render() {
return (
<React.Fragment>
<Marker position={this.props.location} />
</React.Fragment>
);
}
}
|
/* This script is written to demonstrate the process of adding a new value into an already sorted array using JavaScript. */
/* This function in particular only adds one value to the array at a time. */
/* Written by Vakindu Philliam */
var m = function sortList(list,somevalue){
//Capture length of list
var length =list.length;
//Capture the last element of sorted array
var largest=list.slice(length-1,length);
//Compare the largest element of sorted array to the new value
if(somevalue>largest) {
//If new value is greater than the largest element of array, append new value as the largest in the array
list.push(somevalue);
}
//Iterate through list
for(var i=0;i<length;i++){
//Compare each element of array to new value
if(somevalue<list[i]){
//If value is greater than list element, add new element just before it
list.splice(i,0,somevalue);
//Break loop
break;
}
}
//Return value
return list;
}
//Run function
//As an example, run the function upon an already sorted array
var array=[1,2,3,4,5,6];
//Declare value to add to the list
var newValue=3;
document.write(m(array,newValue));
//Outputs: 1,2,3,3,4,5,6
//Adding another value that is bigger than all current elements to the list
var newValue2=7;
document.write(m(array,newValue2));
//Outputs: 1,2,3,3,4,5,6,7
|
"use strict";
require([__dirname + "/../low.js", __dirname + "/tools.js"], function (low, tools)
{
exports.ListModel = function ListModel()
{
tools.defineProperties(this, {
data: { set: setData, get: data },
onReset: { set: setOnReset, get: onReset },
onInsert: { set: setOnInsert, get: onInsert },
onRemove: { set: setOnRemove, get: onRemove },
size: { get: size }
});
var that = this;
var m_data = [];
var m_onReset = null;
var m_onInsert = null;
var m_onRemove = null;
function setData(data)
{
that.reset(data);
}
function data()
{
return m_data.slice();
}
function setOnReset(cb)
{
m_onReset = cb;
}
function onReset()
{
return m_onReset;
}
function setOnInsert(cb)
{
m_onInsert = cb;
}
function onInsert()
{
return m_onInsert;
}
function setOnRemove(cb)
{
m_onRemove = cb;
}
function onRemove()
{
return m_onRemove;
}
function size()
{
return m_data.length;
}
this.reset = function (data)
{
m_data = data;
that.sizeChanged();
if (m_onReset)
{
m_onReset();
}
};
this.insert = function (at, data)
{
if (at >= 0 && at <= m_data.length)
{
m_data = m_data.slice(0, at).concat([data]).concat(m_data.slice(at));
that.sizeChanged();
if (m_onInsert)
{
m_onInsert(at);
}
}
};
this.remove = function (at)
{
if (at >= 0 && at < m_data.length)
{
m_data.splice(at, 1);
that.sizeChanged();
if (m_onRemove)
{
m_onRemove(at);
}
}
};
this.at = function (n)
{
return m_data[n];
};
};
});
|
import React, { Component } from 'react';
import uuid from 'uuid';
import PropTypes from 'prop-types';
const stateInicial = {
appointment: {
petName: '',
owner: '',
date: '',
time: '',
symptoms: ''
},
error: false
}
class NewAppointment extends Component {
state = {...stateInicial}
handleChange = (e) => {
this.setState({
appointment: {
...this.state.appointment, // esta linea toma una copia, se recomienda hacerlo
[e.target.name] : [e.target.value]
}
});
}
handleSubmit = (e) => {
// para prevenir que se envíen los datos
e.preventDefault();
// extraer los datos del state con destructuring
const { petName, owner, date, time, symptoms } = this.state.appointment;
// validar que los campos estén llenos
if (petName === '' || owner === '' || date === '' || time === '' || symptoms === '') {
this.setState({
error: true
});
// detener la ejecución
return;
}
// generar objeto con los datos
const newAppointment = {...this.state.appointment};
newAppointment.id = uuid();
// agregamos al cita
this.props.createNewAppointment(newAppointment);
// reseteamos el state
this.setState({
...stateInicial
});
}
render() {
// extraemos el valor del error
const { error } = this.state;
return (
<div className="card mt-5 py-5">
<div className="card-body">
<h2 className="card-title text-center mb-5">
Enter the information to create a new appointment
</h2>
{ error &&
<div className="alert alert-danger mt-2 mb-5 text-center">All the fields are required </div>
}
<form
onSubmit={this.handleSubmit}>
<div class="form-group">
<label className="col-sm-4 col-lg-2 col-form-label">Pet Name</label>
<div className="col-sm-8 col-lg-10">
<input
type="text"
name="petName"
className="form-control"
placeholder="Pet name"
onChange={this.handleChange}
value={this.state.appointment.petName}/>
</div>
</div>
<div class="form-group">
<label className="col-sm-4 col-lg-2 col-form-label">Owner Name</label>
<div className="col-sm-8 col-lg-10">
<input
type="text"
name="owner"
className="form-control"
placeholder="Owner name"
onChange={this.handleChange}
value={this.state.appointment.owner} />
</div>
</div>
<div class="form-group">
<label className="col-sm-4 col-lg-2 col-form-label">Date</label>
<div className="col-sm-8 col-lg-10">
<input
type="date"
name="date"
className="form-control"
onChange={this.handleChange}
value={this.state.appointment.date}/>
</div>
<label className="col-sm-4 col-lg-2 col-form-label">Time</label>
<div className="col-sm-8 col-lg-10">
<input
type="time"
name="time"
className="form-control"
onChange={this.handleChange}
value={this.state.appointment.time} />
</div>
</div>
<div class="form-group">
<label className="col-sm-4 col-lg-2 col-form-label">Symptoms Description</label>
<div className="col-sm-8 col-lg-10">
<textarea
className="form-control"
name="symptoms"
placeholder="Describe the symptoms"
onChange={this.handleChange}
value={this.state.appointment.symptoms}>
</textarea>
</div>
<input
type="submit"
className="py-3 mt-2 btn btn-success btn-block"
value="Add New Appointment" />
</div>
</form>
</div>
</div>
);
}
}
NewAppointment.propTypes = {
createNewAppointment : PropTypes.func.isRequired
};
export default NewAppointment;
|
// import PrivateRoute from "./Private.Route";
import { ROUTER } from 'Constants/CommonConstants'
import {
Home,
Checkout,
Contact,
FAQ,
Login,
NotFound,
OrderSuccess,
Payment,
ProductDetail,
Profile,
Register,
Shop,
AddProduct,
AllProducts,
AllOrders,
OrderDetail,
} from 'Pages'
import * as React from 'react'
import { BrowserRouter as Router, Switch } from 'react-router-dom'
import { PrivateLayout } from 'Components'
import PublicRoute from './Public.Route'
import PrivateRoute from './Private.Route'
const Routes = () => (
<Router>
<Switch>
<PublicRoute exact path={ROUTER.Home} component={Home} />
<PrivateRoute exact path={ROUTER.Dashboard} component={PrivateLayout} />
<PrivateRoute
path={`${ROUTER.OrderDetail}/:id`}
component={OrderDetail}
/>
<PrivateRoute exact path={ROUTER.AddProduct} component={AddProduct} />
<PrivateRoute exact path={ROUTER.AllProducts} component={AllProducts} />
<PrivateRoute exact path={ROUTER.AllOrders} component={AllOrders} />
<PublicRoute
path={`${ROUTER.ProductDetail}/:id`}
component={ProductDetail}
/>
<PublicRoute exact path={ROUTER.Shop} component={Shop} />
<PublicRoute exact path={ROUTER.FAQ} component={FAQ} />
<PublicRoute exact path={ROUTER.Contact} component={Contact} />
<PublicRoute exact path={ROUTER.Checkout} component={Checkout} />
<PublicRoute exact path={ROUTER.Register} component={Register} />
<PublicRoute exact path={ROUTER.Login} component={Login} />
<PublicRoute exact path={ROUTER.Payment} component={Payment} />
<PublicRoute exact path={ROUTER.Profile} component={Profile} />
<PublicRoute exact path={ROUTER.OrderSuccess} component={OrderSuccess} />
<PublicRoute component={NotFound} />
</Switch>
</Router>
)
export default Routes
|
/**
* @fileoverview 基于Overlay.Dialog dd封装了alert,confirm,prompt，使用dialog会很简单
* @author bofang.zxj<bofang.zxj@taobao.com>
* @module easydialog
**/
KISSY.add(function(S,Alert,Confirm,Prompt){
return {
alert:Alert,
confirm:Confirm,
prompt:Prompt
}
},{
requires:['./alert','./confirm','./prompt']
});
|
/**
* Created by Adc-yang on 2016/8/12.
*/
const TIMEZONES = [
{id: "1", name: "(GMT-12:00)日界线西"},
{id: "2", name: "(GMT-11:00)中途岛，萨摩亚群岛"},
{id: "3", name: "(GMT-10:00)夏威夷"},
{id: "4", name: "(GMT-09:00)阿拉斯加"},
{id: "5", name: "(GMT-08:00)太平洋时间(美国和加拿大),蒂华纳"},
{id: "6", name: "(GMT-07:00)山地时间(美国和加拿大)"},
{id: "7", name: "(GMT-07:00)亚利桑那"},
{id: "8", name: "(GMT-07:00)齐瓦瓦，拉巴斯，马扎特兰"},
{id: "9", name: "(GMT-06:00)萨斯喀彻温"},
{id: "10", name: "(GMT-06:00)中部时间(美国和加拿大)"},
{id: "11", name: "(GMT-06:00)中美洲"},
{id: "12", name: "(GMT-06:00)瓜达拉哈拉，墨西哥城，蒙特雷"},
{id: "13", name: "(GMT-05:00)波哥大，利马，基多"},
{id: "14", name: "(GMT-05:00)东部时间(美国和加拿大)"},
{id: "15", name: "(GMT-05:00)印地安那州(东部)"},
{id: "16", name: "(GMT-04:00)大西洋时间(美国和加拿大)"},
{id: "17", name: "(GMT-04:00)加拉加斯, 拉巴斯"},
{id: "18", name: "(GMT-04:00)圣地亚哥"},
{id: "19", name: "(GMT-03:30)纽芬兰"},
{id: "20", name: "(GMT-03:00)巴西利亚"},
{id: "21", name: "(GMT-03:00)布宜诺斯艾利斯, 乔治敦"},
{id: "22", name: "(GMT-03:00)格陵兰"},
{id: "23", name: "(GMT-02:00)中大西洋"},
{id: "24", name: "(GMT-01:00)佛得角群岛"},
{id: "25", name: "(GMT-01:00)亚速尔群岛"},
{id: "26", name: "(GMT)格林威治标准时间, name: 都柏林, 爱丁堡, 伦敦, 里斯本"},
{id: "27", name: "(GMT)卡萨布兰卡,蒙罗维亚"},
{id: "28", name: "(GMT+01:00)阿姆斯特丹，柏林，伯尔尼，罗马，斯德哥尔摩，维也纳"},
{id: "29", name: "(GMT+01:00)贝尔格莱德，布拉迪斯拉发，布达佩斯，卢布尔雅那，布拉格"},
{id: "30", name: "(GMT+01:00)布鲁塞尔，哥本哈根，马德里，巴黎"},
{id: "31", name: "(GMT+01:00)萨拉热窝，斯科普里，华沙，萨格勒布"},
{id: "32", name: "(GMT+01:00)中非西部"},
{id: "33", name: "(GMT+02:00)布加勒斯特"},
{id: "34", name: "(GMT+02:00)哈拉雷，比勒陀利亚"},
{id: "35", name: "(GMT+02:00)赫尔辛基，基辅，里加，索非亚，塔林，维尔纽斯"},
{id: "36", name: "(GMT+02:00)开罗"},
{id: "37", name: "(GMT+02:00)雅典，贝鲁特, 伊斯坦布尔, 明斯克"},
{id: "38", name: "(GMT+02:00)耶路撒冷"},
{id: "39", name: "(GMT+03:00)巴格达"},
{id: "40", name: "(GMT+03:00)科威特，利雅得"},
{id: "41", name: "(GMT+03:00)莫斯科，圣彼得堡, 伏尔加格勒"},
{id: "42", name: "(GMT+03:00)内罗毕"},
{id: "43", name: "(GMT+03:30)德黑兰"},
{id: "44", name: "(GMT+04:00)阿布扎比，马斯喀特"},
{id: "45", name: "(GMT+04:00)巴库, 第比利斯, 埃里温"},
{id: "46", name: "(GMT+04:30)喀布尔"},
{id: "47", name: "(GMT+05:00)叶卡捷琳堡"},
{id: "48", name: "(GMT+05:00)伊斯兰堡，卡拉奇 ,塔什干"},
{id: "49", name: "(GMT+05:30)马德拉斯，加尔各答，孟买，新德里"},
{id: "50", name: "(GMT+05:45)加德满都"},
{id: "51", name: "(GMT+06:00)阿拉木图，新西伯利亚"},
{id: "52", name: "(GMT+06:00)阿斯塔纳，达卡"},
{id: "53", name: "(GMT+06:00)斯里哈亚华登尼普拉"},
{id: "54", name: "(GMT+06:30)仰光"},
{id: "55", name: "(GMT+07:00)克拉斯诺亚尔斯克"},
{id: "56", name: "(GMT+07:00)曼谷，河内，雅加达"},
{id: "57", name: "(GMT+08:00)北京，重庆，香港特别行政区，乌鲁木齐"},
{id: "58", name: "(GMT+08:00)吉隆坡，新加坡"},
{id: "59", name: "(GMT+08:00)珀斯"},
{id: "60", name: "(GMT+08:00)台北"},
{id: "61", name: "(GMT+08:00)伊尔库茨克，乌兰巴图"},
{id: "62", name: "(GMT+09:00)大坂，札幌，东京"},
{id: "63", name: "(GMT+09:00)汉城"},
{id: "64", name: "(GMT+09:00)雅库茨克"},
{id: "65", name: "(GMT+09:30)阿德莱德"},
{id: "66", name: "(GMT+09:30)达尔文"},
{id: "67", name: "(GMT+10:00)布里斯班"},
{id: "68", name: "(GMT+10:00)符拉迪沃斯托克"},
{id: "69", name: "(GMT+10:00)关岛，莫尔兹比港"},
{id: "70", name: "(GMT+10:00)霍巴特"},
{id: "71", name: "(GMT+10:00)堪培拉，墨尔本，悉尼"},
{id: "72", name: "(GMT+11:00)马加丹，索罗门群岛，新喀里多尼亚"},
{id: "73", name: "(GMT+12:00)奥克兰，惠灵顿"},
{id: "74", name: "(GMT+12:00)斐济，堪察加半岛，马绍尔群岛"},
{id: "75", name: "(GMT+13:00)努库阿洛法"}
];
let timezones = TIMEZONES.slice(0);
export {
timezones
}
|
$(document).ready(function() {
$('#example').DataTable( {
"processing": true,
"serverSide": true,
"ajax": "/iteminfolist",
columns: [
{ data: "Id" },
{ data: 'Sn' },
{ data: 'CarNo' },
{ data: "Time" },
{ data: 'Longitude' },
{ data: 'Latitude' } ,
{ data: 'Height' },
{ data: "Gear" },
{ data: 'FootBrakeAngle' },
{ data: 'HandBrake' },
{ data: "Safetybelt" },
{ data: 'Trumpet' },
{ data: 'HeadLight' } ,
{ data: 'DistanceLight' },//远光灯
{ data: 'ShutDownSignal' },
{ data: 'FrontFogLamp' },
{ data: "RearFogLamp" },
{ data: 'EmergencyLight' },
{ data: 'StartSignal' } ,
{ data: 'MotoSpeed' },
{ data: "WidthLamp" },
{ data: 'LeftTurnSignal' },
{ data: 'RightTurnSignal' },
{ data: "WindscreenWiper" },
{ data: 'CarSpeed' },
{ data: 'ACC' } ,
{ data: 'ElectricQuantity' }
],
dataSrc: function(data){
// var obj =result;
// var data = obj.results;
// var aaData = [];
// var dataResult = {};
// dataResult.iTotalRecords = obj.totalcount;
// dataResult.iTotalDisplayRecords= obj.totalcount;
// dataResult.iDisplayStart = obj.offset;
// dataResult.iDisplayLength= obj.limit;
// dataResult.aaData = aaData;
var datasource={}
if (data.code == 0) {
if(data.Results==null)
datasource.length=0;
else
datasource=data.Results;
}else{
datasource.length=0;
}
return datasource
}
} );
} );
|
import Cart from 'Components/Cart'
import { Avatar, Button, Dropdown, Menu } from 'Components/UI-Library'
import {
LogoutOutlined,
ProfileOutlined,
SearchOutlined,
UserOutlined,
} from 'Components/UI-Library/Icons'
import { ROUTER } from 'Constants/CommonConstants'
import { useStoreActions, useStoreState } from 'easy-peasy'
import isEmpty from 'lodash/isEmpty'
import React, { useState } from 'react'
import { Link, useHistory } from 'react-router-dom'
import './NavBar.Style.less'
import SearchBar from './SearchBar.Component'
const Navbar = () => {
const history = useHistory()
const [openSearch, setOpenSearch] = useState(false)
const user = useStoreState((state) => state.auth.user)
const removeUser = useStoreActions((actions) => actions.auth.removeUser)
const handleOpenSearch = () => {
setOpenSearch(!openSearch)
}
const handleLogout = () => {
removeUser()
}
const handleToProfile = (e) => {
e.preventDefault()
history.push(ROUTER.Profile)
}
const handleToLogin = (e) => {
e.preventDefault()
history.push(ROUTER.Login)
}
return (
<div className="nav-bar">
<div className="search">
<Button className="btn-search" onClick={handleOpenSearch}>
<SearchOutlined className="search-icon" />
</Button>
{openSearch && <SearchBar />}
</div>
<Dropdown
overlay={
<Menu>
{!isEmpty(user) ? (
<>
<Menu.Item>
<Link to={ROUTER.Profile}>
<ProfileOutlined /> Profile
</Link>
</Menu.Item>
<Menu.Item onClick={handleLogout}>
<LogoutOutlined /> Log Out
</Menu.Item>
</>
) : (
<Menu.Item>
<Link to={ROUTER.Register}>Register</Link>
</Menu.Item>
)}
</Menu>
}
>
<Link
to=""
className="login ant-dropdown-link"
onClick={!isEmpty(user) ? handleToProfile : handleToLogin}
>
<Avatar size="small" className="avatar" icon={<UserOutlined />} />
{!isEmpty(user) ? `${user.firstName}` : 'Log In'}
</Link>
</Dropdown>
<Cart />
</div>
)
}
export default Navbar
|
import React from 'react';
import ScrollToButtom from 'react-scroll-to-bottom';
import Message from './Message/message';
import '../../style/messages.scss';
const Messages = (props) => {
return (
<ScrollToButtom className="messagesContainer">
{props.messages.map((message,i) => (
<div className="messageContainer" key={i}>
<Message
message = {message}
/>
</div>
))}
</ScrollToButtom>
);
}
export default Messages;
|
// soundmanager.js
// Defines the Sound Manager
var inherits = require("inherits");
var extend = require("extend");
var EventEmitter = require("events").EventEmitter;
var audioContext;
var MAX_MUSIC = 8; //Max number of music tracks cached in memory
var MAX_SOUNDS = 16; //Max number of sounds cached in memory
/**
*/
function SoundManager() {
this.testSupport();
this.preloadSound("walk_bump");
this.preloadSound("walk_jump");
this.preloadSound("walk_jump_land");
this.preloadSound("exit_walk");
this.registerPreloadedMusic("m_tornworld", {
tag: DORITO_MUSIC,
loopStart: 13.304,
loopEnd: 22.842,
});
}
inherits(SoundManager, EventEmitter);
extend(SoundManager.prototype, {
sounds : {},
music: {},
ext : null,
createAudio: null,
__muted_music: false,
__muted_sound: false,
__vol_music: 0.5,
__vol_sound: 0.5,
testSupport : function() {
var testsound = new Audio();
var ogg = testsound.canPlayType("audio/ogg; codecs=vorbis");
if (ogg) this.ext = ".ogg";
else this.ext = ".mp3";
try {
audioContext = new (window.AudioContext || window.webkitAudioContext)();
if (audioContext) {
this.createAudio = createAudio_WebAPI;
} else {
this.createAudio = createAudio_Tag;
}
this.__audioContext = audioContext;
} catch (e) {
this.createAudio = createAudio_Tag;
}
},
////////////////////////// Loading //////////////////////////////
/** Loads sound from the server, used as part of the startup process. */
preloadSound : function(id) {
if (!this.sounds[id]) {
this.sounds[id] = this.createAudio(id, {
url : BASEURL+"/snd/" + id + this.ext,
});
this.sounds[id].mustKeep = true;
this.emit("load_sound", id);
}
return this.sounds[id];
},
/** Loads music from the server, used as part of the startup process. */
registerPreloadedMusic: function(id, info) {
if (!this.music[id]) {
this.music[id] = createAudio_Tag(id, info); //force using this kind
this.music[id].mustKeep = true;
this.emit("load_music", id);
}
return this.music[id];
},
/** Loads sound from data extracted from the map zip file. */
loadSound: function(id, info) {
if (!this.sounds[id]) {
this.sounds[id] = this.createAudio(id, info);
this.emit("load_sound", id);
}
return this.sounds[id];
},
/** Loads music from data extracted from the map zip file. */
loadMusic: function(id, info) {
if (!this.music[id]) {
this._ensureRoomForMusic();
this.music[id] = this.createAudio(id, info);
this.emit("load_music", id);
}
return this.music[id];
},
isMusicLoaded: function(id) {
return !!this.music[id];
},
isSoundLoaded: function(id) {
return !!this.sounds[id];
},
_ensureRoomForMusic: function() {
if (Object.keys(this.music).length+1 <= MAX_MUSIC) return;
var oldestDate = new Date().getTime();
var oldestId = null;
for (var id in this.music) {
var m = this.music[id]
if (m.mustKeep) continue;
if (m.loadDate < oldestDate) {
oldestDate = m.loadDate;
oldestId = id;
}
}
this.music[oldestId].unload();
delete this.music[oldestId];
this.emit("unloaded-music", oldestId);
},
/////////////////////////////// Playing ///////////////////////////////
playSound : function(id) {
if (this.muted_sound) return;
if (!this.sounds[id]) {
console.error("Sound is not loaded!", id);
return;
}
this.sounds[id].play();
},
playMusic: function(id){
var m = this.music[id];
if (!m) return;
if (m.playing) return; //already playing
var startDelay = 0;
for (var id in this.music) {
if (this.music[id].playing) {
this.stopMusic(id);
startDelay = 1000;
}
}
setTimeout(function(){
m.playing = true;
if (this.muted_music) return;
m.playing_real = true;
m.play();
}, startDelay);
},
pauseMusic: function(id){
var m = this.music[id];
if (!m) return;
m.playing = m.playing_real = false;
m.pause();
},
toggleMusic: function(id) {
var m = this.music[id];
if (!m) return;
if (m.playing) {
m.playing = m.playing_real = false;
m.pause();
} else {
m.playing = true;
if (this.muted_music) return;
m.playing_real = true;
m.play();
}
},
stopMusic: function(id){
var m = this.music[id];
if (!m) return;
// m.playing = m.playing_real = false;
//m.pause();
//m.currentTime = 0;
m.fadeout = true;
},
_tick: function(delta) {
for (var id in this.music) {
this.music[id].loopTick(delta);
}
},
});
Object.defineProperties(SoundManager.prototype, {
vol_music: {
enumerable: true,
get: function() { return this.__vol_music; },
set: function(vol) {
this.__vol_music = Math.clamp(vol);
for (var id in this.music) {
this.music[id].setVolume(this.__vol_music);
}
},
},
vol_sound: {
enumerable: true,
get: function() { return this.__vol_sound; },
set: function(vol) {
this.__vol_sound = Math.clamp(vol);
for (var id in this.sounds) {
this.sounds[id].setVolume(this.__vol_sound);
}
},
},
muted_music: {
enumerable: true,
get: function() { return this.__muted_music; },
set: function(val) {
this.__muted_music = val;
for (var id in this.music) {
this.music[id].setMuted(val);
}
},
},
muted_sound: {
enumerable: true,
get: function() { return this.__muted_sound; },
set: function(val) {
this.__muted_sound = val;
for (var id in this.sounds) {
this.sounds[id].setMuted(val);
}
},
},
__vol_music: { enumerable: false, writable: true, },
__vol_sound: { enumerable: false, writable: true, },
__muted_music: { enumerable: false, writable: true, },
__muted_sound: { enumerable: false, writable: true, },
});
///////////////////////////// Sound Objects ///////////////////////////////
function SoundObject(opts) {
extend(this, opts);
this.loadDate = new Date().getTime();
}
extend(SoundObject.prototype, {
playing: false, //sound is playing, theoretically (might be muted)
playing_real: false, //sound is actually playing and not muted
loopStart: 0,
loopEnd: 0,
loadDate: 0, //milisecond datestamp of when this was loaded, for cache control
mustKeep: false, //if we should skip this object when determining sounds to unload
fadeout: false,
play: function(){},
pause: function(){},
setVolume: function(vol){},
setMuted: function(muted){},
loopTick: function(delta){},
unload: function(){},
});
//////////////////////////// Audio Tag Implementation ////////////////////////////
function createAudio_Tag(id, info) {
var snd;
if (info.tag) {
snd = info.tag;
} else if (info.url) {
snd = new Audio();
snd.autoplay = false;
snd.autobuffer = true;
snd.preload = "auto";
snd.src = info.url;
$("body").append( $(snd.tag).css({display:"none"}) );
} else {
throw new Error("Called createAudio without any info!");
}
var sobj = new SoundObject({
__tag: snd,
__bloburl: info.url,
loopStart: info.loopStart || 0,
loopEnd: info.loopEnd || 0,
play: function() {
this.__tag.play();
},
pause: function() {
this.__tag.pause();
},
setVolume: function(vol) {
this.__tag.volume = vol;
},
setMuted: function(muted) {
if (muted) {
this.playing_real = false;
this.__tag.pause();
} else {
if (this.playing) {
this.playing_real = true;
this.__tag.play();
}
}
},
loopTick: function(delta) {
if (!this.loopEnd || !this.playing_real) return;
//TODO support this.fadeout
if (this.__tag.currentTime >= this.loopEnd) {
this.__tag.currentTime -= (this.loopEnd - this.loopStart);
}
},
unload: function() {
if (this.__bloburl)
URL.revokeObjectURL(this.__bloburl);
$(this.tag).remove();
delete this.tag;
},
});
snd.on("ended", function(){
sobj.playing = false;
sobj.playing_real = false;
snd.currentTime = 0;
});
snd.load();
return sobj;
}
////////////////////////// Web Audio API Implementation //////////////////////////
function createAudio_WebAPI(id, info) {
var sobj = new SoundObject({
__audioBuffer: null,
__tag: null,
__gainCtrl: null,
__muteCtrl: null,
__bloburl: null,
__debugAnalyser: null,
__currSrc: null,
loopStart: info.loopStart || 0,
loopEnd: info.loopEnd || 0,
play: function() {
var src;
if (this.__audioBuffer) {
src = audioContext.createBufferSource();
src.buffer = this.__audioBuffer;
} else if (this.__tag) {
src = audioContext.createMediaElementSource(info.tag);
} else {
console.log("No audio buffer ready to play!");
return;
}
src.loop = !!info.loopEnd;
if (!!info.loopEnd) {
src.loopStart = info.loopStart;
src.loopEnd = info.loopEnd;
}
src.on("ended", function(){
sobj.playing = false;
sobj.playing_real = false;
sobj.__currSrc = null;
});
src.connect(this.__gainCtrl);
src.start();
this._playing = true;
this.__currSrc = src;
},
pause: function() {
this.__currSrc.stop();
this.__currSrc = null;
},
setVolume: function(vol) {
this.__gainCtrl.gain.value = vol;
},
setMuted: function(muted) {
if (this.fadeout) return; //ignore during fadeout
this.__muteCtrl.gain.value = (muted)? 0 : 1;
},
loopTick: function(delta) {
if (this.fadeout) {
if (this.__muteCtrl.gain.value > 0.001) {
this.__muteCtrl.gain.value -= delta * 0.5;
// console.log(this.__muteCtrl.gain.value);
} else {
this.__currSrc.stop();
this.__currSrc = null;
this.fadeout = false;
this.playing = this.playing_real = false;
this.__muteCtrl.gain.value = 1;
}
}
},
unload: function(){
if (this.__bloburl)
URL.revokeObjectURL(this.__bloburl);
delete this.__bloburl;
delete this.__audioBuffer;
delete this.__tag;
delete this.__gainCtrl;
delete this.__muteCtrl;
},
});
if (info.tag) {
sobj.__tag = info.tag;
} else if (info.data) {
currentMap.markLoading("DecodeAudio_"+id);
var fr = new FileReader();
fr.on("load", function(){
audioContext.decodeAudioData(fr.result, function(buffer){
sobj.__audioBuffer = buffer;
if (sobj.playing_real) {
sobj.play();
}
currentMap.markLoadFinished("DecodeAudio_"+id);
});
});
fr.readAsArrayBuffer(info.data);
} else if (info.url) {
var xhr = new XMLHttpRequest();
xhr.open("GET", info.url);
xhr.responseType = 'arraybuffer';
xhr.on("load", function(e) {
// console.log("LOAD:", e);
if (xhr.status != 200) {
console.error("ERROR LOADING AUDIO:", xhr.statusText);
return;
}
var data = xhr.response;
audioContext.decodeAudioData(xhr.response, function(buffer){
sobj.__audioBuffer = buffer;
if (sobj.playing_real) {
sobj.play();
}
});
});
xhr.on("error", function(e){
console.error("ERROR LOADING AUDIO!!", e);
});
if (info.url.indexOf("blob") > -1) {
this.__bloburl = info.url;
}
xhr.send();
} else {
throw new Error("Called createAudio without any info!");
}
sobj.__gainCtrl = audioContext.createGain();
//TODO look into 3d sound fun: https://developer.mozilla.org/en-US/docs/Web/API/AudioContext.createPanner
sobj.__muteCtrl = audioContext.createGain();
sobj.__gainCtrl.connect(sobj.__muteCtrl);
//TODO
var finalNode = sobj.__muteCtrl;
if (DEBUG.setupAdditionalAudioFilters) {
finalNode = DEBUG.setupAdditionalAudioFilters(id, audioContext, finalNode);
}
if (DEBUG.soundAnalyzer) {
var da = sobj.__debugAnalyser = audioContext.createAnalyser();
da.fftSize = 1024;//2048;
this.emit("DEBUG-AnalyserCreated", id, da);
finalNode.connect(da);
da.connect(audioContext.destination);
} else {
finalNode.connect(audioContext.destination);
}
return sobj;
}
///////////////////////////////////////////////////////////////////////////////////
module.exports = new SoundManager();
|
// import React, { useState } from "react";
// import { Dashboard } from "../../_metronic/_partials";
// export function DashboardPage() {
// return (
// // <Dashboard />
// <>
// <h1>Dashboard</h1>
// <Dashboard />
// </>
// );
// }
import React, { useEffect, useState } from "react";
import { Bar } from "react-chartjs-2";
import { MixedWidget1 } from "../../_metronic/_partials/widgets";
import CompanyService from "../services/CompanyService";
import CompanyDepChart from "./CompanyDepChart";
import CompanyUsersChart from "./CompanyUsersChart";
import { Dropdown } from "react-bootstrap";
export function DashboardPage() {
const [allCompanies, setAllCompanies] = useState([]);
const [monthNames, setMonthNames] = useState([
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
]);
const [month, setMonth] = useState("January");
useEffect(() => {
CompanyService.getAllCompanies()
.then((res) => {
console.log("AllCompanies: ", res);
setAllCompanies(res);
})
.catch((err) => console.log("Error: ", err));
}, []);
return (
<>
<div className="col-lg-12">
<MixedWidget1 className="card-stretch gutter-b" />
</div>
<div className="row">
<div className="col-md-12">
<div className={`card card-custom mb-5`}>
{/* Header bg-light-warning bg-light-success bg-light-danger bg-light-info */}
{/* success */}
{/* font-weight-normal text-dark-75 text-hover-primary font-size-lg mb-1 */}
{/* font-weight-bolder text-success py-1 font-size-lg */}
<div className="card-header border-0 bg-light-success py-5">
<h3 className="card-title font-weight-bolder text-success py-1 font-size-lg ">
Companies Stat for {month}
</h3>
<div className="card-toolbar">
<Dropdown className="dropdown-inline" drop="down" alignRight>
<Dropdown.Toggle
id="dropdown-autoclose-inside"
className="btn btn-light-danger btn-sm font-weight-bolder dropdown-toggle px-5 btn btn-transparent"
variant="transparent"
// id="dropdown-toggle-top"
>
Select Month
</Dropdown.Toggle>
<Dropdown.Menu className="dropdown-menu dropdown-menu-sm dropdown-menu-right">
{/* <DropdownMenu2 /> */}
{/*begin::Navigation*/}
<ul className="navi navi-hover">
{monthNames.map((monthName) => (
<li className="navi-item" key={monthName}>
<a href="#" className="navi-link">
<span
className="navi-text"
value={monthName}
onClick={(e) => {
console.log(monthName);
setMonth(monthName);
}}
>
{monthName}
</span>
</a>
</li>
))}
</ul>
{/*end::Navigation*/}
</Dropdown.Menu>
</Dropdown>
</div>
</div>
{/* <div className="card-body d-flex flex-column">Companies</div> */}
</div>
</div>
{allCompanies.map((company) => (
<div className="col-md-6" key={company._id}>
<div className={`card card-custom mb-5`}>
<div className="card-body d-flex flex-column p-0 ">
<CompanyDepChart companyId={company._id} month={month} />
</div>
</div>
</div>
))}
<div className="col-md-12">
<div className={`card card-custom mb-5`}>
<div className="card-header border-0 bg-light-warning py-5">
<h3 className="card-title font-weight-bolder text-warning py-1 font-size-lg ">
Companies Users Stat for {month}
</h3>
</div>
</div>
</div>
{allCompanies.map((company) => (
<div className="col-md-12" key={company._id}>
<div className={`card card-custom mb-5`}>
<div className="card-body d-flex flex-column p-0 ">
<CompanyUsersChart
companyId={company._id}
month={month}
companyName={company.companyName}
/>
</div>
</div>
</div>
))}
{/* <div className="col-md-6">
<div className={`card card-custom`}>
<GetVerticalChart />
</div>
</div> */}
</div>
</>
);
}
|
/**
* Created by Jorge on 23/05/2015.
*/
define(function (require) {
var $ = require('jquery'),
BaseController = require('./controller/BaseController'),
SurveyController = require('./controller/SurveyController');
var baseController = new BaseController();
var surveyController = null;
var run = function () {
$('#title').text(surveyController.getSurvey().getTitle());
$('#description').text(surveyController.getSurvey().getDescription());
var questions = $('#questions');
console.log(surveyController.getSurvey().getQuestions().length);
surveyController.getSurvey().getQuestions().forEach(function (question) {
var container = $('<div style="padding-bottom: 40px"></div>');
container.append($('<p><strong>' + question.getTitle() + '</strong></p>'));
switch (question.getType()) {
case 0:
if (question.isSingleLine())
container.append($('<div class="form-control-wrapper">' +
'<input type="text" class="form-control empty">' +
'<div class="floating-label">resposta</div>' +
'<span class="material-input"></span></div>'));
else
container.append($('<textarea class="form-control" placeholder="resposta" ' +
'style="margin: 0px -3.75px 0px 0px; height: 40px;"></textarea>'));
break;
case 1:
if (question.isSingleChoice())
question.getOptions().forEach(function (option) {
container.append($('<div class="checkbox"<label><input type="checkbox">' +
'<span class="checkbox-material"><span class="check">' +
'</span></span>' + option + '</label></div>'))
});
break;
}
questions.append(container);
});
var page = $('#survey-page');
page.show();
var totop = setInterval(function () {
$(".pages").animate({scrollTop: 0}, 0);
}, 1);
setTimeout(function () {
page.addClass("active");
setTimeout(function () {
clearInterval(totop);
}, 1000);
}, 100);
};
$(function () {
console.log('Page loaded');
$(document).on('ufjf.survey.loaded', function () {
run();
//Show content
$('#loading').fadeOut(500);
});
//Loading Project
surveyController = new SurveyController(baseController, /*window.location.hash.slice(1)*/'5567972b08acd67810514631');
});
});
|
import React from "react";
import InputAdornment from "@material-ui/core/InputAdornment";
// @material-ui/icons
import Email from "@material-ui/icons/Email";
import Note from "@material-ui/icons/Note";
import People from "@material-ui/icons/People";
// core components
import GridContainer from "../../components/Grid/GridContainer";
import GridItem from "../../components/Grid/GridItem";
import Card from "../../components/Card/Card";
import CardBody from "../../components/Card/CardBody";
import CardHeader from "../../components/Card/CardHeader";
import CustomInput from "../../components/CustomInput/CustomInput";
class ViewMessage extends React.Component {
constructor(props) {
super(props);
// we use this to make the card to appear after the page has been rendered
this.state = {
cardAnimaton: "cardHidden"
};
}
componentDidMount() {
// we add a hidden class to the card and after 700 ms we delete it and the transition appears
this.cardAnimation = setTimeout(
function() {
this.setState({ cardAnimaton: "" });
}.bind(this),
700
);
}
//This is use to stop setTimeout
//in case user leave the page before the setTimout occur
//This prevent memory leakage
componentWillUnmount(){
clearTimeout(this.cardAnimation);
}
render() {
return (
<div>
<div>
<GridContainer justify="center">
<GridItem>
<Card>
<form>
<CardHeader color="primary">
<h4>View Message</h4>
<p>From Anne Barley</p>
</CardHeader>
<CardBody>
<CustomInput
labelText="Sender"
id="sender"
formControlProps={{
fullWidth: true
}}
inputProps={{
type: "text",
value: "Anne Barley",
endAdornment: (
<InputAdornment position="end">
<People />
</InputAdornment>
)
}}
/>
<CustomInput
labelText="Email..."
id="email"
formControlProps={{
fullWidth: true
}}
inputProps={{
type: "email",
value: "annebarley@example.com",
endAdornment: (
<InputAdornment position="end">
<Email />
</InputAdornment>
)
}}
/>
<CustomInput
labelText="Subject"
id="pass"
formControlProps={{
fullWidth: true
}}
inputProps={{
type: "text",
value: "Black Jeans",
endAdornment: (
<InputAdornment position="end">
<Note
/>
</InputAdornment>
)
}}
/>
<CustomInput
labelText="Message Content"
id="content"
formControlProps={{
fullWidth: true
}}
inputProps={{
multiline: true,
rows: 5,
value: "The jean sent to me is not pure denim as I saw on the picture and the color is faded",
endAdornment: (
<InputAdornment position="end">
<Note
/>
</InputAdornment>
)
}}
/>
</CardBody>
</form>
</Card>
</GridItem>
</GridContainer>
</div>
</div>
);
}
}
export default ViewMessage;
|
'use strict'
/** @typedef { import('./types').Suite } Suite */
const Suites = require('../suites')
const { splitX } = require('./utils')
const { ecctlSize } = require('./deployment')
module.exports = {
getSuite,
getSuites,
validateSuite,
}
// prefix scenario names with sortable index
for (const suite of Suites) {
let index = 1
for (const scenario of suite.scenarios) {
scenario.sortName = `${index++}: ${scenario.name}`
}
}
/** @type { () => Suite[] } */
function getSuites() {
return clone(Suites)
}
/** @type { (id: string) => Suite | undefined } */
function getSuite(id) {
return clone(Suites.find(suite => suite.id === id))
}
/** @type { (suite: Suite) => void } */
function validateSuite({ id, description, scenarios }) {
if (typeof id !== 'string') throw new Error(`invalid suite.id: "${id}"`)
if (typeof description !== 'string') throw new Error(`invalid suite.description: "${description}"`)
if (!Array.isArray(scenarios)) throw new Error(`invalid suite.scenarios: not an array`)
for (const scenario of scenarios) {
const { name, version, esSpec, kbSpec, alerts, alertInterval } = scenario
const { tmMaxWorkers, tmPollInterval } = scenario
let prefix = `for suite "${id}",`
if (typeof name !== 'string') throw new Error(`${prefix} invalid scenario.name: "${name}"`)
prefix = `${prefix} scenario "${name}",`
if (typeof version !== 'string') throw new Error(`${prefix} invalid scenario.version: "${version}"`)
if (typeof esSpec !== 'string') throw new Error(`${prefix} invalid scenario.esSpec: "${esSpec}"`)
if (typeof kbSpec !== 'string') throw new Error(`${prefix} invalid scenario.kbSpec: "${kbSpec}"`)
if (typeof alerts !== 'number') throw new Error(`${prefix} invalid scenario.alerts: "${alerts}"`)
if (typeof alertInterval !== 'string') throw new Error(`${prefix} invalid scenario.alertInterval: "${alertInterval}"`)
if (typeof tmPollInterval !== 'number') throw new Error(`${prefix} invalid scenario.tmPollInterval: "${tmPollInterval}"`)
if (typeof tmMaxWorkers !== 'number') throw new Error(`${prefix} invalid scenario.tmMaxWorkers: "${tmMaxWorkers}"`)
const esSizes = splitX(esSpec)
const kbSizes = splitX(kbSpec)
if (esSizes == null) throw new Error(`${prefix} invalid scenario.esSpec: should be in the form MxN`)
if (kbSizes == null) throw new Error(`${prefix} invalid scenario.kbSpec: should be in the form MxN`)
try {
ecctlSize(esSpec, 'elasticsearch')
} catch (err) {
throw new Error(`${prefix} invalid scenario.esSpec "${esSpec}": ${err.message}`)
}
try {
ecctlSize(kbSpec, 'kibana')
} catch (err) {
throw new Error(`${prefix} invalid scenario.kbSpec "${kbSpec}": ${err.message}`)
}
}
}
/**
* @template T
* @type { (object: T) => T }
* */
function clone(object) {
if (object == null) return object
return JSON.parse(JSON.stringify(object))
}
|
(function(){
var app = angular.module("app", ["onsen"]);
app.controller('contacts', ['$scope', 'ContactsFactory', function($scope,ContactsFactory)
{
$scope.items = {};
$scope.findContact = function (contactSearch)
{
ContactsFactory.find(contactSearch).then(function(contacts)
{
$arr = [];
for (var i = 0; i < contacts.length; i++)
{
if (contacts[i].displayName !== null)
{
for (var j = 0; j < contacts[i].displayName.length; j++)
{
$arr.push({name: contacts[i].displayName})
}
}
}
$scope.contacts = $arr;
});
};
$scope.items = $scope.contacts;
$scope.showDetail = function(index) {
alert(index);
var selectedItem = $scope.contacts[index];
$scope.selectedItem = selectedItem;
$scope.navi.pushPage('detail.html', {title : selectedItem.name});
};
}]);
app.controller('DetailController', function($scope) {
$scope.item = $scope.selectedItem;
});
app.factory("ContactsFactory", ['$q', function($q)
{
return {
find: function(filter)
{
//promesas
var deferred = $q.defer();
//opciones de contactos
var options = new ContactFindOptions();
//añadimos los filtros de búsqueda
options.filter = filter;
options.multiple = true;
//campos que queremos obtener
var fields = ["displayName"];
//acepta tres parámetros, los campos, la respuesta, el error y las opciones
navigator.contacts.find(fields, function (contacts)
{
deferred.resolve(contacts);
},
function(error)
{
deferred.reject(error);
},
options);
return deferred.promise;
}
};
}]);
})();
|
$(function() {
$("#getComments").click(function() {
viewModel.comments([]);
$.get('/api/comments', function(data) {
viewModel.comments(data);
});
});
});
|
import React, { useState, useRef, useEffect } from 'react'
import { graphql, Link } from "gatsby"
import Layout from '../components/Layout/Layout'
import Header from '../components/Header/Header'
import Navigation from '../components/Navigation/Navigation'
import "./styles.scss"
import BackgroundImage from 'gatsby-background-image'
import SEO from "../components/SEO/SEO"
import ZoomedImage from "../components/ZoomedImage/ZoomedImage"
import { DismissMenuContext } from "../utils/context"
export default data => {
const [scrollTop, setScrollTop] = useState(0);
const [showSecondNav, setShowSecondNav] = useState(false)
const scrollRef = useRef()
useEffect(() => {
if (scrollTop >= 200) {
setShowSecondNav(true)
} else {
setShowSecondNav(false)
}
const onScroll = e => {
setScrollTop(e.target.documentElement.scrollTop);
};
window.addEventListener("scroll", onScroll);
return () => window.removeEventListener("scroll", onScroll);
}, [scrollTop]);
const [state] = useState(() => {
const images = data.data.images.edges
const pageName = data.pageContext.slug.split('/')
const displayedName = pageName[pageName.length - 1].replace(/-/g, ' ')
const description = data.data.description.edges[0].node.childMarkdownRemark.html
const metaDescription = data.data.description.edges[0].node.childMarkdownRemark.plainText
const metaCanonical = "http://www.maisondesign.ro/" + data.pageContext.slug
return {
images,
displayedName,
description,
metaDescription,
metaCanonical
}
})
return <Layout>
<SEO title={state.displayedName.toUpperCase() + " | Maison Design"}
description={state.metaDescription}
canonical={state.metaCanonical} robots="index, follow" />
<Header image={data.data.discover2.childImageSharp.fluid} className="header-cataloage header-mid">
<div className="header-cataloage_content">
<DismissMenuContext.Provider value={{ showSecondNav: !showSecondNav, setShowSecondNav }}>
<Navigation className="navigation-cataloage" />
</DismissMenuContext.Provider>
<div className="header-filter" id="header-filter"></div>
<p>{state.displayedName}</p>
</div>
</Header>
{
scrollRef.current && (scrollTop >= 200) && <div style={{ position: "absolute", top: "0px" }}>
<DismissMenuContext.Provider value={{ showSecondNav, setShowSecondNav }}>
<Navigation />
</DismissMenuContext.Provider>
</div>
}
<div className="produse-images" ref={scrollRef}>
{
state.images.map(image => <ZoomedImage image={image.node.childImageSharp.fluid} text="" />)
}
</div>
{
state.description &&
<div className="page-description">
<p dangerouslySetInnerHTML={{ __html: state.description }} />
</div>
}
<BackgroundImage fluid={data.data.discover2.childImageSharp.fluid} className="discover-image">
<div className="header-filter"></div>
<p>Ai un plan? Contactează-ne</p>
<Link to="/contact">Contact</Link>
</BackgroundImage>
</Layout >
}
export const query = graphql`
query ($slug:String!){
discover2:file(relativePath:{eq:"discover2.png"}) {
childImageSharp {
fluid(maxWidth:1600,maxHeight:750) {
...GatsbyImageSharpFluid
}
}
}
images: allFile(filter: {relativeDirectory: {eq: $slug}, extension: {in: ["jpg", "jpeg", "png"]}}, sort: {order: DESC, fields: childImageSharp___resolutions___height}) {
edges {
node {
name
childImageSharp {
fluid(quality: 100, pngQuality: 100, jpegQuality: 100) {
...GatsbyImageSharpFluid
}
}
}
}
}
description: allFile(filter: {relativeDirectory: {eq: $slug}, extension: {eq: "md"}}, limit: 1) {
edges {
node {
name
childMarkdownRemark {
html
plainText
}
}
}
}
}
`
|
'use strict';
/**
* Created by Indexyz on 2016/7/14.
*/
class MojangApi{
constructor(){
this.versionIndex = "https://launchermeta.mojang.com/mc/game/version_manifest.json";
this.librariesUrl = "https://libraries.minecraft.net/";
this.assetsUrl = "http://resources.download.minecraft.net/";
this.assetIndex = "https://s3.amazonaws.com/Minecraft.Download/indexes/";
this.assetDownload = "http://resources.download.minecraft.net/";
}
}
module.exports = MojangApi;
|
import React, {Component} from "react";
import ReactDOM from "react-dom";
import Search from'./Search'
class SearchBar extends Component{
constructor(props) {
super(props);
this.state = {
searchvalue :'',
}}
handleSearch = (event) => {
this.setState({
searchvalue : event.target.value
})}
handlesubmit = (event) => {
event.preventDefault()
this.setState({
searchvalue : this.state.searchvalue
}, this.props.searchOutput(this.state.searchvalue)
//,console.log (`this is form searchbar ${this.state.searchvalue}`)
)}
render() {
return (
<form onSubmit = {this.handlesubmit}>
<div>
<h1> The Search </h1>
<input
type= 'text'
value = {this.state.searchvalue}
onChange = {this.handleSearch} />
<button type ='submit' >Search </button>
</div>
</form>
)}
}
export default SearchBar
|
const { InputValidation } = require('ebased/schema/inputValidation');
class InputSchema extends InputValidation {
constructor(payload, meta) {
super({
source: meta.status,
payload,
source: meta.source,
specVersion: 'v1.0.0',
schema: {
strict: true,
id: { type: String, required: true },
dni: { type: String, required: true },
name: { type: String, required: true },
birth: { type: Date, required: true }
}
});
}
}
module.exports = InputSchema;
|
// @flow
import React from 'react'
import { storiesOf } from '@kadira/storybook'
import Label from 'components/Label'
import Input from 'components/Input'
import Select from 'components/Select'
import Field from './'
const options = [
{
label: 'Rr',
value: 'dr',
},
{
label: 'Mr',
value: 'mr',
},
{
label: 'Ms',
value: 'ms',
},
{
label: 'Miss',
value: 'miss',
},
]
storiesOf('Field', module)
.add('default', () => (
<Field>
<Label>Name</Label>
<Input leftIcon="fa-user" />
</Field>
))
.add('with addons', () => (
<Field className="has-addons">
<Select options={options} />
<Input leftIcon="fa-user" />
</Field>
))
.add('with addons & expanded', () => (
<Field className="has-addons">
<Select options={options} />
<Input className="is-expanded" leftIcon="fa-user" />
</Field>
))
// .add('horizontal', () => (
// <Field className="is-horizontal">
// <div className="field-label is-normal">
// <Label>Name</Label>
// </div>
// <div className="field-body">
// <Field>
// <Input leftIcon="fa-user" />
// </Field>
// </div>
// </Field>
// ))
|
import React from 'react';
import { withStyles } from '@material-ui/core';
import PropTypes from 'prop-types';
import List from '@material-ui/core/List';
import Typography from '@material-ui/core/Typography';
import shortid from 'shortid';
import UserItem from '../UserItem';
const UserList = ({
list,
name,
lastname,
age,
sex,
getFilteredUsers,
classes,
}) => {
const filteredUsers = getFilteredUsers(list, name, lastname, age, sex);
return (
<>
{filteredUsers.length === 0 && (
<Typography className={classes.text}>
Пользователь по результату поиска не найден!!!
</Typography>
)}
<List className={classes.list}>
{filteredUsers.map(user => (
<UserItem key={shortid()} item={user} />
))}
</List>
</>
);
};
UserList.defaultProps = {
name: '',
lastname: '',
age: '',
sex: '',
};
UserList.propTypes = {
list: PropTypes.PropTypes.arrayOf(
PropTypes.shape({
name: PropTypes.string.isRequired,
lastname: PropTypes.string.isRequired,
age: PropTypes.number.isRequired,
sex: PropTypes.string.isRequired,
}).isRequired,
).isRequired,
name: PropTypes.string,
lastname: PropTypes.string,
age: PropTypes.string,
sex: PropTypes.string,
getFilteredUsers: PropTypes.func.isRequired,
classes: PropTypes.shape({
list: PropTypes.string.isRequired,
text: PropTypes.string.isRequired,
}).isRequired,
};
const styles = () => ({
list: {
display: 'flex',
justifyContent: 'space-between',
flexWrap: 'wrap',
margin: '0 auto',
width: 800,
},
text: {
margin: '60px auto 0 auto',
fontSize: 36,
color: '#424242',
},
});
export default withStyles(styles)(UserList);
|
Ext.Viewport.add(
Ext.create('Ext.Panel', {
width: '50%',
height: '50%',
// layout: 'fit',
items: [
{
xtype: 'panel',
html: 'Fits exact coordinates',
styleHtmlContent: true,
}
]
})
);
|
import React from "react";
import { useDispatch } from "react-redux";
import { Auth } from "aws-amplify";
import { useHistory, Link } from "react-router-dom";
import { login, singout } from "../../redux/actions/user";
import { SubmitButton } from "../../components";
import { useForm } from "../../hooks";
import "./Login.css";
const Login = () => {
const [{ values, isLoading }, handleChange, handleSubmit] = useForm();
const dispatch = useDispatch();
const history = useHistory();
const handleLogin = async () => {
await Auth.signIn(values.email, values.password)
.then((cognitoUser) => {
dispatch(login(cognitoUser.attributes));
history.goBack();
})
.catch((err) => {
dispatch(singout());
alert(err.message);
});
};
return (
<div id="login-page">
<form onSubmit={handleSubmit(handleLogin)} id="login-form">
<label className="login-label">
Email:
<br />
<input
required
className="login-input"
type="email"
name="email"
onChange={handleChange}
/>
</label>
<label className="login-label">
Senha:
<br />
<input
required
className="login-input"
type="password"
name="password"
onChange={handleChange}
/>
</label>
<Link to="/signin">
Ainda não tem conta?
</Link>
<SubmitButton isLoading={isLoading} title="Entrar" />
</form>
</div>
);
};
export default Login;
|
import React, { Component } from 'react';
import { Container, Row, Col } from 'reactstrap';
import SearchBox from '../SearchBox/SearchBox';
import PhotoList from '../PhotoList/PhotoList';
import './Gallery.css';
class Gallery extends Component {
render() {
return (
<Container className="gallery-container">
<Row className="mb-5">
{/* */}
<Col md={{ size: 6, offset: 3 }}>
<SearchBox />
</Col>
</Row>
<PhotoList />
</Container>
);
}
}
export default Gallery;
|
import styled from "styled-components";
export let HamburgerContainer = styled.div`
display: flex;
justify-content: center;
align-items: center;
flex-direction: column;
position: absolute;
top: 2rem;
right: 2rem;
z-index: 10;
overflow: hidden;
cursor: pointer;
span {
width: 3rem;
height: 5px;
background-color: white;
margin: 2px 0;
transition: all 0.4s;
transform-origin: 3px;
}
span:nth-child(2) {
transform: translateX(${(props) => (props.isOpen ? "100%" : 0)});
opacity: ${(props) => (props.isOpen ? 0 : 1)};
}
span:nth-child(1) {
transform: rotate(${(props) => (props.isOpen ? "45deg" : 0)});
}
span:nth-child(3) {
transform: rotate(${(props) => (props.isOpen ? "-45deg" : 0)});
}
@media only screen and (min-width: 600px) {
display: none;
}
`;
|
import { GET_SESSION_FAILED, GET_SESSION_SUCCESS, GET_SESSION_LOADING } from '../constants/app.js';
const getSessionInitialState = {
getSessionLoading: false,
getSessionFailed: false,
getSessionSuccess: false,
getSessionError: {},
user: {
username: '',
thumb: '',
},
};
export default function app(state = getSessionInitialState, action) {
switch (action.type) {
case GET_SESSION_LOADING:
return { ...state, ...getSessionInitialState, getSessionLoading: true };
case GET_SESSION_SUCCESS:
return { ...state, ...getSessionInitialState, getSessionSuccess: true, user: action.user };
case GET_SESSION_FAILED:
return { ...state, ...getSessionInitialState, getSessionFailed: true, error: action.error };
default:
return state;
}
}
|
import React, { Component } from 'react';
import './buttonsSample.scss';
import Avatar from 'material-ui/Avatar';
import List from 'material-ui/List/List';
import ListItem from 'material-ui/List/ListItem';
export const AvatarExampleSimple = () => (
<List>
<ListItem disabled={true} leftAvatar={<Avatar>F</Avatar>}> Form </ListItem>
</List>
);
|
module.exports = function (styles, keys) {
keys.forEach(function (ob) {
styles[ob.key] = ob.value;
});
};
|
var _routeContent = $("#route-content");
if(!_routeContent) {
console.log("请检查是否存在#route-content视图区域")
}
var currentState = {};
//路由列表
var routeLis = [
{
path:'home',
url:'home.html'
},
{
path:'list',
url:'list.html'
},
{
path:'about',
url:'about.html'
},
{
path:'info',
url:'info.html'
}
]
;(function(){
$("a.item").on('click', function() {
var _routeContent = $("#route-content");
var _path = this.getAttribute('data-route-param');
//判断点击事件触发当前视图不更新
if(currentState && currentState['path'] === _path) {
return true;
}
var _route = "#/" + _path;
var _text = this.text;
currentState = {
path: _path,
route: _route,
text:_text
}
for(var index in routeLis) {
var item = routeLis[index];
if(item['path'] === _path){
currentState['url'] = item['url'];
};
}
if(currentState) {
loadPage();
}
})
})();
window.addEventListener('load', function(event) {
loadPage();
});
//获取当前路由页面
function loadPage() {
activeRoute();
_routeContent.load(currentState['url'] || routeLis && routeLis[0] && routeLis[0]['ur']);
}
//ActiveRouteStyle
function activeRoute() {
var _routeList = $(".route") || [];
for(var i=0; i< _routeList.length;i++) {
var _item = _routeList[i];
var _classList = _item && _item.classList;
var _aDome = _item && $(_item.getElementsByTagName("a")) && $(_item.getElementsByTagName("a")[0]);
console.log(currentState)
var _activeBool = _aDome && _aDome['context'] && _aDome['context'].getAttribute('data-route-param') === currentState['path'];
if(_activeBool) {
_classList.add('active')
} else {
_classList.remove('active');
}
}
}
|
var gulp = require('gulp');
var del = require('del');
var stylus = require('gulp-stylus');
var sourcemaps = require('gulp-sourcemaps');
var autoprefixer = require('gulp-autoprefixer');
var livereload = require('gulp-livereload');
var config = {
src: 'src/',
dest: 'dist/'
}
config.paths = {
html: config.src + 'html/**/*.html',
js: config.src + 'js/**/*.js',
css: config.src + 'css/**/*.css',
styl: [
config.src + 'stylus/**/*.styl',
'!' + config.src + 'stylus/**/_*.styl'
],
styl_watch: config.src + 'stylus/**/*.styl',
styl_base: config.src + 'stylus',
img: [
config.src + 'img/*.png',
config.src + 'img/favicon.ico'
],
font: [
config.src + 'fonts/**/*.ttf',
config.src + 'fonts/**/*.otf',
config.src + 'fonts/**/*.eot',
config.src + 'fonts/**/*.svg',
config.src + 'fonts/**/*.woff'
],
};
gulp.task('clean', function () {
del([config.dest + '*']);
});
gulp.task('html', function() {
gulp.src(config.paths.html)
.pipe(gulp.dest(config.dest))
.pipe(livereload());
});
gulp.task('js', function() {
gulp.src(config.paths.js)
.pipe(gulp.dest(config.dest + 'js'))
.pipe(livereload());
});
gulp.task('css', function() {
gulp.src(config.paths.css)
.pipe(autoprefixer({
browsers: ['last 2 versions'],
cascade: false
}))
.pipe(gulp.dest(config.dest + 'css'))
.pipe(livereload());
});
gulp.task('styl', function() {
gulp.src(config.paths.styl, { base: config.paths.styl_base })
.pipe(sourcemaps.init())
.pipe(stylus({compress: true}))
.pipe(autoprefixer({
browsers: ['last 2 versions'],
cascade: false
}))
.pipe(sourcemaps.write('.'))
.pipe(gulp.dest(config.dest + 'css'))
.pipe(livereload());
});
gulp.task('img', function() {
gulp.src(config.paths.img)
.pipe(gulp.dest(config.dest + 'img'))
.pipe(livereload());
});
gulp.task('font', function() {
gulp.src(config.paths.font)
.pipe(gulp.dest(config.dest + 'font'))
.pipe(livereload());
});
gulp.task('watch', function() {
gulp.watch(config.paths.html, ['html']);
gulp.watch(config.paths.js, ['js']);
gulp.watch(config.paths.css, ['css']);
gulp.watch(config.paths.styl_watch, ['styl']);
livereload.listen({ basePath: config.dest });
});
gulp.task('build', ['clean'], function(){
gulp.start('html');
gulp.start('js');
gulp.start('css');
gulp.start('styl');
gulp.start('img');
gulp.start('font');
});
gulp.task('default', function(){
gulp.start('build', ['watch']);
});
|
import Vue from 'vue';
import BreakdownTemplates from "./BreakdownTemplate.vue";
Vue.component('breakdown-templates', BreakdownTemplates);
const app = new Vue({
el: '#breakdownTemplates'
});
|
alert('awesome js include');
|
const express = require("express");
const { connection } = require("mongoose");
const router = express.Router();
const Auth = require("../model/user");
const Auth2 = require("../model/user");
const bcrypt = require("bcryptjs");
const auth = require("../middleware/auth");
const jwt = require("jsonwebtoken");
const fs = require("fs");
const path = require("path");
const multer = require("multer");
const GridFsStorage = require("multer-gridfs-storage");
const { find } = require("../model/user");
router.use(express.static(__dirname + "./uploads/"));
let storage = multer.diskStorage({
destination: "./uploads/",
filename: function (req, file, cb) {
cb(null, file.originalname);
},
});
let upload = multer({ storage: storage });
router.use("/uploads", express.static("uploads"));
// API for Registration
router.post("/register", upload.single("file"), async (req, res, next) => {
// Our register logic starts here
try {
// Get user input
const {
username,
fullname,
gender,
date,
phone,
email,
password,
confirmpassword,
} = req.body;
// Validate user input
const file = req.file.filename;
if (
!(username && fullname && phone && email && password && confirmpassword)
) {
res.status(400).send("All input is required");
}
// console.log("filepath", req.file.filename, req.file.path);
console.log("filepath", req.file.filename);
// check if user already exist
// Validate if user exist in our database
const oldUser = await Auth.findOne({ email });
if (oldUser) {
return res.status(400).send("User Already Exist , Please Login");
}
//Encrypt user password
let encryptedPassword = await bcrypt.hash(password, 10);
// Create user in our database
const url = req.protocol + "://" + req.get("host");
const user = await Auth.create({
file: req.file.originalname,
username,
fullname,
email: email.toLowerCase(),
date,
gender,
phone,
password: encryptedPassword,
confirmpassword: encryptedPassword,
});
// Create token
const token = jwt.sign({ _id: user._id, email }, process.env.TOKEN_KEY, {
expiresIn: "2h",
});
user.token = token;
console.log("User Token", token);
res.status(200).json(user);
} catch (err) {
res.status(400).json("Not valid");
console.log("Error , not Valid");
console.log(err);
}
});
// Login API
router.post("/login", async (req, res) => {
try {
// Get user input
const { email, password } = req.body;
// Validate user input
if (!(email && password)) {
res.status(400).send("All input is required");
}
// Validate if user exist in our database
const user = await Auth.findOne({ email });
if (!user) {
res.status(404).json("User not found");
}
if (user && (await bcrypt.compare(password, user.password))) {
// Create token
const token = jwt.sign({ _id: user._id, email }, process.env.TOKEN_KEY, {
expiresIn: "2h",
});
user.token = token;
console.log("token", token);
res.status(200).json(user);
}
} catch (err) {
res.status(400).send("Invalid Credentials");
console.log(err);
}
});
// Dashboard API
router.get("/userprofile", auth, async (req, res) => {
try {
const result = await Auth2.findById(req.user._id);
return res.json(result);
} catch (error) {
console.log("data not found", error);
}
});
router.get("/edituser/:id", async (req, res) => {
try {
const result = await Auth2.findById(req.params.id);
return res.json(result);
} catch (error) {
console.log({ error: "Data Not Found" });
}
});
router.get("/getuser", async (req, res) => {
try {
const result = await Auth2.find();
return res.json(result);
} catch (error) {
console.log("data not found", error);
}
});
// Update API
router.put("/update/:id", upload.single("file"), async (req, res) => {
if (!(await Auth.findOne({ _id: req.params.id }))) {
return res.status(400).json("user not found");
}
let payload = {
username: req.body.username,
fullname: req.body.fullname,
email: req.body.email,
phone: req.body.phone,
}
if(req.file && req.file.filename) {
payload.file = req.file.filename;
}
let updatedUser = await Auth.findByIdAndUpdate(
{ _id: req.params.id },
payload,
{ new: true }
);
console.log(updatedUser);
res.status(200).json(updatedUser);
});
router.put(
"/update/profile/:id",
auth,
upload.single("file"),
async (req, res) => {
if (!(await Auth.findOne({ _id: req.params.id }))) {
return res.status(400).json("user not found");
}
let payload = {
username: req.body.username,
fullname: req.body.fullname,
email: req.body.email,
phone: req.body.phone,
}
if(req.file && req.file.filename) {
payload.file = req.file.filename;
}
let updatedUser = await Auth.findByIdAndUpdate(
{ _id: req.params.id },
payload,
{ new: true }
);
console.log(updatedUser);
res.status(200).json(updatedUser);
}
);
// Delete API
router.delete("/delete/:id", async (req, res) => {
if (!(await Auth.findOne({ _id: req.params.id }))) {
return res.status(400).json("user not found");
}
let updatedUser = await Auth.findByIdAndDelete({ _id: req.params.id });
res.status(200).json(updatedUser);
});
router.get("/count", async (req, res) => {
let count = (await Auth.find()).length;
res.json(count);
});
const getPageData = ({ page = 0, limit = 2 }) => {
page = parseInt(page);
if (!limit) {
limit = 2;
}
limit = parseInt(limit);
let skip = page === 0 ? 0 : page * limit;
return { page, limit, skip };
};
const getPageInfo = ({ count = 0, limit, page }) => {
count = parseInt(count);
const info = { count };
let totalPages = count / limit - 1;
if (page >= 1) {
info.prev = page - 1;
}
if (page < totalPages) {
info.next = page + 1;
}
return info;
};
router.get("/pages", async (req, res, next) => {
// skip = page - 1 * limit
try {
let { page, limit, skip } = getPageData(req.query);
const count = await Auth.countDocuments();
const users = await Auth.find().skip(skip).limit(limit);
const info = getPageInfo({ count, limit, page });
res.send({
info,
users,
});
} catch (error) {
res.sendStatus(500);
}
});
module.exports = router;
|
export const SETQUESTIONDATA = 'SETQUESTIONDATA';
export const getQusetionData = (activeItem) => {
return async (dispatch) => {
try {
const response = await fetch(
`http://localhost:3001/questions?subjectName=${activeItem}`,
{
method: 'GET',
headers: {
Accept: 'application/json',
'Content-Type': 'application/json',
},
}
);
const resData = await response.json();
// unsorted arrays
const topicNames = [];
const years = [];
for (const item of resData) {
topicNames.push(item.topicName);
years.push(item.year);
}
//below arrays is for storing unique values of the previous arrays
const distinctTopicNames = topicNames.filter(
(value, index, self) => self.indexOf(value) === index
);
const distinctyears = years.filter(
(value, index, self) => self.indexOf(value) === index
);
dispatch({
type: SETQUESTIONDATA,
topicNames: distinctTopicNames,
years: distinctyears,
});
} catch (error) {
console.log(error);
}
};
};
export const addQuestion = (data) => {
return async (dispatch) => {
const formData = new FormData();
const imgFiles = document.getElementById('questionImage');
imgFiles.files[0] && formData.append('questionImage', imgFiles.files[0]);
formData.append('correctAnswer', data.correctAnswer);
formData.append('choices', data.choices);
formData.append('question', data.question);
formData.append('subjectName', data.subjectName);
formData.append('topicName', data.topicName);
formData.append('year', data.year);
try {
await fetch('http://localhost:3001/questions', {
method: 'POST',
body: formData,
});
} catch (error) {
console.log(error);
}
};
};
|
import React from 'react';
import ReactDOM from 'react-dom';
import { shallow } from 'enzyme';
import renderer from 'react-test-renderer';
import ThumbnailComp from '../components/ThumbnailComp';
const imageUrl = 'https://d30y9cdsu7xlg0.cloudfront.net/png/75112-200.png';
const imageId = '75112';
it('renders without crashing', () => {
shallow(<ThumbnailComp imageUrl={imageUrl} imageId={imageId} />);
});
it('renders without crashing', () => {
const div = document.createElement('div');
ReactDOM.render(<ThumbnailComp imageUrl={imageUrl} imageId={imageId} />, div);
ReactDOM.unmountComponentAtNode(div);
});
test('snapshot of UI renders consistently', () => {
const tree = renderer.create(<ThumbnailComp imageUrl={imageUrl} imageId={imageId} />).toJSON();
expect(tree).toMatchSnapshot();
});
|
const { app, BrowserWindow } = require('electron')
//Google翻訳のURL
var URL = "https://translate.google.co.jp/"
function createWindow () {
// Create the browser window.
let win = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
nodeIntegration: true
}
})
win.loadURL(URL)
}
//appはエレクトロンの大元プロセスを管理している。
//Electronアプリの初期化処理完了後createWindowファンクションが実行される
app.on('ready', createWindow)
app.on('window-all-closed', () => {
app.quit()
})
|
export const isCorrect = (someString) => {
if (someString === 'yes') return true;
return false;
};
|
// Create the Google Map…
var lines = [];
var map = new google.maps.Map(d3.select("#map").node(), {
zoom: 8,
center: new google.maps.LatLng(52.3, 5.3),
mapTypeId: google.maps.MapTypeId.ROADMAP
});
redraw(8);
draw_overlay(8);
map.addListener('zoom_changed', function() {
var zoom = map.getZoom();
if (zoom < 8)
zoom = 8;
if (zoom > 10)
zoom = 10;
redraw(zoom);
draw_overlay(zoom);
});
var lineSymbol = {
path: google.maps.SymbolPath.FORWARD_CLOSED_ARROW
};
function redraw(zoom)
{
while (lines.length > 0)
lines.pop().setMap(null);
d3.json("flow_" + zoom + ".json", function(error, data) {
if (error) throw error;
// get the sum of all migrations for arrow size normalisation
var total = 0;
for (var from in data) {
for (var to in data[from]) {
total += data[from][to];
}
}
d3.json("cities_" + zoom + "_clusters.json", function(error, cities) {
if (error) throw error;
for (var from in data) {
for (var to in data[from]) {
if (from == to)
continue;
var from_coords = cities[from];
var to_coords = cities[to];
if (!from_coords || !to_coords)
continue;
var line = new google.maps.Polyline({
path: [{lat: from_coords[0], lng: from_coords[1]},
{lat: to_coords[0], lng: to_coords[1]}],
icons: [{
icon: lineSymbol,
offset: '100%'
}],
map: map,
strokeColor: 'slategray',
strokeOpacity: 0.7,
strokeWeight: (data[from][to] / total) * 2000
});
lines.push(line);
}
}
});
});
}
function draw_overlay(zoom) {
d3.json("cities_" + zoom + "_clusters.json", function(error, data) {
if (error) throw error;
var overlay = new google.maps.OverlayView();
d3.selectAll("svg").remove();
// Add the container when the overlay is added to the map.
overlay.onAdd = function() {
var layer = d3.select(this.getPanes().overlayLayer).append("div")
.attr("class", "stations");
// Draw each marker as a separate SVG element.
// We could use a single SVG, but what size would it have?
overlay.draw = function() {
var projection = this.getProjection(),
padding = 10;
var marker = layer.selectAll("svg")
.data(d3.entries(data))
.each(transform) // update existing markers
.enter().append("svg")
.each(transform)
.attr("class", "marker");
// Add a circle.
marker.append("circle")
.attr("r", 5)
.attr("cx", padding)
.attr("cy", padding);
// Add a label.
//marker.append("text")
// .attr("x", padding + 7)
// .attr("y", padding)
// .attr("dy", ".31em")
// .text(function(d) { return d.key; });
function transform(d) {
d = new google.maps.LatLng(d.value[0], d.value[1]);
d = projection.fromLatLngToDivPixel(d);
return d3.select(this)
.style("left", (d.x - padding) + "px")
.style("top", (d.y - padding) + "px");
}
};
};
// Bind our overlay to the map…
overlay.setMap(map);
}
);
}
|
var express = require('express');
var todoListModel = require("../models/todoList.js");
var router = express.Router();
require('date-utils');
var todoList = {};
/* GET home page. */
router.get('/', function(req, res, next) {
res.render('index', {
user: 'administrator',
success: req.flash('success'),
error: req.flash('error'),
title: 'Express'
});
});
router.get('/todo', function(req, res, next){
todoListModel.find(function( err, results){
res.render('todoList', {
todoList : results,
title: 'todoList',
user: 'administrator',
success: req.flash('success'),
error: req.flash('error'),
});
});
});
//create a todo list
router.post('/todo/create', function(req, res, next){
if(req.body.item == '' || req.body.content == ''){
req.flash('error','內容輸入不齊全');
return res.redirect('/');
}
var now = new Date();
var tlModel = new todoListModel();
tlModel.item = req.body.item;
tlModel.content = req.body.content;
tlModel.time = now.toFormat("YYYY-MM-DD HH24:MI:SS");
tlModel.save(function( err){
if( err){
req.flash('error',err);
return res.redirect('/todo');
}
req.flash('success','新增成功');
res.redirect('/todo');
});
});
//delete a todo list
router.post('/todo/delete/:id', function(req, res, next){
var id = req.params.id;//todo list id
todoListModel.findByIdAndRemove(id,function(err, results){
if( err){
req.flash('error',err);
return res.redirect('/todo');
}
req.flash('success','刪除成功');
res.redirect('/todo');
});
});
router.get('/todo/update/:id', function(req, res, next){
var id = req.params.id;//todo list id
todoListModel.find({_id:id},function(err,results){
res.render('update',{
success: req.flash('success'),
error: req.flash('error'),
title : "Update todoList" ,
todoList : results
});
});
});
router.post('/todo/update_do', function(req, res, next){
if(req.body.item == '' || req.body.content == ''){
req.flash('error','內容輸入不齊全');
return res.redirect('/todo/update');
}
var id = req.body.id;//todo list id
todoListModel.update({_id:id},
{item: req.body.item,
content: req.body.content,
time: new Date().toFormat("YYYY-MM-DD HH24:MI:SS")},
function(err,results){
if(err){
req.flash('error',err);
return res.redirect('/todo/update');
}
req.flash('success','修改成功');
return res.redirect('/todo');
});
});
module.exports = router;
|
document.onkeyup = function(e) {
document.getElementById("intro").innerHTML = "";
document.getElementById("logo").style.visibility = "visible";
var answers = ["SOJOURNER", "DUBOIS", "DOUGLASS", "TUBMAN", "WHEATLEY"];
answerCurrent = answers[Math.floor(Math.random() * answers.length)];
console.log(answerCurrent);
var alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
// var isLetter = document.onkeyup(/^[a-zA-Z]/);
// console.log(isLetter);
var wins = 0;
//give the user a fair number of guesses
var numGuessRemain = 12;
//define empty string for letters already guessed
var lettersGuessed = "";
//fill an array with answers[i] of blanks where the user's guess will "build"
var userGuessArray = [];
// // RANDOMLY PICK A BAND IN BAND ARRAY
// // AND PUT IN VARIABLE;
// var Band = BandArray[Math.floor(Math.random() * BandArray.length)];
// console.log(Band);
// RANDOM FUNCTION THAT PICKS BAND;
// FILL USERGUESSARRAY WITH NUM OF LETTERS IN BAND.LENGTH
// (how to fill empty space???)
// for (i = 0; i < Band.length; i++) {
// userGuessArray[i] = "_"
// };
// console.log(userGuessArray);
// var userGuess = e.key.toLowerCase();
// function checkInput(userGuess, alphabet) {
// for (i = 0; i < alphabet.length; i++) {
// if (alphabet[i] === userGuess) {
// return true;
// } else {
// return false;
// }
// }
// }
// function guessInArray(userGuess, Band) {
// for (i = 0; i < Band.length; i++) {
// if (Band[i] === userGuess) {
// PRINT USERGUESS IN USERGUESSARRAY
// }
// }
// }
}
|
// setSampleData.js
// 2017.08.04
let devices =
{
"GeneralLighting_1" : {
"ip" : "192.168.50.5",
"eoj" : [656,1],
"protocol" : "ECHONET Lite",
"manufacturerNameJa" : "神奈川工科大学",
"manufacturerNameEn" : "Kanagawa Institute of Technology",
"propertyEL" : {
"0x80" : 48,
"0xB0" : 53
},
"propertyWebApi" : {
"on" : true,
"operatingMode" : "color"
}
},
"GeneralLighting_2" : {
"ip" : "192.168.50.5",
"eoj" : [656,2],
"protocol" : "ECHONET Lite",
"manufacturerNameJa" : "神奈川工科大学",
"manufacturerNameEn" : "Kanagawa Institute of Technology",
"propertyEL" : {
"0x80" : 49,
"0xB0" : 53
},
"propertyWebApi" : {
"on" : false,
"operatingMode" : "color"
}
},
"HomeAirConditioner_1" : {
"ip" : "192.168.50.15",
"eoj" : [304,1],
"protocol" : "ECHONET Lite",
"manufacturerNameJa" : "東芝",
"manufacturerNameEn" : "Toshiba",
"propertyEL" : {
"0x80" : 48,
"0xB0" : 53
},
"propertyWebApi" : {
"on" : true,
"operatingMode" : "cooling"
}
}
};
global.set("devices", devices);
return msg;
|
var email_2body_8h =
[
[ "Body", "structBody.html", "structBody" ],
[ "mutt_body_cmp_strict", "email_2body_8h.html#af8bf716dc11fb780a1d2492fe722e1ae", null ],
[ "mutt_body_free", "email_2body_8h.html#a129af1c316fcbc26b55fb48957bab2cb", null ],
[ "mutt_body_get_charset", "email_2body_8h.html#a8465f41e6b0f0256527ca2404edfb762", null ],
[ "mutt_body_new", "email_2body_8h.html#aee001296b775e82e3988b5a81e53e30c", null ]
];
|
function createRandomId() {
return (
new Date().getFullYear() +
"/" +
(new Date().getMonth() + 1) +
"/" +
new Date().getDate() +
"/" +
new Date().getTime() +
"/" +
(Math.random() * 10000000).toString(16).substr(0, 4) +
Math.random()
.toString()
.substr(2, 5)
);
}
export const toLocaleString = function(dateTime) {
let cdate = new Date(dateTime);
var year = cdate.getFullYear(); //取得4位数的年份
var month =
cdate.getMonth() + 1 > 9
? cdate.getMonth() + 1
: "0" + (cdate.getMonth() + 1); //取得日期中的月份，其中0表示1月，11表示12月
var date = cdate.getDate() > 9 ? cdate.getDate() : "0" + cdate.getDate(); //返回日期月份中的天数（1到31）
var hour = cdate.getHours() > 9 ? cdate.getHours() : "0" + cdate.getHours(); //返回日期中的小时数（0到23）
var minute =
cdate.getMinutes() > 9 ? cdate.getMinutes() : "0" + cdate.getMinutes(); //返回日期中的分钟数（0到59）
var second =
cdate.getSeconds() > 9 ? cdate.getSeconds() : "0" + cdate.getSeconds(); //返回日期中的秒数（0到59）
return (
year + "-" + month + "-" + date + " " + hour + ":" + minute + ":" + second
);
};
let utools = window.utools;
// 上传数据更新数据
export const putApi = (data) => {
console.log("上传数据更新数据", {
...data,
_id: data["_id"] || createRandomId(),
});
return new Promise((resolve, reject) => {
let res = utools.db.put({
...data,
_id: data["_id"] || createRandomId(),
});
if (res) {
console.log("🐛:: putApi -> res", res);
resolve(res);
} else {
reject("出错");
}
});
};
// 获取数据
export const getApi = (id) => {
console.log("🐛:: getApi -> id", id);
return new Promise((resolve, reject) => {
let res = utools.db.get(id);
if (res) {
console.log("🐛:: getApi -> res", res);
resolve(res);
} else {
reject("出错");
}
});
};
// 移除数据
export const removeApi = (id) => {
console.log("🐛:: removeApi -> id", id);
return new Promise((resolve, reject) => {
let res = utools.db.remove(id);
if (res) {
console.log("🐛:: removeApi -> res", res);
resolve(res);
} else {
reject("出错");
}
});
};
// 批量更新数组
export const bulkDocsApi = (data) => {
return new Promise((resolve, reject) => {
let res = utools.db.bulkDocs(data);
if (res) {
resolve(res);
} else {
reject("出错");
}
});
};
// 获取所有数据
export const allDocsApi = (data) => {
return new Promise((resolve, reject) => {
let res = utools.db.allDocs(data);
if (res) {
console.log("🐛:: allDocsApi -> res", res);
resolve(res);
} else {
reject("出错");
}
});
};
// 保存上一次的数据
export const setLastDocApi = (data) => {
utools.dbStorage.setItem('lastdoc', data)
return true
};
// 获取上一次的数据
export const getLastDocApi = () => {
return utools.dbStorage.getItem('lastdoc')
};
|
var setEffects = false;
function onCategoryClick() {
setEffects = !setEffects;
if (setEffects) {
setValuesOnElements("#FF0000", "2px solid #E8272C");
} else {
setValuesOnElements("#FFFF00", "none");
}
}
function setValuesOnElements(textColor, photoBorder) {
var photosOfProducts = document.getElementsByClassName("poz");
var names = document.getElementsByTagName("p");
for (var name of names) {
name.style.color = textColor
}
for (var photo of photosOfProducts) {
photo.style.border = photoBorder;
}
}
|
'use strict';
angular.module('arcanine.config', [])
.constant('ENV', {name:'production',apiEndpoint:'https://arbok.herokuapp.com/api/',FIREBASE_URL:'https://arbokold.firebaseio.com/'})
;
|
/* global bootbox */
$(document).ready(function() {
// Setting a reference to the article-container div where all the dynamic content will go
// Adding event listeners to any dynamically generated "save article"
// and "scrape new article" buttons
$(document).on("click", ".btn.save", saveArticle);
$(document).on("click", ".scrape-new", scrapeArticle);
$(document).on("click", ".clear", clearArticle);
$(document).on("click", ".note", saveNote);
$(document).on("click", ".delete", deleteArticle )
function initPage() {
// Run an AJAX request for any unsaved headlines
$.get("/").then(function(data) { });
}
function saveArticle() {
// This function is triggered when the user wants to save an article
// When we rendered the article initially, we attached a javascript object containing the headline id
// to the element using the .data method. Here we retrieve that.
event.preventDefault();
var articleToSave = $(this).attr('data')
// articleToSave.saved = true;
// Using a patch method to be semantic since this is an update to an existing record in our collection
$.ajax({
method: "PUT",
url: "/api/saved/" + articleToSave
}).then(function(data) {
// // If the data was saved successfully
location.reload();
});
}
function deleteArticle() {
event.preventDefault();
var articleToDelete = $(this).attr('data')
// Using a patch method to be semantic since this is an update to an existing record in our collection
$.ajax({
method: "DELETE",
url: "/api/delete/" + articleToDelete
}).then(function(data) {
// // If the data was saved successfully
location.reload();
});
}
function saveNote() {
console.log("called note")
// This function is triggered when the user wants to save an article
// When we rendered the article initially, we attached a javascript object containing the headline id
// to the element using the .data method. Here we retrieve that.
event.preventDefault();
var id = $(this).attr('data')
var noteId = "#note" + id;
var noteVal = $(noteId).val();
var noteData = { "note": noteVal };
$.ajax({
method: "PUT",
url: "/api/note/" + id,
data: noteData
}).then(function(data) {
// // // // // If the data was saved successfully
location.reload();
});
}
function scrapeArticle() {
event.preventDefault();
$.get("/api/fetch").then(function(data) {
location.reload();
});
}
function clearArticle() {
event.preventDefault();
$.get("/api/clear").then(function(data) {
location.reload();
});
}
});
|
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
module.exports = mongoose.model('User', new Schema({
firstName: String,
lastName: String,
designation: String,
organisation: String,
phone: Number,
addressLine1: String,
addressLine2: String,
landMark: String,
city: String,
state: String,
country: String,
pincode: Number,
email: String,
password: String,
admin: Boolean,
adminType: String
}));
|
import React, { useEffect, useState } from "react";
import axios from "axios";
import { useHistory } from "react-router-dom";
import { useDispatch, useSelector } from "react-redux";
import PersonAddIcon from "@mui/icons-material/PersonAdd";
import ContactPhoneIcon from "@mui/icons-material/ContactPhone";
import ContactsIcon from "@mui/icons-material/Contacts";
import MarkEmailReadIcon from "@mui/icons-material/MarkEmailRead";
import AddReactionTwoToneIcon from "@mui/icons-material/AddReactionTwoTone";
import CheckCircleIcon from "@mui/icons-material/CheckCircle";
import ArrowBackIcon from "@mui/icons-material/ArrowBack";
import { getuserprofile } from "../../store/oneuser/profileAction";
import CustomizedSnackbars from "../../Alert/SuccessSnackbar";
import ErrorSnackbar from "../../Alert/Error";
import api from "../../utils/api";
const Update = (props) => {
const dispatch = useDispatch();
const user = useSelector((state) => state?.profiles?.profile || {});
const userprofile = useSelector((state)=>state?.profiles?.profile || null)
console.log("++++++userprofile++++++++" , userprofile)
const [selectedImage, setSelectedImage] = useState();
const [Data, setData] = useState("");
const [open, setOpen] = useState(false);
const [ files , setFile ] = useState("")
const [notification, setnotification] = useState(false);
const token = localStorage.getItem("token");
const handleClose = (reason, event) => {
if (reason === "clickaway") {
return;
}
setOpen(false);
setnotification(false);
};
useEffect(() => {
setData(user)
}, [user])
const history = useHistory();
const onSubmit = (e) => {
e.preventDefault();
const formData = new FormData();
formData.append("file", files);
for (let key in Data) {
formData.append(key, Data[key]);
}
try {
api
.put(`/update/profile/${Data._id}`,formData)
.then((res) => {
setData(res.data)
dispatch(getuserprofile(res.data));
setOpen(true);
});
} catch (msg) {
console.log({ msg: "Not Updated" });
}
};
const handleInput = (e) => {
return setData({ ...Data, [e.target.name]: e.target.value });
};
const head = {
background: "linear-gradient(#444 , #999 , #333)",
width: "100%",
height: "calc(100vh - 58px)",
display: "flex",
flexdirection: "column",
alignitems: "center",
justifyContent: "center",
};
return (
<>
<form onSubmit={onSubmit} className="p-4" style={head}>
<div>
<div
className="user"
style={{
display: "flex",
alignItems: "center",
justifyContent: "space-evenly",
}}
>
<img
style={{ width: "120px", borderRadius: "15px" }}
src={
Data.file && `http://localhost:3000/uploads/${Data.file}`
}
alt=""
/>
<h1 className="text-center">
<AddReactionTwoToneIcon className="icons mx-3" />
Update Profile
</h1>
<div className="btn">
<button
className="btn btn-success"
onClick={() => {
history.push("/dashboard");
}}
>
<ArrowBackIcon /> Back
</button>
</div>
</div>
<hr />
<CustomizedSnackbars
handlerclose={handleClose}
open={open}
setOpen={setOpen}
/>
<ErrorSnackbar
handlerclose={handleClose}
notification={notification}
setnotification={setnotification}
/>
<div className="row g-3 p-4">
<div className="col-md-6">
<label htmlFor="inputEmail4" className="form-label">
<PersonAddIcon /> Username :-
</label>
<input
className="form-control"
id="inputEmail4"
placeholder="Enter Your Username"
type="text"
name="username"
value={Data.username}
onChange={handleInput}
/>
</div>
<div className="col-md-6">
<label htmlFor="inputPassword4" className="form-label">
<ContactsIcon /> FullName :-
</label>
<input
className="form-control"
id="inputAddress"
placeholder="Enter Your Fullname"
type="text"
name="fullname"
value={Data.fullname}
onChange={handleInput}
/>
</div>
<div className="col-3">
<label htmlFor="inputAddress" className="form-label">
<MarkEmailReadIcon /> Email :-
</label>
<input
className="form-control"
id="inputAddress1"
placeholder="Enter Your Email"
type="email"
name="email"
value={Data.email}
onChange={handleInput}
/>
</div>
<div className="col-md-3">
<label htmlFor="inputZip" className="form-label">
<ContactPhoneIcon /> Contact No.: -
</label>
<input
className="form-control"
placeholder="Enter Your Contact No."
id="inputCity1"
type="text"
name="phone"
value={Data.phone}
onChange={handleInput}
/>
</div>
<div className="col-md-3">
<label htmlFor="file" className="form-label">
Image : -
</label>
<input
type="file"
onChange={(e) => setFile(e.target.files[0])}
className="form-control"
id="file"
/>
</div>
<div className="btn">
<button className="btn btn-success" onSubmit={onSubmit}>
<CheckCircleIcon /> Update
</button>
</div>
</div>
</div>
</form>
</>
);
};
export default Update;
|
class StylePlugin {
constructor(options) {
}
apply(event) {
event.addListener('before-parse-file', (config, chunk) => {
if (chunk.ext === 'html') {
let html = chunk.data;
var regexp = new RegExp('<style\\b[^<]*(?:(?!<\\/style>)<[^<]*)*<\\/style>', 'img');
let styles = html.match(regexp);
html = html.replace(regexp, '');
if (styles) {
for (let style of styles) {
style = style.replace(/^<style[\s\S]*?>/, '');
style = style.replace(/^<\/style>$/, '');
}
}
chunk.data = html;
}
})
}
}
module.exports = StylePlugin;
|
import React from "react";
import Card from "material-ui/Card";
import "./Quote.css";
const Quote = ({ quote, person }) => {
return (
<Card className="testimonial-quote">
<blockquote>
{quote}
<cite>{person}</cite>
</blockquote>
</Card>
);
};
export default Quote;
|
import { Router } from 'express'
import binanceController from '../controllers/binance.js'
const binance = Router()
binance.get('/candles/:starttime/:endtime/:symbol', binanceController.candles)
export default binance
|
/*
* Track and report the current location
*/
var handlePositionUpdate = function(e) {
var latitude = e.coords.latitude;
var longitude = e.coords.longitude;
log("Position update:", latitude, longitude);
if(navigator.onLine) {
uploadLocations(latitude, longitude);
}
storeLocation(latitude, longitude);
}
var handlePositionError = function(e) {
log("Position error");
}
var uploadLocations = function(latitude, longitude) {
var request = new XMLHttpRequest();
request.open("POST", "http://geodata.example.net:8000/geoupload", true);
request.send(localStorage.locations);
}
var storeLocation = function(latitude, longitude) {
// load stored location list
var locations = JSON.parse(localStorage.locations || "[]");
// add location
locations.push({"latitude" : latitude, "longitude" : longitude});
// save new location list
localStorage.locations = JSON.stringify(locations);
}
var geolocationConfig = {"maximumAge":20000};
navigator.geolocation.watchPosition(handlePositionUpdate,
handlePositionError,
geolocationConfig);
|
export const actionTypes = {
LOGIN: `@@${process.env.APPNAME}/auth/login`,
LOGIN_SUCCESS: `@@${process.env.APPNAME}/auth/login_success`,
LOGIN_FAILED: `@@${process.env.APPNAME}/auth/login_failed`,
LOGOUT: `@@${process.env.APPNAME}/auth/logout`,
LOGOUTED: `@@${process.env.APPNAME}/auth/logouted`,
};
export const actions = {
login: (username, password) => ({
type: actionTypes.LOGIN,
payload: {
username,
password,
}
}),
login_success: token => ({
type: actionTypes.LOGIN_SUCCESS,
payload: token
}),
login_failed: message => ({
type: actionTypes.LOGIN_FAILED,
payload: message
}),
logout: () => ({
type: actionTypes.LOGOUT
}),
logouted: () => ({
type: actionTypes.LOGOUTED
})
};
|
var stompClient = null;
$(document).ready(function(){
var socket = new SockJS('/webSocket');
stompClient = Stomp.over(socket);
stompClient.connect({}, function (frame) {
stompClient.subscribe('/sujet/position/ceinture',function(){
});
});
});
function passerCeinture(receveur){
var ceId = "ch"+receveur.id;
if(document.getElementById(ceId).checked){
stompClient.send("/app/gradation/ceinture", {}, JSON.stringify({'texte': receveur.id+'-'+$("#admin").text() , 'creation': 0 , 'de' : "PASSERCEINTURE", 'avatar': 'GR8SUCCESS', 'type':"publique" }));
}
else{
stompClient.send("/app/gradation/ceinture", {}, JSON.stringify({'texte': receveur.id+'-'+$("#admin").text() , 'creation': 0 , 'de' : "PASSERCEINTURE", 'avatar': 'TRUMP', 'type':"publique" }));
}
setTimeout(function(){
location.reload(true)
},1000);
}
|
import md5 from 'js-md5';
export const formatTimestamp = timestamp => {
const date = new Date(timestamp);
return `${date.toLocaleString()}`;
};
export const gravatarImageSrc = (token, size = 32) => {
return `https://www.gravatar.com/avatar/${md5(token)}?d=identicon&s=${size}`
};
|
var totals
var ddc
// var usvalue =[]
// var russvalue =[]
// var ukvalue =[]
// var frvalue =[]
// var chnvalue =[]
// var indvalue =[]
// var pksvalue =[]
// var nkvalue =[]
// var ddc
// var ddct =[]
// var x
// var y
function preload(){
totals = loadTable('data/totals.csv','csv','header')
ddc = loadTable('data/ddc.csv','csv','header')
}
function setup(){
createCanvas(6000, 2000)
background(230)
var table = totals
var times = ddc
var x = 200
var y =100
var colWidth = 100
var rowHeight = 100
textStyle(BOLD)
textAlign(RIGHT)
for (var c=1; c<table.getColumnCount(); c++){
text(table.columns[c], x-colWidth, y)
y += rowHeight
}
for (var c=1; c<table.getRowCount(); c++){
var year = table.getString(c,0)
text(year,x,rowHeight-30)
x += colWidth
}
for (var r=1; r<table.getRowCount(); r++){
y = 100
for (var c=1; c<table.getColumnCount(); c++){
var value = table.getNum(r, c)
noStroke()
fill(0,0,150)
ellipse(200+(r-1)*colWidth,c*rowHeight,value/2)
print(value)
}
y += rowHeight
}
for (var r=1; r<times.getRowCount(); r++){
var tvalue = times.getNum(r, 1)
var kvalue = 60-tvalue
var value = table.getNum(r,9)
map (kvalue,0,60,0,2*PI)
noStroke()
fill(value*100,0,0)
arc(200+(r-1)*colWidth,rowHeight*(table.getColumnCount()-1),value/2,value/2,0,kvalue)
}
}
|
const express = require('express');
const router = express.Router();
const pool = require('../lib/database');
const { isLoggedIn } = require('../lib/auth');
router.get('/', isLoggedIn, async (req, res) => {
res.render('dpto/list');
});
router.get('/alldpto', isLoggedIn, async (req, res) => {
const dpto = await pool.query('SELECT * from departamentos WHERE dp_activo=?', [1]);
for (i = 0; i < dpto.length; i++) {
dpto[i].option = "<div Class='text-center'><a class='btn btn-primary btn-sm rounded-circle fnEditDp' href='#' rl='" + dpto[i].dp_id + "'><i Class='fas fa-pencil-alt'></i></a><a class='btn btn-danger btn-sm rounded-circle fnDelDp' href='#' rl='" + dpto[i].dp_id + "'><i Class='fas fa-trash-alt'></i></a></div>"
};
res.send(JSON.stringify(dpto));
});
router.post('/setDpto', isLoggedIn, async (req, res) => {
const form = req.body;
const objDpto = {
dp_cod: form.cod,
dp_des: form.des,
};
var rows;
var result = {};
if (form.idDpto == 0) {
rows = await pool.query('SELECT * FROM departamentos WHERE dp_cod = ?', [objDpto.dp_cod]);
if (rows.length > 0) {
result = {
status: false,
msg: 'Codigo Departamento ya Existe'
}
} else {
rows = await pool.query('INSERT INTO departamentos set ?', [objDpto]);
if (rows.affectedRows == 1) {
result = {
status: true,
msg: 'Departamento Creado Correctamente'
}
};
}
} else {
rows = await pool.query('UPDATE departamentos set ? WHERE dp_id=?', [objDpto, form.idDpto]);
if (rows.affectedRows == 1) {
result = {
status: true,
msg: 'Departamento Actualizado Correctamente'
}
} else {
result = {
status: false,
msg: 'Error al Actualizar Departamento'
}
}
}
res.send(JSON.stringify(result));
});
router.get('/getDpto/:id', async (req, res) => {
const { id } = req.params;
const rows = await pool.query('SELECT * FROM departamentos WHERE dp_id = ?', [id]);
result = rows[0];
res.send(JSON.stringify(result));
//res.render('dpto/edit', { dpto: rows[0] });
});
router.delete('/delDpto/:id', async (req, res) => {
const { id } = req.params;
var rows;
var result = {};
rows = await pool.query('SELECT dp_cod FROM departamentos WHERE dp_id = ?', id);
const codDp = rows[0];
rows = await pool.query('SELECT * FROM productos WHERE dpto = ?', [codDp.dp_cod]);
if (rows.length > 0) {
result = {
status: false,
msg: 'No se puede borrar Deparamento asociado a Producto'
}
} else {
rows = await pool.query('UPDATE departamentos SET dp_activo=0 WHERE dp_id = ?', id);
if (rows.affectedRows == 1) {
result = {
status: true,
msg: 'Departamento Borrado'
}
};
}
res.send(JSON.stringify(result));
});
module.exports = router;
|
import React from 'react';
export default function Item(props) {
return (
<li className="well">
<article>
<h2>
{props.artistName}
</h2>
<h3>
{props.collectionName}
</h3>
<h4>
{props.trackName}
</h4>
<div className="row">
<img className="col-xs-2 col-md-2" src={props.artworkUrl60} />
<p className="col-xs-10 col-md-10">{props.trackPrice} {props.currency}</p>
<span
className="col-xs-10 col-md-10 glyphicon glyphicon-heart"
aria-hidden="true"
onClick={() => props.add()}
style={{cursor: 'pointer'}}
></span>
</div>
</article>
</li>
);
}
|
import { call, put, select } from 'redux-saga/effects';
import * as applicationApi from 'services/application';
export const state = {
applicationListLoading: false,
applicationList: [],
applicationPagination: { current: 1, pageSize: 10 },
applicationVis: { editVis: false },
currentApp: null,
applicationName: '',
applicationComboList: [],
editLoading: false,
};
export const effects = {
*fetchApplicationList() {
yield put({ type: 'application/setState', payload: { applicationListLoading: true } });
const { applicationState } = yield select();
const { applicationName, applicationPagination } = applicationState;
const query = {
applicationName,
currentPage: applicationPagination.current,
pageSize: applicationPagination.pageSize,
};
const res = yield call(applicationApi.requestApplicationList, query);
console.log('application list', res)
if (res) {
yield put({
type: 'application/setState',
payload: { applicationList: res.data.applications, applicationListLoading: false },
});
}
},
*fetchApplicationCombo() {
const res = yield call(applicationApi.requestApplicationCombo);
if (res) {
yield put({ type: 'application/setState', payload: { applicationComboList: res.data } });
}
},
*fetchEditApplication({ payload }) {
yield put({ type: 'application/setState', payload: { editLoading: true } });
const { applicationState } = yield select();
const { currentApp } = applicationState;
let application = { ...payload };
if (currentApp?.id) application = { ...application, ...currentApp };
const res = yield call(applicationApi.requestEditApplication, application);
if (res) {
yield put({
type: 'app/notify.success',
payload: `${currentApp?.id ? '更新' : '新增'} ${application.applicationName} 成功`,
});
yield put.resolve({ type: 'application/fetchApplicationList' });
yield put({ type: 'application/setState', payload: { editLoading: false } });
yield put({ type: 'application/setApplicationVis', payload: { editVis: false } });
}
},
};
export const reducers = {
setApplicationVis(state, { payload }) {
state.applicationVis = { ...state.applicationVis, ...payload };
return { ...state };
},
};
|
// Libraries
import styled from 'styled-components';
// Assets
import ClickableCursor from '../../../assets/cursors/clickable.cur';
export const DealArea = styled.div`
cursor: ${(props) =>
props.dealingDecksLength > 0 &&
`url(${ClickableCursor}), pointer`};
display: inline-flex;
flex-direction: row-reverse;
height: 100%;
width: 110px;
.card {
&:not(:last-child) {
margin-left: -30px;
@media (min-width: ${(props) =>
props.theme.breakpoints.smallTablet}) {
margin-left: -62px;
}
}
img {
height: 100%;
}
}
`;
|
var Task = function (data) {
this.name = data.name;
this.completed = data.completed;
};
Task.prototype.complete = function () {
console.log('Task completed: ' + this.name);
this.completed = true;
};
Task.prototype.save = function () {
console.log('Saving task: ' + this.name);
};
var myTask = new Task({
name: 'legacy task'
});
myTask.complete();
myTask.save();
var urgentTask = new Task({
name: 'Urgent Task'
});
urgentTask.priority = 'medium'; //decorate with additional attribute
urgentTask.notify = function () { //decorate with additional method
console.log('notifying important people');
};
urgentTask.complete();
urgentTask.save = function () { //decorate via modifing existing function
this.notify(); //new method
Task.prototype.save.call(this); //call existing method
};
urgentTask.save();
|
var _ = require('lodash');
var zmq = require('zeromq');
var sock = zmq.socket('dealer');
sock.identity = "srv#1"
sock.linger = 0
var uri = process.env["BROKER_URI"] || 'tcp://127.0.0.1:3000'
sock.connect(uri);
console.log('srv.connected to %s', uri);
sock.on('message', function (frames) {
var frames = _.toArray(arguments).map(String);
console.log('srv.work: %j', frames);
})
sock.on('error', function (err) {
console.log('srv.error: ', err);
})
var IDENTITY_FRAME = 0,
PROTOCOL_FRAME = 1,
TYPE_FRAME = 2,
RID_FRAME = 3,
ADDRESS_FRAME = 4,
HEADERS_FRAME = 5,
STATUS_FRAME = 6,
PAYLOAD_FRAME = 7;
var pingFrames = [
"ZSS:0.0",
"REQ",
"c1e9a160-4a4a-11e9-a123-afbb82ae3d12",
JSON.stringify({
"sid": "COMPUTEINSTANCE_PROFILE_CONFIGURATION",
"sversion": "*",
"verb": "BATCH"
}),
JSON.stringify({
"userId": "5ae857a3f3488d5386684b1f",
"tenantId": "58ac2c19f2c169639e74dc19",
"X-REQUEST-ID": "c763b7ba28826842b1b72f5e64f55556"
}),
"",
JSON.stringify({sid: 'TEST'})
];
setInterval(function() {
sock.send(pingFrames);
}, parseInt(process.env["HEARTBEAT"], 10) || 500);
|
const createOfficeGroupDialog = {
state: {
isShow: false,
id: "",
successOrgId: "",
successGroupId: ""
},
mutations: {
OPEN_CREATE_OFFICE_GROUP_DRAWER: (state, id) => {
state.isShow = true;
state.id = id;
},
CLOSE_CREATE_OFFICE_GROUP_DRAWER: (state) => {
state.isShow = false;
state.id = "";
},
SET_CREATE_OFFICE_GROUP_DRAWER_SUCCESS_ID: (state, data) => {
state.successOrgId = data.orgId;
state.successGroupId = data.groupId;
}
},
actions: {
openCreateOfficeGroupDialog(context, id) {
context.commit("OPEN_CREATE_OFFICE_GROUP_DRAWER", id);
},
setCreateOfficeGroupDialogSuccessId(context, data) {
context.commit("SET_CREATE_OFFICE_GROUP_DRAWER_SUCCESS_ID", data);
},
closeCreateOfficeGroupDialog(context) {
context.commit("CLOSE_CREATE_OFFICE_GROUP_DRAWER");
}
}
};
export default createOfficeGroupDialog;
|
importScripts('https://storage.googleapis.com/workbox-cdn/releases/3.3.1/workbox-sw.js');
if (workbox) {
console.log('[Workbox] Successfully loaded');
workbox.precaching.precacheAndRoute(self.__precacheManifest || [])
workbox.routing.registerRoute(
/.*\.js/,
workbox.strategies.cacheFirst()
)
} else {
console.log('[Workbox] Failed to load');
}
|
const MenuContainer = document.querySelector(".main-container");
const ClientContainer = document.querySelector('.client-container');
const prodContainer = document.querySelector('.prod-container');
const editionContainer = document.querySelector('.edition-container');
const btn = document.createElement('button');
const ProdBtn = document.createElement("button");
let current;
const Mmenu = document.querySelector(".M-menu");
const Menuclient = document.querySelector(".menu-client");
const Menuproduit = document.querySelector(".menu-produit");
const Edition = document.querySelector(".edition");
//Client datat :
const NomClien = [], TelClient = [], DateEnreg = [];
let comp = 1;
//Prod data :
const NomP = [], Typeprod = [], TypeTask = [], DateP = [];
let Ncomp = 0;
//Functions :
function load() {
ClientContainer.style.display = 'none';
prodContainer.style.display = 'none';
editionContainer.style.display = 'none';
//Creation de client-----------------------------------------------------------
const Nom = document.createElement('input');
const Tel = document.createElement('input');
const Date = document.createElement('input');
const ClientDiv = document.createElement('div');
const buttonClientDiv = document.createElement('div');
Nom.placeholder = "Nom de client";
Tel.placeholder = "Num de Téléphone";
Date.placeholder = "Date d'enregistrement";
btn.innerText = "submit";
btn.classList = "lool";
ClientDiv.classList = "ClientDiv";
buttonClientDiv.classList = "buttdiv";
buttonClientDiv.appendChild(btn);
ClientDiv.appendChild(Nom);
ClientDiv.appendChild(Tel);
ClientDiv.appendChild(Date);
ClientContainer.appendChild(ClientDiv);
ClientContainer.appendChild(buttonClientDiv);
//creation de Poduit-----------------------------------------------------------
const ProdDiv =document.createElement('div');
const buttonProdtDiv = document.createElement('div');
prodContainer.appendChild(ProdDiv);
buttonProdtDiv.classList = "buttdiv";
ProdDiv.classList = "ProdDiv";
//nom :
const NomProd = document.createElement('input');
NomProd.placeholder = "Nom de produit";
const NomProdDiv = document.createElement("div");
NomProdDiv.appendChild(NomProd);
ProdDiv.appendChild(NomProdDiv);
//Type de produit :
const Type = ["PC Portable", "PC Bureau", "Imprimant", "Camera"];
const listDrop = document.createElement('select');
const TypeText =document.createElement("label");
const TypeProdDiv = document.createElement("div");
TypeText.innerText = "Choisir le Type de Produit : ";
TypeProdDiv.appendChild(TypeText);
TypeProdDiv.appendChild(listDrop);
ProdDiv.appendChild(TypeProdDiv);
for (let i = 0; i < Type.length ; i++) {
const option = document.createElement("option");
option.innerText = Type[i];
listDrop.appendChild(option);
}
//Client :
const clientProduit = document.createElement('select');
const labelclient = document.createElement('label');
const clientproduitdiv = document.createElement('div');
clientproduitdiv.appendChild(labelclient);
clientproduitdiv.appendChild(clientProduit);
labelclient.innerText = "Choisi le client : ";
clientproduitdiv.appendChild(clientProduit);
ProdDiv.appendChild(clientproduitdiv);
addEventListener('click', (e) => {
const target = e.target;
if ( target === Menuproduit) {
var length = clientProduit.options.length;
for (i = length-1; i >= 0; i--) {
clientProduit.options[i] = null;
}
for (let newcomp = 1; newcomp < comp; newcomp++) {
const opt = document.createElement('option');
opt.innerText = NomClien[newcomp];
clientProduit.appendChild(opt);
console.log(opt.value);
}
}
})
//Type de Traitement :
const Type1 = ["Diagnostique", "Formatage", "Change", "test4", "test5"];
const TypeTrait = document.createElement("select");
const TypeText1 =document.createElement("label");
const TraitProdDiv = document.createElement("div");
TraitProdDiv.classList = "traitdiv";
TypeText1.innerText = "Choisir le Type de Traitement : ";
TraitProdDiv.appendChild(TypeText1);
TraitProdDiv.appendChild(TypeTrait);
ProdDiv.appendChild(TraitProdDiv)
for (let x = 0; x < Type1.length; x++) {
const option1 = document.createElement("option");
option1.innerText = Type1[x];
TypeTrait.appendChild(option1);
}
//Date :
const DateProd = document.createElement("input");
DateProd.placeholder = "Date d'enregitrement";
ProdDiv.appendChild(DateProd);
//button :
ProdBtn.innerText = "submit";
ProdBtn.classList = "lool";
buttonProdtDiv.appendChild(ProdBtn);
prodContainer.appendChild(buttonProdtDiv);
addEventListener('click', (e) => {
const target = e.target;
if (target === btn) {
NomClien[comp] = Nom.value;
TelClient[comp] = Tel.value;
DateEnreg[comp] = Date.value;
console.log("Nom : " + NomClien[comp]);
console.log("Tel : " + TelClient[comp]);
console.log("Date : " + DateEnreg[comp]);
Nom.value = "";
Tel.value = "";
Date.value = "";
comp = comp + 1;
}
if (target === ProdBtn) {
NomP[comp] = NomProd.value;
Typeprod[comp] = Tel.value;
TypeTask[comp] = Date.value;
console.log("Nom : " + NomP[comp]);
console.log("Type prod : " + Type[comp]);
console.log("type task : " + Type1[comp])
console.log("Date : " + DateProd.value);
}
})
}
function verify() {
if (current == 1) {
MenuContainer.style.display = 'block'
ClientContainer.style.display = 'none';
prodContainer.style.display = 'none';
editionContainer.style.display = 'none';
} else if (current == 2) {
ClientContainer.style.display = 'block';
MenuContainer.style.display = 'none';
prodContainer.style.display = 'none';
editionContainer.style.display = 'none';
} else if (current == 3) {
prodContainer.style.display = 'block'
MenuContainer.style.display = 'none';
ClientContainer.style.display = 'none';
editionContainer.style.display = 'none';
} else if (current == 4) {
editionContainer.style.display = 'block';
MenuContainer.style.display = 'none';
prodContainer.style.display = 'none';
ClientContainer.style.display = 'none';
}
}
//event Listeners :
addEventListener('click', (e) => {
let target = e.target;
if (target === Mmenu) {
current = 1;
verify();
console.log("menu");
} else if (target === Menuclient) {
current = 2;
console.log("client");
verify();
} else if (target === Menuproduit) {
current = 3;
verify();
console.log("produit");
} else if (target === Edition) {
current = 4;
verify();
console.log("edition");
}
})
load();
|
'use strict'
module.exports = {
put: put,
clear: clear,
search: search,
setOptions: setOptions
}
const FuzzySearchStrategy = require('./SearchStrategies/FuzzySearchStrategy')
const LiteralSearchStrategy = require('./SearchStrategies/LiteralSearchStrategy')
function NoSort () {
return 0
}
const data = []
let opt = {}
opt.fuzzy = false
opt.limit = 10
opt.searchStrategy = opt.fuzzy ? FuzzySearchStrategy : LiteralSearchStrategy
opt.sort = NoSort
opt.exclude = []
function put (data) {
if (isObject(data)) {
return addObject(data)
}
if (isArray(data)) {
return addArray(data)
}
return undefined
}
function clear () {
data.length = 0
return data
}
function isObject (obj) {
return Boolean(obj) && Object.prototype.toString.call(obj) === '[object Object]'
}
function isArray (obj) {
return Boolean(obj) && Object.prototype.toString.call(obj) === '[object Array]'
}
function addObject (_data) {
data.push(_data)
return data
}
function addArray (_data) {
const added = []
clear()
for (let i = 0, len = _data.length; i < len; i++) {
if (isObject(_data[i])) {
added.push(addObject(_data[i]))
}
}
return added
}
function search (crit) {
if (!crit) {
return []
}
return findMatches(data, crit, opt.searchStrategy, opt).sort(opt.sort)
}
function setOptions (_opt) {
opt = _opt || {}
opt.fuzzy = _opt.fuzzy || false
opt.limit = _opt.limit || 10
opt.searchStrategy = _opt.fuzzy ? FuzzySearchStrategy : LiteralSearchStrategy
opt.sort = _opt.sort || NoSort
opt.exclude = _opt.exclude || []
}
function findMatches (data, crit, strategy, opt) {
const matches = []
for (let i = 0; i < data.length && matches.length < opt.limit; i++) {
const match = findMatchesInObject(data[i], crit, strategy, opt)
if (match) {
matches.push(match)
}
}
return matches
}
function findMatchesInObject (obj, crit, strategy, opt) {
for (const key in obj) {
if (!isExcluded(obj[key], opt.exclude) && strategy.matches(obj[key], crit)) {
return obj
}
}
}
function isExcluded (term, excludedTerms) {
for (let i = 0, len = excludedTerms.length; i < len; i++) {
const excludedTerm = excludedTerms[i]
if (new RegExp(excludedTerm).test(term)) {
return true
}
}
return false
}
|
/**
* Copyright 2015 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
templatesLoader.register('DIALOG', '/src/custom-dialog/snippets/dialog.html');
describe('CustomDialog', function () {
var defTout = 600;
it('should be globally available', function () {
expect(CustomDialog).to.be.a('function');
});
it('should upgrade successfully', function () {
var TEMPLATE = templatesLoader.get('DIALOG');
var el = document.createElement('div');
document.body.appendChild(el);
el.innerHTML = TEMPLATE;
componentHandler.upgradeElements(el);
var dialog = el.querySelector('.custom-js-dialog')
expect(dialog.getAttribute('data-upgraded')).to.be.equal(',CustomDialog');
componentHandler.downgradeElementRecursive(el);
expect(dialog.getAttribute('data-upgraded')).to.be.equal('');
el.remove();
});
it('should open on bt click', function (done) {
var TEMPLATE = templatesLoader.get('DIALOG');
var el = document.createElement('div');
document.body.appendChild(el);
el.innerHTML = TEMPLATE;
componentHandler.upgradeElements(el);
var dialog = el.querySelector('.custom-js-dialog')
var bt = document.querySelector('#bt1');
var cherry = window.cherry;
var display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('none');
bt.click();
setTimeout(function() {
display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('block');
dialog['CustomDialog'].hide();
componentHandler.downgradeElementRecursive(el);
el.remove();
done();
}, defTout)
});
it('should close on cancel click', function (done) {
var TEMPLATE = templatesLoader.get('DIALOG');
var el = document.createElement('div');
document.body.appendChild(el);
el.innerHTML = TEMPLATE;
componentHandler.upgradeElements(el);
var dialog = el.querySelector('.custom-js-dialog');
var cancel = dialog.querySelector('.custom-dialog-cancel');
var bt = document.querySelector('#bt1');
var cherry = window.cherry;
var display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('none');
bt.click();
setTimeout(function(){
display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('block');
cancel.click();
setTimeout(function() {
var display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('none');
componentHandler.downgradeElementRecursive(el);
el.remove();
done();
}, defTout)
}, defTout)
});
it('should close on close click', function (done) {
var TEMPLATE = templatesLoader.get('DIALOG');
var el = document.createElement('div');
document.body.appendChild(el);
el.innerHTML = TEMPLATE;
componentHandler.upgradeElements(el);
var dialog = el.querySelector('.custom-js-dialog');
var close = dialog.querySelector('.custom-dialog-close');
var bt = document.querySelector('#bt1');
var cherry = window.cherry;
var display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('none');
bt.click();
setTimeout(function() {
display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('block');
close.click();
setTimeout(function() {
var display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('none');
componentHandler.downgradeElementRecursive(el);
el.remove();
done();
}, defTout)
}, defTout)
});
it('should prevent first click on button enabler', function (done) {
var TEMPLATE = templatesLoader.get('DIALOG');
var el = document.createElement('div');
document.body.appendChild(el);
el.innerHTML = TEMPLATE;
componentHandler.upgradeElements(el);
var dialog = el.querySelector('.custom-js-dialog')
var bt = document.querySelector('#bt1');
var clicked = false;
bt.addEventListener('click', function () {
clicked = true;
})
var cherry = window.cherry;
var display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('none');
bt.click();
expect(clicked).to.be.equal(false);
setTimeout(function() {
display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('block');
dialog['CustomDialog'].hide();
componentHandler.downgradeElementRecursive(el);
el.remove();
done();
}, defTout)
});
it('should enable click on button enabler after confirm', function (done) {
var TEMPLATE = templatesLoader.get('DIALOG');
var el = document.createElement('div');
document.body.appendChild(el);
el.innerHTML = TEMPLATE;
componentHandler.upgradeElements(el);
var dialog = el.querySelector('.custom-js-dialog');
var confirm = dialog.querySelector('.custom-dialog-confirm');
var bt = document.querySelector('#bt1');
var clicked = false;
bt.addEventListener('click', function() {
clicked = true;
}, false);
var cherry = window.cherry;
var display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('none');
bt.click();
expect(clicked).to.be.equal(false);
setTimeout(function() {
display = cherry.getStyle(dialog, 'display');
expect(display).to.be.equal('block');
confirm.click();
expect(clicked).to.be.equal(true);
setTimeout(function() {
componentHandler.downgradeElementRecursive(el);
el.remove();
done();
}, defTout)
}, defTout)
});
});
|
;(function() {
if (!$('#jogo-do-mix').length) {
return;
}
var ua = navigator.userAgent.toLowerCase();
var jogoDoMix;
var playPause = $('#main-jogo-timeline-biografia #play-pause');
getDataJogoDoMix();
// Video
var videos = [
$('#main-jogo-timeline-biografia #video1')[0],
$('#main-jogo-timeline-biografia #video2')[0],
$('#main-jogo-timeline-biografia #video3')[0],
$('#main-jogo-timeline-biografia #video4')[0],
];
// Attr video idx
var counter = -1;
$('#main-jogo-timeline-biografia .controls li').each(function(){
$(this).find('input').attr('video', counter);
counter++;
});
$('body').on('click', '.menu button', function() {
var itemId = $(this).attr('id');
setJogo(itemId);
$('#jogo-do-mix .song').removeClass('active');
$('#' + itemId).addClass('active');
});
function getDataJogoDoMix(itemId) {
$.get("../assets/data/jogo-do-mix.json", function(data) {
if ( typeof data == 'string' ) {
jogoDoMix = JSON.parse( data );
} else {
jogoDoMix = data;
}
setupVideos(jogoDoMix, 0);
setupMenu(jogoDoMix);
});
};
function setJogo(itemId) {
var index = jogoDoMix.findIndex(x => x.id == itemId);
setupVideos(jogoDoMix, index);
}
function setupMenu(Data) {
var menuItems = [];
var songIndex;
for (var i = 0; i < Data.length; i++) {
if(i == 0) {
songIndex = 'active';
} else {
songIndex = '';
}
var Item = (Data[i]);
var menuItem = $(
'<button id="'+ Item.id +'" class="song ' + songIndex + '">' +
Item.compositor +
'<span class="music">' +
Item.musica +
'</span>' +
'</button>'
);
menuItems.push(menuItem);
}
$('#main-jogo-timeline-biografia #jogo-do-mix .menu').html(menuItems);
}
function setupVideos(data, current) {
//playPause.removeClass('pause');
//playPause.addClass('play');
$("#video1").attr("src", '../assets/videos/' + data[current].video1);
$("#video2").attr("src", '../assets/videos/' + data[current].video2);
$("#video3").attr("src", '../assets/videos/' + data[current].video3);
$("#video4").attr("src", '../assets/videos/' + data[current].video4);
$(".instrument1").html(data[current].video1Instrumento);
$(".instrument2").html(data[current].video2Instrumento);
$(".instrument3").html(data[current].video3Instrumento);
$(".instrument4").html(data[current].video4Instrumento);
}
// Play and pause click
playPause.on('click', function(){
if (videos[0].paused == false) {
pause();
} else {
play();
}
});
// Stop click
$('#main-jogo-timeline-biografia #stop').on('click', function(){
for (var i = 0; i < videos.length; i++) {
videos[i].pause();
videos[i].currentTime = 0;
}
$('#play-pause').removeClass('pause');
$('#play-pause').addClass('play');
});
// Play, pause and stop functions
function play() {
for (var i = 0; i < videos.length; i++) {
videos[i].play();
}
playPause.removeClass('play');
playPause.addClass('pause');
}
function pause() {
for (var i = 0; i < videos.length; i++) {
videos[i].pause();
}
playPause.removeClass('pause');
playPause.addClass('play');
}
function end() {
$('video').on('ended', function(){
play();
});
}
// Volume and video opacity
var range = $('input');
range.bind('input', function() {
var vol = $(this).val();
var value = vol * 100;
var volContainer = $(this).parent().find('.vol_bar');
var bar = volContainer.find('.bar');
var drag = volContainer.find('.drag');
var idx = $(this).attr('video');
var video = videos[idx];
var volume = video.volume;
$(this).parent().find('p span').text(vol + ' ' + value);
bar.css('width', value +'%');
if (value == 0) {
drag.css('left', 0 +'%');
} else {
drag.css('left', 'calc(' + value + '% - 10px)');
}
video.volume = vol;
video.style.opacity = vol;
});
})();
|
var models = require('../models'),
User = models.User;
var check = require('validator').check,
sanitize = require('validator').sanitize;
var crypto = require('crypto');
var config = require('../config').config;
var message_ctrl = require('./message');
var mail_ctrl = require('./mail');
//sign up
exports.signup = function(req,res,next){
var method = req.method.toLowerCase();
if(method == 'get'){
res.render('sign/signup');
return;
}
if(method == 'post'){
var name = sanitize(req.body.name).trim();
name = sanitize(name).xss();
var loginname = name.toLowerCase();
var pass = sanitize(req.body.pass).trim();
pass = sanitize(pass).xss();
var email = sanitize(req.body.email).trim();
email = email.toLowerCase();
email = sanitize(email).xss();
var re_pass = sanitize(req.body.re_pass).trim();
re_pass = sanitize(re_pass).xss();
if(name == '' || pass =='' || re_pass == '' || email ==''){
res.render('sign/signup', {error:'信息不完整。',name:name,email:email});
return;
}
if(name.length < 5){
res.render('sign/signup', {error:'用户名至少需要5个字符。',name:name,email:email});
return;
}
try{
check(name, '用户名只能使用0-9，a-z，A-Z。').isAlphanumeric();
}catch(e){
res.render('sign/signup', {error:e.message,name:name,email:email});
return;
}
if(pass != re_pass){
res.render('sign/signup', {error:'两次密码输入不一致。',name:name,email:email});
return;
}
try{
check(email, '不正确的电子邮箱。').isEmail();
}catch(e){
res.render('sign/signup', {error:e.message,name:name,email:email});
return;
}
User.find({'$or':[{'loginname':loginname},{'email':email}]},function(err,users){
if(err) return next(err);
if(users.length > 0){
res.render('sign/signup', {error:'用户名或邮箱已被使用。',name:name,email:email});
return;
}
// md5 the pass
pass = md5(pass);
// create gavatar
var avatar_url = 'http://www.gravatar.com/avatar/' + md5(email) + '?size=48';
var user = new User();
user.name = name;
user.loginname = loginname;
user.pass = pass;
user.email = email;
user.avatar = avatar_url;
user.active = false;
user.save(function(err){
if(err) return next(err);
mail_ctrl.send_active_mail(email,md5(email+config.session_secret),name,email,function(err,success){
if(success){
res.render('sign/signup', {success:'欢迎加入 ' + config.name + '！我们已给您的注册邮箱发送了一封邮件，请点击里面的链接来激活您的帐号。'});
return;
}
});
});
});
}
};
/**
* Show user login page.
*
* @param {HttpRequest} req
* @param {HttpResponse} res
*/
exports.showLogin = function(req, res) {
req.session._loginReferer = req.headers.referer;
res.render('sign/signin');
};
/**
* Handle user login.
*
* @param {HttpRequest} req
* @param {HttpResponse} res
* @param {Function} next
*/
exports.login = function(req, res, next) {
var loginname = sanitize(req.body.name).trim().toLowerCase();
var pass = sanitize(req.body.pass).trim();
if (!loginname || !pass) {
return res.render('sign/signin', { error: '信息不完整。' });
}
User.findOne({ 'loginname': loginname }, function(err, user) {
if (err) return next(err);
if (!user) {
return res.render('sign/signin', { error:'这个用户不存在。' });
}
pass = md5(pass);
if (pass !== user.pass) {
return res.render('sign/signin', { error:'密码错误。' });
}
if (!user.active) {
res.render('sign/signin', { error:'此帐号还没有被激活。' });
return;
}
// store session cookie
gen_session(user, res);
res.redirect(req.session._loginReferer || 'home');
});
};
// sign out
exports.signout = function(req, res, next) {
req.session.destroy();
res.clearCookie(config.auth_cookie_name, { path: '/' });
res.redirect(req.headers.referer || 'home');
};
exports.active_account = function(req,res,next) {
var key = req.query.key;
var name = req.query.name;
var email = req.query.email;
User.findOne({name:name},function(err,user){
if(!user || md5(email+config.session_secret) != key){
res.render('notify/notify',{error: '信息有误，帐号无法被激活。'});
return;
}
if(user.active){
res.render('notify/notify',{error: '帐号已经是激活状态。'});
return;
}
user.active = true;
user.save(function(err){
res.render('notify/notify',{success: '帐号已被激活，请登录'});
});
});
}
exports.search_pass = function(req,res,next){
var method = req.method.toLowerCase();
if(method == 'get'){
res.render('sign/search_pass');
}
if(method == 'post'){
var email = req.body.email;
email = email.toLowerCase();
try{
check(email, '不正确的电子邮箱。').isEmail();
}catch(e){
res.render('sign/search_pass', {error:e.message,email:email});
return;
}
User.findOne({email:email},function(err,user){
if(!user){
res.render('sign/search_pass', {error:'没有这个电子邮箱。',email:email});
return;
}
mail_ctrl.send_reset_pass_mail(email,md5(email+config.session_secret),user.name,function(err,success){
res.render('notify/notify',{success: '我们已给您填写的电子邮箱发送了一封邮件，请点击里面的链接来重置密码。'});
});
});
}
}
exports.reset_pass = function(req,res,next){
var key = req.query.key;
var name = req.query.name;
var new_pass = '';
User.findOne({name:name},function(err,user){
if(!user || md5(user.email+config.session_secret) != key){
res.render('notify/notify',{error: '信息有误，密码无法重置。'});
return;
}
new_pass = random_password();
user.pass = md5(new_pass);
user.save(function(err){
res.render('notify/notify',{success: '你的密码已被重置为：' + new_pass + '，请立即用此密码登录后在设置页面更改密码。'});
});
});
}
// auth_user middleware
exports.auth_user = function(req,res,next){
if(req.session.user){
if(config.admins[req.session.user.name]){
req.session.user.is_admin = true;
}
message_ctrl.get_messages_count(req.session.user._id,function(err,count){
if(err) return next(err);
req.session.user.messages_count = count;
res.local('current_user',req.session.user);
return next();
});
}else{
var cookie = req.cookies[config.auth_cookie_name];
if(!cookie) return next();
var auth_token = decrypt(cookie, config.session_secret);
var auth = auth_token.split('\t');
var user_id = auth[0];
User.findOne({_id:user_id},function(err,user){
if(err) return next(err);
if(user){
if(config.admins[user.name]){
user.is_admin = true;
}
message_ctrl.get_messages_count(user._id,function(err,count){
if(err) return next(err);
user.messages_count = count;
req.session.user = user;
res.local('current_user',req.session.user);
return next();
});
}else{
return next();
}
});
}
};
// private
function gen_session(user,res){
var auth_token = encrypt(user._id + '\t'+user.name + '\t' + user.pass +'\t' + user.email, config.session_secret);
res.cookie(config.auth_cookie_name, auth_token, {path: '/',maxAge: 1000*60*60*24*7}); //cookie 有效期1周
}
function encrypt(str,secret){
var cipher = crypto.createCipher('aes192', secret);
var enc = cipher.update(str,'utf8','hex');
enc += cipher.final('hex');
return enc;
}
function decrypt(str,secret){
var decipher = crypto.createDecipher('aes192', secret);
var dec = decipher.update(str,'hex','utf8');
dec += decipher.final('utf8');
return dec;
}
function md5(str){
var md5sum = crypto.createHash('md5');
md5sum.update(str);
str = md5sum.digest('hex');
return str;
}
function random_password(passwd_size){
var size = passwd_size || 6;
var code_string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
var max_num = code_string.length + 1;
var new_pass = '';
while(size>0){
new_pass += code_string.charAt(Math.floor(Math.random()* max_num));
size--;
}
return new_pass;
}
|
import React from 'react';
const BlogCard = (props) => {
const {name,image,country,description}=props.data;
return (
<div className="col-md-3 card m-2">
<div className=" d-flex pt-3 align-items-center">
<img className="mx-3" src={image} alt="" width="60"/>
<div>
<h6 className="text-primary">{name}</h6>
<p className="m-0">{country}</p>
</div>
</div>
<div className="card-body">
<p className="card-text text-center">{description}</p>
</div>
</div>
);
};
export default BlogCard;
|
module.exports = function (f, t) {
if (!t)
return f
var err = new Error('timeout of '+t+'ms exceeded for callback ' + (f.name||'anonymous'))
err.name = 'Timeout'
var ecb = function () {
clearTimeout(timer)
timer = null
f.call(f, new Error(err))
}
var timer = setTimeout(ecb, t)
var cb = function () {
if (timer) {
clearTimeout(timer)
f.apply(f, arguments)
}
}
return cb
}
|
var $E = function(opts){
function _(objId){return (typeof objId === "string")?document.getElementById(objId):objId;}
var beImg,expand,clip,cover,warp,expImg;
var clipWidth,clipHeight;
var closeTimeId = null;
var mult = 1; //图片放大倍数,根据裁剪框和放大后图片容器的大小自动调整
//init
(function(){
beImg = _(opts.berviary);
warp = beImg.parentNode;
cover = document.createElement("div");
warp.appendChild(cover);
cover.style.position = "absolute";
cover.style.top = "0px";
cover.style.left = "0px";
cover.style.backgroundColor = "#ccc";
var opac = parseFloat(opts.opacity) || 0.3;
cover.style.opacity = opac;
cover.style.filter = "Alpha(Opacity=" + opac * 100 + ")";
cover.style.width = "100%";
cover.style.height = "100%";
cover.style.zIndex = 2;
cover.style.visibility = "hidden";
clip = document.createElement("img");
warp.appendChild(clip);
clipWidth = (opts.clip && opts.clip.width) || "60px";
clipHeight = (opts.clip && opts.clip.height) || "60px";
clip.src = beImg.src;
clip.className = beImg.className;
clip.style.position = "absolute";
clip.style.top = "0px";
clip.style.left = "0px";
clip.style.clip = "rect(0px," + clipWidth + "," + clipHeight + ",0px)";
clip.style.backgroundColor = "#ccc";
clip.style.zIndex = 3;
//ie里面会变态的自动设置宽度和高度
clip.removeAttribute("width");
clip.removeAttribute("height");
})();
function layerPos(e){
if(e.layerX && e.layerY){
return {x:e.layerX,y:e.layerY};
} else {
return {x:e.x - document.getElementById('img_warp').offsetLeft,y:e.y - document.getElementById('img_warp').offsetTop};
}
}
function absolutePos(e){
if(e.pageX && e.pageY){
return {x:e.pageX,y:e.pageY};
} else {
var x = e.clientX + (document.documentElement.scrollLeft?document.documentElement.scrollLeft : document.body.scrollLeft);
var y = e.clientY + (document.documentElement.scrollTop?document.documentElement.scrollTop : document.body.scrollTop);
return {x:x,y:y};
}
}
var showExpand = function(x,y,e){
if(!expand){
initExpand();
}
expImg.style.left = (-1 * x) * mult + "px";
expImg.style.top = (-1 * y ) * mult + "px";
if((!opts.expand) || (!opts.expand.id)){
var aPos = absolutePos(e);
expand.style.left = aPos.x + parseFloat(clipWidth) / 2 + 20 + "px";
expand.style.top = aPos.y + "px";
}
//初始化放大的div
function initExpand(){
if(opts.expand && opts.expand.id) {
expand = _(opts.expand.id);
} else {
expand = document.createElement("div");
if(opts.expand && opts.expand.style){
for(var p in opts.expand.style){
expand.style[p] = opts.expand.style[p];
}
}
expand.style.border = "1px solid #000";
expand.style.position = "absolute";
expand.style.left ="0";
expand.style.right = "0";
expand.style.display = "block";
document.body.appendChild(expand);
if(clip.clientWidth>clip.clientHeight){
expand.style.width = clip.clientWidth + "px";
expand.style.height = clip.clientWidth * parseFloat(clipHeight) / parseFloat(clipWidth) + "px";
} else {
expand.style.height = clip.clientHeight + "px";
expand.style.width = clip.clientHeight * parseFloat(clipWidth) / parseFloat(clipHeight) + "px";
}
expand.style.zIndex = 4;
}
expand.style.overflow = "hidden";
if((expand.style.position != "relative") && (expand.style.position != "absolute")){
//变态的ie6和ie7的img如果为relative,需要设置其父节点也为relative,否则overflow:hidden无效
expand.style.position = "relative";
expand.style.left = "0";
expand.style.top = "0";
}
expImg = document.createElement("img");
expImg.src = beImg.src;
expImg.style.position = "relative";
expImg.style.left = "0px";
expImg.style.top = "0px";
expand.appendChild(expImg);
expImg.removeAttribute("width");
expImg.removeAttribute("height");
//计算图片放大的倍数
var ew = expand.clientWidth;
var eh = expand.clientHeight;
var cw = parseFloat(clipWidth);
var ch = parseFloat(clipHeight);
mult = (ew/cw < eh/ch) ? ew/cw : eh/ch;
//调整放大图片的大小
expImg.style.width = beImg.clientWidth * mult + "px";
expImg.style.height = beImg.clientHeight * mult + "px";
}
}
cover.onmousemove = clip.onmousemove = function(e){
var e = e || event;
var pos = layerPos(e);
var x = pos.x;
var y = pos.y;
//判断x和y坐标有没有超出范围
var w = parseFloat(clipWidth) / 2,h = parseFloat(clipHeight) / 2;
x = (x < w)?w:x;
y = (y < h)?h:y;
x = (x > warp.clientWidth - w) ? (warp.clientWidth - w) : x;
y = (y > warp.clientHeight - h) ? (warp.clientHeight - h) : y;
clip.style.clip = "rect(" + (y - h) + "px," + (x + w) + "px," + (y + h) + "px," + (x - w) + "px)";
showExpand(x - w,y - h,e);
}
warp.onmouseover = cover.onmouseover = clip.onmouseover = function(){
//如果清除的定时器存在,则删除.
if(closeTimeId){
clearTimeout(closeTimeId);
closeTimeId = null;
}
if(cover.style.visibility === "hidden"){
cover.style.visibility = "visible";
}
if(expand && expand.style.display === "none"){
expand.style.display = "block";
}
}
warp.onmouseout = function(){
//延迟一定时间后清除
closeTimeId = setTimeout(function(){
cover.style.visibility = "hidden";
document.getElementById("expand").style.display='none';
if((!opts.expand) || (!opts.expand.id)){
expand.style.display = "none";
}
},130);
}
return {
clear:function(){
//在这里清除放大镜效果
warp.removeChild(clip);
warp.removeChild(cover);
warp.onmouseout = null;
if((!opts.expand) || (!opts.expand.id)){
expand.style.display = "none";
}
}
}
}
|
const Footer = {
render: () => `
<div class="footer__top">
<div class="container">
<div class="row">
<div class="col text-center">
<div class="footer__top-brand"><img src="../images/brands.png" alt="Brand"></div>
</div>
</div>
</div>
</div>
<div class="footer__middle">
<div class="container">
<div class="row">
<div class="col-md-2 col-xs-12">
<h4 class="footer__title">Thông tin</h4>
<ul class="footer__list">
<li><a href="#">Về chúng tôi</a></li>
<li><a href="#">Giao hàng</a></li>
<li><a href="#">Cảm nghĩ</a></li>
<li><a href="#">Lưu trữ</a></li>
<li><a href="#">Chính sách riêng tư</a></li>
</ul>
</div>
<div class="col-md-2 col-xs-12">
<h4 class="footer__title">Mua hàng</h4>
<ul class="footer__list">
<li><a href="#">Vận chuyển và trả hàng</a></li>
<li><a href="#">Mua hàng an toàn</a></li>
<li><a href="#">Vận chuyển quốc tế</a></li>
<li><a href="#">Liên kết</a></li>
<li><a href="#">Dịch vụ giảm giá</a></li>
</ul>
</div>
<div class="col-md-4 col-xs-12">
<h4 class="footer__title">Gửi email</h4>
<p>Gửi email cho chúng tôi để được hỗ trợ</p>
<div class="cta">
<form class="input-group">
<input class="form-control" type="text" placeholder="Recipient's username" aria-label="Recipient's username" aria-describedby="basic-addon2">
<div class="input-group-append">
<button class="btn btn-outline-secondary cta__btn" type="button">Gửi</button>
</div>
</form>
</div>
<ul class="footer__social">
<li><a href="#"><i class="fab fa-twitter"></i></a></li>
<li><a href="#"><i class="fab fa-google-plus-g"></i></a></li>
<li><a href="#"><i class="fab fa-dribbble"></i></a></li>
<li><a href="#"><i class="fas fa-rss"></i></a></li>
</ul>
</div>
<div class="col-md-4 col-xs-12">
<h4 class="footer__title">Liên hệ</h4>
<div class="footer__contact"><span><i class="fas fa-map-marker-alt"></i></span><span>Tầng 4, Tòa nhà Hanoi Group Số 442 Đội Cấn, P. Cống Vị, Q. Ba Đình, Hà Nội</span></div>
<div class="footer__contact"><span><i class="fas fa-fax"></i></span><span>(04) 6674 2332</span><span><i class="fas fa-fax"></i></span><span>(04) 3786 8904</span></div>
<div class="footer__contact"><span><i class="fas fa-fax"></i></span><span>(08) 6680 9686</span><span><i class="fas fa-envelope"></i></span><span><a href="#">Support@bizweb.vn</a></span></div>
</div>
</div>
</div>
</div>
<div class="footer__bottom">
<div class="container">
<div class="copyright">© Copyright 2008-2014 DKT Technology JSC</div>
<div class="payment"><img src="../images/payments.png" alt="Payment"></div>
</div>
</div>
`,
};
export default Footer;
|
const express = require('express')
const bodyParser = require('body-parser')
const cors = require('cors')
const fileUpload = require('express-fileupload')
require('dotenv').config();
const app = express()
app.use(cors());
app.use(bodyParser.json());
app.use(fileUpload());
app.use(bodyParser.urlencoded({ extended: false }))
const port = 5000
const ObjectID = require('mongodb').ObjectID;
const MongoClient = require('mongodb').MongoClient;
const uri = `mongodb+srv://${process.env.DB_USER}:${process.env.DB_PASS}@cluster0.fuyuk.mongodb.net/${process.env.DB_NAME}?retryWrites=true&w=majority`;
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
client.connect(err => {
const userInfoCollection = client.db(process.env.DB_NAME).collection("userInfo");
const bankInfoCollection = client.db(process.env.DB_NAME).collection("banks");
const coinInfoCollection = client.db(process.env.DB_NAME).collection("coins");
const tokenInfoCollection = client.db(process.env.DB_NAME).collection("tokens");
// add UserInfo
app.post('/buySubmit', (req, res) => {
const coinID = req.body.coin;
const quantity = req.body.quantity;
const walletAddress = req.body.address;
const bankID = req.body.bank;
userInfoCollection.insertOne({ coinID, quantity, walletAddress, bankID })
.then(result => {
res.status(200).send(result.insertedCount > 0);
})
})
app.get('/getAllBank', (req, res) => {
bankInfoCollection.find()
.toArray((err, documents) => {
res.status(200).send(documents);
})
})
app.get('/getAllCoin', (req, res) => {
coinInfoCollection.find()
.toArray((err, documents) => {
res.status(200).send(documents);
})
})
app.get('/getBankByCoin', (req, res) => {
const coinName = req.query.coin;
bankInfoCollection.find({ coin: coinName })
.toArray((err, documents) => {
res.send(documents);
})
});
app.get('/getAllToken', (req, res) => {
tokenInfoCollection.find()
.toArray((err, documents) => {
res.status(200).send(documents);
})
})
});
app.get('/', (req, res) => {
res.send('server is running')
})
app.listen(process.env.PORT || port)
|
import React from 'react';
import PropTypes from 'prop-types';
import styles from './Welcome.module.css';
const Welcome = () => (
<div className={styles.Welcome} data-testid="Welcome">
<h1>
Hi I'm draftjs editor
</h1>
</div>
);
Welcome.propTypes = {};
Welcome.defaultProps = {};
export default Welcome;
|
"use strict";
module.exports=function(sequelize,DataTypes){
var match_titles = sequelize.define("match_titles",{
title:{type:DataTypes.STRING, unique:true, allowNull:false,primaryKey: true}
});
return match_titles;
};
|
const buttonOpeningModalRegister = document.querySelector(".j-register-button");
const modalRegister = document.querySelector(".j-modal-register");
const buttonCloseModalRegister = document.querySelector(".j-close-modal-register");
const loaderRegister = modalRegister.querySelector(".loader_js");
const registerForm = document.forms.registerForm;
const loginForm = document.forms.loginForm;
const linkToProfile = document.querySelector(".j-to-profile");
const modalLogin = document.querySelector(".j-modal-login");
const loaderLogin = modalLogin.querySelector(".loader_js");
// Логика регистрации пользователя
let isLoading = false;
function register(e) {
e.preventDefault();
if(isLoading) {
return;
}
removeErrorsFromForm(e.target);
isLoading = true;
loaderRegister.classList.remove('hidden');
const data = getDataFromForm(e.target);
console.log(data);
sendRequest({
url: '/api/users',
method: 'POST',
body: JSON.stringify(data),
headers: {
'Content-Type': 'application/json;charset=utf-8'
},
})
.then(res => res.json())
.then(res => {
if(!res.success) {
throw res;
} else {
console.log('then', res);
isLoading = false;
loaderRegister.classList.add('hidden');
}
})
.catch(err => {
setErrorsToForm(e.target, err.errors);
isLoading = false;
loaderRegister.classList.add('hidden');
});
}
function logIn(e) {
e.preventDefault();
if(isLoading) {
return;
}
removeErrorsFromForm(e.target);
isLoading = true;
loaderLogin.classList.remove('hidden');
const data = getDataFromForm(e.target);
sendRequest({
method: 'POST',
url: '/api/users/login',
headers: {
'Content-Type': 'application/json;charset=utf-8',
},
body: JSON.stringify(data),
})
.then(res => res.json())
.then(res => {
if(!res.success) {
throw res;
}
window.location = '/11/profile';
updateTokenState(res.data);
isLoading = false;
loaderLogin.classList.add('hidden');
})
.catch(err => {
if(err._message) {
alert(err._message);
}
setErrorsToForm(e.target, err.errors);
isLoading = false;
loaderLogin.classList.add('hidden');
});
}
function modalWindow({toggleButtonSelector, closeButtonSelector, modalSelector, isOpen = false}) {
const toggleButton = document.querySelector(toggleButtonSelector);
const closeButton = document.querySelector(closeButtonSelector);
const modal = document.querySelector(modalSelector);
toggleButton.addEventListener('click', () => {
removeErrorsFromForm(modal);
interactionModal(modal);
});
closeButton.addEventListener('click', () => {
removeErrorsFromForm(modal);
interactionModal(modal);
});
}
modalWindow({
toggleButtonSelector: '.j-login-button',
closeButtonSelector: '.j-close-modal-login',
modalSelector: '.j-modal-login',
});
modalWindow({
toggleButtonSelector: '.j-register-button',
closeButtonSelector: '.j-close-modal-register',
modalSelector: '.j-modal-register',
});
registerForm.addEventListener('submit', (e) => {
register(e);
});
loginForm.addEventListener('submit', (e) => {
logIn(e);
});
|
const express = require('express');
const server = express();
server.use(express.json());
const projects = [];
var totalreqs = 0;
server.use((req, res, next) => {
totalreqs++;
console.log(`Total de requisições realizadas até o momento: ${totalreqs}`);
next();
});
function checkProjectId(req, res, next) {
const { id } = req.params;
const project = projects.find(x => x.id === id);
const projectIndex = projects.findIndex(x => x.id === id);
if (!id)
return res.json({ error: 'ID não localizado!' })
if (!project || project === undefined)
return res.json({ error: 'Projeto não localizado' })
req.project = project;
req.index = projectIndex;
return next();
}
function checkParamsProject(req, res, next) {
const { id, title } = req.body;
if (!id)
return res.json({ error: 'ID do projeto não foi localizado!' });
if (!title)
return res.json({ error: 'Título do projeto não foi localizado!' });
return next();
}
function checkIdParamsProject(req, res, next) {
const { id } = req.params;
const { title } = req.body;
if (!id)
return res.json({ error: 'ID do projeto não foi localizado!' });
if (!title)
return res.json({ error: 'O campo "title" está faltando!' });
return next();
}
function checkIdProjectExsits(req, res, next) {
const { id } = req.body;
const project = projects.find(p => p.id === id);
if (project)
return res.json({ error: 'ID já existe!', project });
return next();
}
server.get('/projects', (req, res) => {
return res.json(projects);
});
server.get('/projects/:id', checkProjectId, (req, res) => {
return res.json(req.project);
});
server.post('/projects', checkParamsProject, checkIdProjectExsits, (req, res) => {
projects.push(req.body);
return res.json(projects);
});
server.put('/projects/:id', checkIdParamsProject, checkProjectId, (req, res) => {
projects[req.index].title = req.body.title;
return res.json(projects[req.index]);
});
server.delete('/projects/:id', checkProjectId, (req, res) => {
projects.splice(req.index, 1);
return res.json({ message: "Projeto deletado!" });
});
server.post('/projects/:id/tasks', checkProjectId, (req, res) => {
const { title } = req.body;
if (!title)
return res.json({ error: 'Campo "title" é obrigatório!' });
if (!projects[req.index]["tasks"])
projects[req.index]["tasks"] = [];
projects[req.index].tasks.push(req.body);
return res.json(projects[req.index]);
});
server.listen(3000);
|
const HOST_URL = 'http://18.130.226.249:5000/';
const API_URL = HOST_URL + 'api';
export default {
HOST_URL: HOST_URL,
API_URL: API_URL
}
|
//-----打乱数组函数-------
export const shuffle = (arr) => {
const _arr = arr.slice();
const arrLength = _arr.length;
let i = arrLength;
let num;
while(i--) {
num = Math.floor(Math.random()*arrLength);
if(i !== num) {
[_arr[i],_arr[num]] = [_arr[num],_arr[i]];
}
}
return _arr;
}
//---------节流函数---------
export const debounce = (fn,delay=200) => {
let timer = null;
return function(...agrs) {
timer && clearTimeout(timer);
timer = setTimeout(() => {
fn.apply(this,agrs)
}, delay);
}
}
|
import React, { useEffect } from 'react';
import { Grid } from '@material-ui/core';
import Controls from '../../components/controls/Controls';
import { useForm, Form } from '../../components/useForm';
import ServiceLayer from '../../services/ServiceLayer';
const genderItems = [
{id:'male', title:'Male'},
{id:'female', title:'Female'},
{id:'other', title:'Other'} ,
]
const initialFValues = {
patientId: 0,
patientFirstName : '',
patientLastName : '',
patientDOB: null,
patientGender: '',
patientClass: '',
patientHaveIEP: false,
patientInABA: false,
patientNotes: '',
patientInactive: false
}
export default function PatientForm() {
// Validation function (to be passed as a callback)
const validate = (fieldValues = values) => {
let temp = {...errors};
if('patientFirstName' in fieldValues)
temp.patientFirstName = fieldValues.patientFirstName ? "" : "This field is required."
if('patientLastName' in fieldValues)
temp.patientLastName = fieldValues.patientLastName ? "" : "This field is required."
if('patientDOB' in fieldValues)
temp.patientDOB = fieldValues.patientDOB ? "" : "This field is required."
if('patientClass' in fieldValues)
temp.patientClass = fieldValues.patientClass ? "" : "This field is required."
if('patientGender' in fieldValues)
temp.patientGender = fieldValues.patientGender ? "" : "This field is required."
// temp.moble = values.mobile.length > 9 ? "" : "Minimum 10 numbers required"
// temp.email = (/$^|.+@.+..+/).test(values.email) ? "" : "Email is not a valid format"
setErrors({
...temp
})
// Check that every item in the array has a blank result (no errors) else return false.
if(fieldValues === values)
return Object.values(temp).every(x => x === "")
}
// const [values, setValues ] = useState(initialFValues);
// const classes = useStyles;
const {
values,
// setValues,
errors,
setErrors,
handleInputChange,
resetForm,
} = useForm(initialFValues);
// SaveSubmit Callback handler - event driven
const handleSubmit = (event) => {
event.preventDefault();
if(validate())
alert("All good")
};
// // TODO: Swap this out with Redux Actions/Reducers
// async function updatePatients(e){
// try{
// const response = await ServiceLayer.updatePatient(values);
// setPatients(response.data);
// resetForm()
// }
// catch(e){
// console.log('API call unsuccessful', e)
// }
// }
useEffect(() => {
},[values])
return(
<Form>
<Grid container alignItems="flex-start" spacing={2}>
<Grid item xs={6}>
<Controls.Input
name="patientFirstName"
label="FirstName"
value={values.patientFirstName}
onChange={handleInputChange}
error={errors.patientFirstName}
/>
<Controls.Input
name="patientLastName"
label="LastName"
value={values.patientLastName}
onChange={handleInputChange}
error={errors.patientLastName}
/>
<Controls.DatePicker
name="patientDOB"
label="Date of Birth"
value={values.patientDOB}
onChange={handleInputChange}
error={errors.patientDOB}
/>
<Controls.RadioGroup
name="patientGender"
label="Gender"
value={values.patientGender}
onChange={handleInputChange}
items={genderItems}
error={errors.patientGender}
/>
</Grid>
<Grid item xs={6}>
<Controls.Select
name="patientClass"
label="Financial Class"
value={values.patientClass}
onChange={handleInputChange}
options = {ServiceLayer.getAllFinancialClasses() }
error={errors.patientClass}
/>
<Controls.Checkbox
name="patientHaveIEP"
label="Has an IEP"
value={values.patientHaveIEP}
onChange={handleInputChange}
/>
<Controls.Checkbox
name="patientInABA"
label="In ABA"
value={values.patientInIEP}
onChange={handleInputChange}
/>
<Controls.Checkbox
name="patientInactive"
label="InActive"
value={values.patientInactive}
onChange={handleInputChange}
color="secondary"
/>
</Grid>
<Grid item xs={12} styles={{display: "flex"}}>
<Controls.Input
name="patientNotes"
label="Notes"
value={values.patientNotes}
onChange={handleInputChange}
multiline
rowsMax={4}
/>
<div styles={{display: "flex"}}>
<Controls.Button
type="submit"
text="Submit"
onClick={handleSubmit}
/>
<Controls.Button
color="default"
text="Reset"
onClick={resetForm}
/>
</div>
</Grid>
</Grid>
</Form>
)
}
|
/*!
* remarked <https://github.com/jonschlinkert/remarked>
*
* Copyright (c) 2014 Jon Schlinkert
* Licensed under the MIT license.
*
* Based on marked <https://github.com/chjj/marked>
* Copyright (c) 2011-2014, Christopher Jeffrey, contributors.
* Released under the MIT License (MIT)
*/
'use strict';
var defaults = require('./lib/defaults');
var Parser = require('./lib/parser');
var Lexer = require('./lib/lexer-block');
var InlineLexer = require('./lib/lexer-inline');
var Renderer = require('./lib/renderer');
var utils = require('./lib/utils/helpers');
var merge = require('./lib/utils/merge');
// Copy defaults
var remarkedOptions = merge({}, defaults);
/**
* remarked
*/
function Remarked(src, options) {
if (!(this instanceof Remarked)) {
var remarked = new Remarked(merge({} ,remarkedOptions, options));
return remarked.parse(src);
}
this.options = merge({}, defaults, src);
this.lexer = new Lexer(this.options);
this.parser = new Parser(this.options);
}
/**
* parse
*/
Remarked.prototype.parse = function(src) {
try {
return this.parser.parse(this.lexer.lex(src));
} catch (e) {
e.message += '\n [remarked]: please report this to https://github.com/jonschlinkert/remarked.';
if ((this.options || defaults).silent) {
return '<p>An error occured:</p><pre>' + utils._escape(e.message + '', true) + '</pre>';
}
throw e;
}
};
/**
* options
*/
Remarked.prototype.setOptions = function(options) {
merge(this.options, options);
return this;
};
Remarked.setOptions = function (options) {
merge(remarkedOptions, options);
return this;
};
Remarked.defaults = defaults;
/**
* Expose classes
*/
Remarked.Parser = Parser;
Remarked.Renderer = Renderer;
Remarked.Lexer = Lexer;
Remarked.InlineLexer = InlineLexer;
// Export remarked
module.exports = Remarked;
|
const moment = require("moment");
let groupBy = async (data) => {
let response = {};
data.forEach(item => {
let columnName = moment(item['created_at']).format('Y-MM-DD');
if (response.hasOwnProperty(columnName)) {
response[columnName].push(item)
} else {
response[columnName] = [];
response[columnName].push(item)
}
})
return response;
}
module.exports.groupBy = groupBy;
|
import state from "./state"
const getters = {
skin:(state,getters)=>{
return state.skin
},
header:(state,getters)=>{
return state.header
},
account:(state,getters) =>{
return state.account
},
isConnected: (state, getters) => {
return state.isConnected
},
chainId:(state, getters) => {
return state.chainId
},
web3:(state, getters) => {
return state.web3
},
drizzle:(state, getters) => {
return state.drizzle
}
}
export default(getters)
|
import registerComponent from "../../../core/component_registrator";
import BaseComponent from "../../component_wrapper/component";
import { Form as FormComponent } from "./form";
export default class Form extends BaseComponent {
get _propsInfo() {
return {
twoWay: [],
allowNull: [],
elements: [],
templates: [],
props: ["scrollingEnabled", "useNativeScrolling"]
};
}
get _viewComponent() {
return FormComponent;
}
}
registerComponent("dxForm", Form);
|
// All valid credit card numbers
const valid1 = [4, 5, 3, 9, 6, 7, 7, 9, 0, 8, 0, 1, 6, 8, 0, 8]
const valid2 = [8, 5, 3, 5, 7, 6, 6, 7, 6, 8, 7, 5, 1, 4, 3, 9]
const valid3 = [3, 7, 1, 6, 1, 2, 0, 1, 9, 9, 8, 5, 2, 3, 6]
const valid4 = [6, 0, 1, 1, 1, 4, 4, 3, 4, 0, 6, 8, 2, 9, 0, 5]
const valid5 = [4, 5, 3, 9, 4, 0, 4, 9, 6, 7, 8, 6, 9, 6, 6, 6]
// All invalid credit card numbers
const invalid1 = [4, 5, 3, 2, 7, 7, 8, 7, 7, 1, 0, 9, 1, 7, 9, 5]
const invalid2 = [5, 7, 9, 5, 5, 9, 3, 3, 9, 2, 1, 3, 4, 6, 4, 3]
const invalid3 = [3, 7, 5, 7, 9, 6, 0, 8, 4, 4, 5, 9, 9, 1, 4]
const invalid4 = [6, 0, 1, 1, 1, 2, 7, 9, 6, 1, 7, 7, 7, 9, 3, 5]
const invalid5 = [5, 3, 8, 2, 0, 1, 9, 7, 7, 2, 8, 8, 3, 8, 5, 4]
// Can be either valid or invalid
const mystery1 = [3, 4, 4, 8, 0, 1, 9, 6, 8, 3, 0, 5, 4, 1, 4]
const mystery2 = [5, 4, 6, 6, 1, 0, 0, 8, 6, 1, 6, 2, 0, 2, 3, 9]
const mystery3 = [6, 0, 1, 1, 3, 7, 7, 0, 2, 0, 9, 6, 2, 6, 5, 6, 2, 0, 3]
const mystery4 = [4, 9, 2, 9, 8, 7, 7, 1, 6, 9, 2, 1, 7, 0, 9, 3]
const mystery5 = [4, 9, 1, 3, 5, 4, 0, 4, 6, 3, 0, 7, 2, 5, 2, 3]
// An array of all the arrays above
const batch = [valid1, valid2, valid3, valid4, valid5, invalid1, invalid2, invalid3, invalid4, invalid5, mystery1, mystery2, mystery3, mystery4, mystery5]
// Add your functions below:
function checkCard(array) {
let copyArray = array;
let last = copyArray.pop();
let doubleArray = [];
let singleArray = [];
const decimalTointeger = (decimal) => { //Convert a decimal number in the sum of his digits.
let rest = decimal % 10;
let result = 1+rest;
return result;
}
const sum = (arr) => arr.reduce(function (a,b){return a+b;}); // Fuction make the total sum of the all elements of Array.
for(let i= copyArray.length-1; i >= 0; i--){// loop to go truth the Array from the left.
let double = copyArray[i] *2;
if( double >= 10) {
double = decimalTointeger(double);
}
doubleArray.unshift(double);// Make a new array with double de digits.
i= i - 1;
if( i === -1) {
break;
} else{
singleArray.unshift(copyArray[i]); // Make a new array of the other number single.
}
}
let sumTotal = sum(doubleArray) + sum(singleArray); // Make the Sum of the 2 Arrays
let digitX = 10 - (sumTotal % 10); // show the digit.
if(digitX === last) { //Check the last digict with the result of Luhn algorithm.
return true;
}
else{
return false;
}
};
function findInvalidCards(array) { // function for checking invalidcards in an Array, retunr an Array
let invalidCards=[];
array.forEach(element => {
let arrayChecked = checkCard(element);
if(!arrayChecked){
invalidCards.push(element);
}
});
return invalidCards;
};
function checkedCompany(array) {// Check the company of the credit card.
if(array[0] === 3) {
return 'Amex';
}else if (array[0] === 4){
return 'Visa';
}else if (array[0] === 5){
return 'Mastercard';
}else if (array[0] === 6){
return 'Discover';
}else{
return 'Company not found';
}
};
function idInvalidCardCompanies(array) { // return an Array of cards companies without duplicates.
let companies = [];
array.forEach(element =>{
let company = checkedCompany(element);
if (company != 'Company not found'){ // check if Company is 'Not found'.
let duplicate = companies.includes(company);// check if the company is in the Array of companies.
if(!duplicate){
companies.push(company);
}
}
});
return companies;
};
function checkEverything(array){ // Completed function that log to the console an Array of Ivalid Cards and the companies.
let arr = findInvalidCards(array);
console.log(arr);
console.log(idInvalidCardCompanies(arr));
}
checkEverything(batch);
|
#!/usr/bin/env node
#
# jQuery File Upload Plugin Node.js Example 2.0
# https://github.com/blueimp/jQuery-File-Upload
#
# Copyright 2012, Sebastian Tschan
# https://blueimp.net
#
# Licensed under the MIT license:
# http://www.opensource.org/licenses/MIT
#jslint nomen: true, regexp: true, unparam: true, stupid: true
#global require, __dirname, unescape, console
# (modified and converted to coffeescript by Jason Livesay
# because I want to use SSL and can't do cross-origin with SSL
# so this needs to be integrated into the main server)
require('source-map-support').install()
path = require 'path'
fs = require 'fs'
_existsSync = fs.existsSync || path.existsSync
formidable = require 'formidable'
nodeStatic = require 'node-static'
imageMagick = require 'imagemagick'
options =
tmpDir: __dirname + '/tmp'
publicDir: __dirname + '/public'
uploadDir: __dirname + '/public/files'
uploadUrl: '/files/'
maxPostSize: 11000000000 # 11 GB
minFileSize: 0
maxFileSize: 10000000000 # 10 GB
acceptFileTypes: /.+/i
safeFileTypes: /\.(gif|jpe?g|png)$/i
imageTypes: /\.(gif|jpe?g|png)$/i
imageVersions:
thumbnail:
width: 80
height: 80
accessControl:
allowOrigin: '*'
allowMethods: 'OPTIONS, HEAD, GET, POST, PUT, DELETE'
allowHeaders: 'X-Requested-With'
ssl:
key: fs.readFileSync 'key.pem'
cert: fs.readFileSync 'cert.pem'
utf8encode = (str) -> unescape encodeURIComponent(str)
nameCountRegexp = /(?:(?: \(([\d]+)\))?(\.[^.]+))?$/
nameCountFunc = (s, index, ext) ->
' (' + ((parseInt(index, 10) || 0) + 1) + ')' + (ext || '')
serve = (req, res) ->
#res.setHeader 'Access-Control-Allow-Origin', options.accessControl.allowOrigin
#res.setHeader 'Access-Control-Allow-Methods', options.accessControl.allowMethods
handleResult = (result, redirect) ->
if redirect
res.writeHead 302, { Location: redirect.replace /%s/,
encodeURIComponent(JSON.stringify(result)) }
res.end()
else
res.writeHead 200, { 'Content-Type':
req.headers.accept.indexOf('application/json') != -1 ?
'application/json' : 'text/plain' }
res.end JSON.stringify(result)
setNoCacheHeaders = ->
res.setHeader 'Pragma', 'no-cache'
res.setHeader 'Cache-Control', 'no-store, no-cache, must-revalidate'
res.setHeader 'Content-Disposition', 'inline; filename="files.json"'
handler = new UploadHandler req, res, handleResult
console.log 'req.method is '
console.log req.method
switch req.method
when 'OPTIONS' then res.end()
when 'HEAD', 'GET'
if req.url is '/'
setNoCacheHeaders()
if req.method is 'GET'
handler.get()
else
res.end()
else
console.log 'get request for file??'
#console.log req?.path
#fileServer.serve req, res
when 'POST'
setNoCacheHeaders()
handler.post()
when 'DELETE' then handler.destroy()
else
res.statusCode = 405
res.end()
class FileInfo
constructor: (file) ->
@name = file.name
@size = file.size
@type = file.type
@delete_type = 'DELETE'
validate: =>
if options.minFileSize? and options.minFileSize > @size
@error = 'File is too small'
else if options.maxFileSize? and options.maxFileSize < @size
@error = 'File is too big'
else if not options.acceptFileTypes.test(@name)
@error = 'Filetype not allowed'
not @error
safeName: =>
console.log 'X'
#Prevent directory traversal and creating hidden system files:
@name = path.basename(this.name).replace /^\.+/, ''
console.log 'X1'
#Prevent overwriting existing files:
while _existsSync(options.uploadDir + '/' + @name)
@name = @name.replace nameCountRegexp, nameCountFunc
initUrls: (req) =>
if not @error?
console.log 'req.headers.host is ' + req.headers.host
baseUrl = 'https://' + req.headers.host + options.uploadUrl
console.log 'baseurl is ' + baseUrl
@url = @delete_url = baseUrl + encodeURIComponent(@name)
for version, val of options.imageVersions
if _existsSync "#{options.uploadDir}/#{version}/#{@name}"
@[version + '_url'] = baseUrl + version + '/' + encodeURIComponent(@name)
class UploadHandler
constructor: (@req, @res, @callback) ->
get: =>
files = [];
fs.readdir options.uploadDir, (err, list) =>
for name in list
stats = fs.statSync options.uploadDir + '/' + name
if stats.isFile()
fileInfo = new FileInfo { name: name, size: stats.size }
fileInfo.initUrls @req
files.push fileInfo
@callback { files: files }
post: =>
#var handler = this
form = new formidable.IncomingForm()
tmpFiles = []
files = []
map = {}
counter = 1
redirect = null
finish = =>
counter -= 1
if !counter
for fileInfo in files
fileInfo.initUrls @req
@callback { files: files }, redirect
form.uploadDir = options.tmpDir
form.on 'fileBegin', (name, file) =>
if not file?
console.log "Problem: no file!"
console.log name
tmpFiles.push file.path
fileInfo = new FileInfo file, @req, true
fileInfo.safeName()
map[path.basename(file.path)] = fileInfo
files.push fileInfo
form.on 'field', (name, value) =>
if name is 'redirect' then redirect = value
form.on 'file', (name, file) =>
if not file?
console.log "Problem: no file!"
console.log name
fileInfo = map[path.basename(file.path)]
fileInfo.size = file.size;
if not fileInfo.validate()
fs.unlink file.path
return
fs.renameSync file.path, options.uploadDir + '/' + fileInfo.name
if options.imageTypes.test(fileInfo.name)
for version, val of options.imageVersions
counter += 1
opts = options.imageVersions[version]
imageMagick.resize {
width: opts.width
height: opts.height
srcPath: "#{options.uploadDir}/#{fileInfo.name}"
dstPath: "#{options.uploadDir}/#{version}/#{fileInfo.name}"
}, finish
form.on 'aborted', =>
for file in tmpFiles
fs.unlink file
form.on 'error', (e) ->
console.log e
form.on 'progress', (bytesReceived, bytesExpected) =>
if bytesReceived > options.maxPostSize
@req.connection.destroy()
form.on('end', finish).parse @req
destroy: =>
fileName = null
if @req.url.slice(0, options.uploadUrl.length) is options.uploadUrl
fileName = path.basename decodeURIComponent(@req.url)
fs.unlink "#{options.uploadDir}/#{fileName}", (ex) =>
for version, val of options.imageVersions
fs.unlink "#{options.uploadDir}/#{version}/#{fileName}/"
@callback { success: not ex? }
else
@callback { success: false }
exports.serve = serve
|
/* eslint-disable react/jsx-handler-names,react/prop-types */
import React, { Component } from "react";
import { string, bool, func, array, number } from "prop-types";
import { Modal, Button, FormControl} from "react-bootstrap";
import classes from "./Modal.less";
class ModalComponent extends Component {
static propTypes = {
visibility: bool.isRequired,
visibilityChange: func,
modalSave: func,
changeProductDataSaga: func,
productData: array,
totalPrice: number,
incrementProduct: func,
decrementProductBasket: func,
nextBtnClick: func
};
onIncrementBtnClick = (_id) => (event) => {
event.stopPropagation();
this.props.incrementProduct(_id);
}
onDecrementBtnClick = (_id) => (event) => {
event.stopPropagation();
this.props.decrementProductBasket(_id);
}
onDeleteProductBtnClick = (_id) => (event) => {
event.stopPropagation();
this.props.deleteProductBasket(_id);
}
onSaveBtnClick = () => {
this.props.nextBtnClick();
}
closeBtnClick = () => {
this.props.visibilityChange();
}
renderCuurrency = (currency) => {
switch (currency) {
case "ua":
return ('грн');
case "rub":
return ('руб');
case "usd":
return ('$');
}
}
renderSingleProduct = (product) => {
return (
<div className={classes.modalProductWrapper}>
<div className={classes.modalProductLeftBlock}>
<p>{ product.name }</p>
</div>
<div className={classes.modalProductRigthBlock}>
<div className={classes.modalProductButtonWrapper}>
<button className={ product.count === 1 && classes.modalBtnDisable } disabled={ product.count === 1 && true } onClick={this.onDecrementBtnClick(product._id)}> - </button>
<p>{ product.count }</p>
<button onClick={this.onIncrementBtnClick(product._id)}> + </button>
</div>
<div className={classes.modalProductCloseWrapper}>
<p className={classes.modalProductPrice}>{`${product.price} ${this.renderCuurrency(product.currency)}`}</p>
<a onClick={this.onDeleteProductBtnClick(product._id)}>❌</a>
</div>
</div>
</div>
)
}
render() {
const { visibility, productData, totalPrice } = this.props;
return (
<Modal className={classes.modal} show={visibility} onHide={this.closeBtnClick}>
<Modal.Header closeButton className={classes.modalHeader}>
<Modal.Title>Корзина товаров</Modal.Title>
</Modal.Header>
<Modal.Body>
{ productData.map((product) => {return this.renderSingleProduct(product)}) }
</Modal.Body>
<Modal.Footer>
<div className={classes.modalFooter}>
<span className={classes.modalFooterHintText}>Итого: <span className={classes.modalFooterBoltText}>{ totalPrice }</span> руб</span>
</div>
<div className={classes.modalButton}>
<Button onClick={this.closeBtnClick}>Продолжать покупки</Button>
<Button bsStyle="primary" onClick={this.onSaveBtnClick}>Далее</Button>
</div>
</Modal.Footer>
</Modal>
);
}
}
export default ModalComponent;
|
//Register Worker
function registerWorker() {
//If Browser supports serviceWorker
if('serviceWorker' in navigator) {
navigator.serviceWorker.register('worker.js').then( reg => {
reg.pushManager.getSubscription().then( sub => {
if(sub === null) {
subscribeUser();
sendSubscription(sub);
} else
sendSubscription(sub);
});
});
}
}
//Fetch public key from server then subscribe to push notifications
async function subscribefUser() {
let response = await fetch('/api/publicKey');
let responseJson = await response.json();
let publicKey = responseJson.publicKey;
if ('serviceWorker' in navigator) {
navigator.serviceWorker.ready.then( reg => {
reg.pushManager.subscribe({
userVisibleOnly: true,
applicationServerKey: urlBase64ToUint8Array(publicKey)
}).then(sub => console.log('Subscribed', sub));
});
}
}
//Send the Subscription JSON Object to the Backend using POST request
function sendSubscription(sub) {
console.log(JSON.stringify(sub));
fetch('/sendsub', {
method: 'POST',
body: JSON.stringify(sub),
headers: {
'content-type': 'application/json'
}
}).then( res => {
if (!res.ok) throw new Error('Could not send to Server');
return res.json();
}).then(resData => {
if (!resData.data.success) throw new Error('Could not save to db');
});
}
//Helper function to convert datatype of key for transfer through HTTP
function urlBase64ToUint8Array(base64String) {
const padding = '='.repeat((4 - base64String.length % 4) % 4);
const base64 = (base64String + padding)
.replace(/\-/g, '+')
.replace(/_/g, '/');
const rawData = window.atob(base64);
const outputArray = new Uint8Array(rawData.length);
for (let i = 0; i < rawData.length; ++i) {
outputArray[i] = rawData.charCodeAt(i);
}
return outputArray;
}
registerWorker();
|
import WisNav from './src/main';
/* istanbul ignore next */
WisNav.install = function(Vue) {
Vue.component(WisNav.name, WisNav);
};
export default WisNav;
|
/*
* @Description:
* @Author: yamanashi12
* @Date: 2019-05-10 10:18:19
* @LastEditTime: 2021-01-20 16:02:23
* @LastEditors: Please set LastEditors
*/
export default {
schema: {
type: { // 组件类型
type: 'string',
default: 'Quote'
},
quotePageId: 'string'
},
rules: {
quotePageId: [
{ required: true, message: '请输入项目ID', trigger: 'blur' }
]
}
}
|
import loadTypesGenerator from '../generators/constants/load';
const SET_USERS = 'SET_USERS';
export default {
...loadTypesGenerator('users'),
SET_USERS,
}
|
/* eslint-disable */
const commonConfig = require('@modules/eslint');
module.exports = {
...commonConfig,
env: {
'cypress/globals': true
},
extends: [
...commonConfig.extends,
'plugin:cypress/recommended',
],
plugins: [
...commonConfig.plugins,
'cypress',
],
rules: {
...commonConfig.rules,
'prefer-arrow-callback': 'off',
'func-names': 'off',
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.