text stringlengths 7 3.69M |
|---|
import React, { Component } from 'react';
import Icon from './Icon';
class Toolbar extends Component {
render() {
let tableStatus = this.props.tableStatus;
let renderSynced = ()=>{
return (
<button className="button-disabled" disabled={true}>
<span className="slds-icon_container slds-current-color quip-icon" title="Description of icon when needed">
<Icon object="check" type="utility" size="x-small" />
</span>
<span>Synced to Salesforce</span>
</button>
)
}
let renderSave = ()=>{
return (
<button>
<span className="slds-icon_container slds-current-color" title="Description of icon when needed">
<Icon object="sync" type="utility" size="x-small" />
</span>
<span>Save to Salesforce</span>
</button>
)
}
let renderError = ()=>{
return (
<button className="button-disabled">
<span className="slds-icon_container slds-current-color" title="Description of icon when needed">
<Icon object="error" type="utility" size="x-small" />
</span>
<span>Fix Errors to Save</span>
</button>
)
}
let renderSyncState = ()=>{
if(tableStatus === 'sync') {
return renderSynced();
} else if(tableStatus === 'save') {
return renderSave();
} else if(tableStatus === 'error') {
return renderError();
}
}
let renderReset = ()=> {
return (
<button onClick={this.props.resetAll}>Discard All Changes</button>
)
}
return (
<div className="listview-toolbar">
<button className="quip-salesforce-button">
<span className="slds-icon_container slds-current-color" title="Description of icon when needed">
<Icon object="salesforce1" type="utility" size="x-small" />
</span>
<span>Salesforce List View</span>
</button>
{renderSyncState()}
{tableStatus === 'sync' ? '' : renderReset()}
</div>
)
}
}
export default Toolbar;
|
import AppDispatcher from '../dispatcher.jsx'
import ActionTypes from '../constants.jsx'
export default{
receivedGoals(rawGoals){
console.log(3, "Server Actions");
AppDispatcher.dispatch({
actionType: ActionTypes.RECEIVED_GOALS,
rawGoals
})
}
}
|
const books = [
{"title": "Menbrain","author": "Cassandra Navarro","stock": 452},
{"title": "Springbee","author": "Mitzi Cunningham","stock": 202},
{"title": "Viocular","author": "Warner Mcpherson","stock": 714},
{"title": "Cytrek","author": "Araceli Whitfield","stock": 859},
{"title": "Enjola","author": "Greene Richmond","stock": 136},
{"title": "Supportal","author": "Neva Haley","stock": 184},
{"title": "Techade","author": "Kara Roy","stock": 779},
{"title": "Insurity","author": "Justice Blackburn","stock": 596},
{"title": "Lunchpad","author": "Pollard Sosa","stock": 922},
{"title": "Macronaut","author": "York Norris","stock": 818},
{"title": "Concility","author": "Robbins Wolfe","stock": 450},
{"title": "Polarax","author": "Eula Swanson","stock": 313},
{"title": "Neocent","author": "Horton Wiggins","stock": 532},
{"title": "Envire","author": "Castaneda Lloyd","stock": 812},
{"title": "Callflex","author": "Carrillo Bates","stock": 569},
{"title": "Exerta","author": "Becky Copeland","stock": 636},
{"title": "Netplode","author": "Miles Goff","stock": 372},
{"title": "Tetak","author": "Heather Ortega","stock": 297},
{"title": "Techmania","author": "Hutchinson Buckner","stock": 977},
{"title": "Insurety","author": "Esther Frye","stock": 215},
{"title": "Geekfarm","author": "Tamra Farmer","stock": 552},
{"title": "Avenetro","author": "Angeline Hurst","stock": 252},
{"title": "Undertap","author": "Klein Mccall","stock": 551},
{"title": "Biohab","author": "Colon Hines","stock": 382},
{"title": "Orbalix","author": "Courtney Phillips","stock": 907},
{"title": "Applideck","author": "Megan Kane","stock": 828},
{"title": "Eyeris","author": "Margarita Rush","stock": 560},
{"title": "Zyple","author": "Morton Glenn","stock": 989},
{"title": "Gronk","author": "Goldie Carrillo","stock": 899},
{"title": "Zorromop","author": "Joyner Boyer","stock": 206},
{"title": "Tubalum","author": "Milagros Barker","stock": 843},
{"title": "Combogen","author": "Cummings Avila","stock": 908},
{"title": "Letpro","author": "Burnett Duncan","stock": 597},
{"title": "Updat","author": "Elsa Fitzpatrick","stock": 930},
{"title": "Xiix","author": "Gracie Dale","stock": 797},
{"title": "Suremax","author": "Vaughn Dominguez","stock": 333},
{"title": "Gology","author": "Liliana Lewis","stock": 614},
{"title": "Medifax","author": "Mallory Jefferson","stock": 349},
{"title": "Velos","author": "Espinoza Robbins","stock": 945},
{"title": "Quotezart","author": "Ortega Hewitt","stock": 707},
{"title": "Flotonic","author": "Mcpherson Wood","stock": 693},
{"title": "Baluba","author": "Lolita Todd","stock": 431},
{"title": "Iplax","author": "Angie Newton","stock": 711},
{"title": "Sybixtex","author": "Marion Houston","stock": 429},
{"title": "Comstruct","author": "Duke Michael","stock": 859},
{"title": "Codact","author": "Wyatt Parker","stock": 791},
{"title": "Vendblend","author": "Gardner Raymond","stock": 431}
];
/* Mock data from: https://next.json-generator.com/VJakxMaPU */ |
/**
* @file demos/xui-buybucket.js
* @author leeight
*/
import {defineComponent} from 'san';
import {Row, BuyBucket} from 'san-xui';
/* eslint-disable */
const template = `<template>
<x-row label="[default],previous">
<xui-buybucket
previous
datasource="{{buybucket.datasource}}" />
</x-row>
<x-row label="disabled,tip=This is a tip message">
<xui-buybucket
disabled
previous
tip="{{buybucket.tip}}"
datasource="{{buybucket.datasource}}" />
</x-row>
</template>`;
/* eslint-enable */
export default defineComponent({
template,
components: {
'x-row': Row,
'xui-buybucket': BuyBucket
},
initData() {
return {
buybucket: {
tip: '温馨提示：按需计费类型的集群子节点已经售罄，百度云正在积极扩容中，建议您先购买包年包月类型的集群， 或者提<a href="javascript:void(0)">工单</a>申请按需资源，谢谢。',
datasource: [
{title: '地域', content: '华北 - 北京'},
{title: '可用区', content: '可用区A'},
{title: '购买配置', content: 'CPU：1核、内存：1GB、本地磁盘：20GB、公网带宽1Mbps'},
{title: '购买配额', content: '1台 * 1月'},
{title: '购买配额(2)', content: '2台 * 2月', hidden: true},
{title: '配置费用', content: '￥1296.00'}
]
}
};
}
});
|
const flatCache = require("flat-cache")
const path = require('path');
var self = module.exports = {
findBykey: function(req,type,permission,id){
return new Promise(function(resolve, reject) {
req.getConnection(function(err,connection){
connection.query('SELECT value FROM level_permissions WHERE level_id = ? AND name = ? AND type = ?',[id,permission,type],function(err,results,fields)
{
if(err)
resolve(false)
if(results){
let result = JSON.parse(JSON.stringify(results))
if(result && result.length){
resolve(result[0].value)
}else{
resolve(false)
}
}else{
resolve(false)
}
})
})
})
},
findById: function(id,req,res,reset,setData = true){
if(!reset){
reset = reset;
}
return new Promise(function(resolve, reject) {
let cache = flatCache.load("levelPermissions"+id, path.resolve(req.cacheDir));
let key = "__express__levelPermissions"
let cacheContent = cache.getKey(key)
if(cacheContent && cacheContent != "{}" && reset == false){
if(setData)
req.levelPermissions = cacheContent
resolve(cacheContent)
}else{
req.getConnection(function(err,connection){
connection.query('SELECT * FROM level_permissions WHERE level_id = ?',[id],function(err,results,fields)
{
if(err)
reject("")
if(results){
const permissionsArray = {}
Object.keys(results).forEach(function(key) {
let result = JSON.parse(JSON.stringify(results[key]))
permissionsArray[result.type+"."+result.name] = result.value
})
cache.setKey(key, (permissionsArray))
cache.save()
if(setData)
req.levelPermissions = permissionsArray
resolve(permissionsArray)
}else{
resolve("")
}
})
})
}
})
},
getKeyValue:function(req,level_id,getKeyName){
let cache = flatCache.load("levelPermissions"+level_id, path.resolve(req.cacheDir));
let key = "__express__levelPermissions"
let cacheContent = cache.getKey(key)
if(!cacheContent)
return {}
return cacheContent
},
insertUpdate:function(req,res,data,level_id,type){
return new Promise(function(resolve, reject) {
req.getConnection(function(err,connection){
Object.keys(data).forEach(function(key) {
let result = JSON.parse(JSON.stringify(data[key]))
connection.query('INSERT INTO level_permissions SET ? ON DUPLICATE KEY UPDATE value = ?',[{name:key,value:result,level_id:level_id,type:type},result],function(err,results,fields)
{
})
})
self.findById(level_id,req,res,true).then(results => {})
resolve("")
})
})
}
}
|
import React from 'react';
import ReactDOM from 'react-dom';
import ContadorApp from './ContadorApp';
import './index.css';
ReactDOM.render( <ContadorApp contadorProps={10}/>, document.getElementById('root')); |
import { NavLink as Link } from 'react-router-dom';
import { Collapse, Navbar, NavbarToggler, NavbarBrand, Nav, NavItem, NavLink } from 'reactstrap';
import React, { useCallback, useState } from 'react';
const Header = () => {
const [navbarState, setNavbarState] = useState(false);
const toggleNavbar = useCallback(() => {
setNavbarState(!navbarState)
}, [navbarState, setNavbarState]);
return (
<header role="header">
<Navbar color="dark" dark expand="md">
<NavbarBrand tag={Link} to="/">
Test Application
</NavbarBrand>
<NavbarToggler onClick={toggleNavbar} />
<Collapse isOpen={navbarState} navbar>
<Nav navbar>
<NavItem>
<NavLink tag={Link} to="/" exact>Summary</NavLink>
</NavItem>
<NavItem>
<NavLink tag={Link} to="/vendors">Vendors</NavLink>
</NavItem>
<NavItem>
<NavLink tag={Link} to="/customers">Customers</NavLink>
</NavItem>
<NavItem>
<NavLink tag={Link} to="/sales">Sales</NavLink>
</NavItem>
<NavItem>
<NavLink tag={Link} to="/errors">Errors</NavLink>
</NavItem>
</Nav>
</Collapse>
</Navbar>
</header>
);
};
export default Header; |
import React from 'react';
import HomePage from '../features/homepage/HomePage';
export const permalink = '/index.html';
export default function Index({ route }) {
return <HomePage route={route} />;
}
|
class Fallout{
constructor(element, opt){
this.element = element;
this.origins = element.textContent.split('');
this.opt = {
...Fallout.defaults(),
...opt
}
this.init();
}
static defaults(){
return {
gibberish : ["#", "*", "&", "$", "@", "%"],
duration : 1400, // продолжительность анимации
}
}
static randomIndex(array){
return Math.floor(Math.random() * array.length);
}
randomGibberish(){
return this.opt.gibberish[Fallout.randomIndex(this.opt.gibberish)];
}
init(){
this.fakes();
this.start();
}
fakes(){
this.element.textContent = this.origins.map((char) => char = this.randomGibberish()).join('');
}
start(){
this.interval = setInterval(() => this.replace(), this.opt.duration/this.origins.length);
}
stop(){
clearInterval(this.interval);
}
replace(){
const current = this.element.textContent.split('');
const chars = current.map((value, index) => {if (this.opt.gibberish.indexOf(value) > -1) return index;} ).filter((value) => value != undefined );
if (!chars.length) this.stop();
const randomIndex = Fallout.randomIndex(chars);
const randomGibberish = chars[randomIndex];
const realChar = this.origins[randomGibberish];
current[randomGibberish] = realChar;
chars.splice(randomIndex, 1);
for (let i = 0; i < chars.length; i++) current[chars[i]] = this.randomGibberish();
this.element.textContent = current.join("");
}
}
const pipboys = document.querySelectorAll("[data-action=fallout], [data-action=sk]");
if (pipboys.length) Array.prototype.forEach.call(pipboys, (pipboy) => {
const fallouts = pipboy.querySelectorAll(pipboy.dataset.fallout);
if (fallouts.length) Array.prototype.forEach.call(fallouts, (fallout) => new Fallout(fallout) );
});
|
const express = require("express");
const router = express.Router();
const Favourites = require("../models/favourites");
router.route("/addFavourite/:cityName").post((req, res) => {
const newFavourite = new Favourites({ name: req.params.cityName });
newFavourite.save(err => {
if (err) {
return res.send(err.message);
}
Favourites.find()
.then(favourites => {
res.json(favourites);
})
.catch(err => res.send(err.message));
});
});
router.route("/favourites").get((req, res) => {
Favourites.find()
.then(favourites => {
res.json(favourites);
})
.catch(err => {
res.send(err.message);
});
});
module.exports = router;
|
// global datastore
let store = { neighborhoods: [], meals: [], customers: [], deliveries: [] };
let neighborhoodIds = 0
let mealIds = 0
let customerIds = 0
let delveryIds = 0
class Neighborhood {
constructor(name){
this.name = name;
this.id = neighborhoodIds++;
store.neighborhoods.push(this)
}
customers() {
return store.customers.filter(customer => {
return customer.neighborhoodIds === this.neighborhoodIds
})
}
deliveries() {
return store.deliveries.filter(neighborhood =>{
return neighborhood.neighborhoodId === this.id
})
}
// deliveries() - returns a list of all deliveries placed in a neighborhood
// customers() - returns all of the customers that live in a particular neighborhood
// items(){
// return store.items.filter(item => {
// return item.userId === this.id
// }
// }
meals(){
return store.meals.filter(meal =>{
return meal.customers().filter(customer =>{
return customer.neighborhoodId === this.id
})
})
}
// returns a unique list of meals orderd in a neighborhood
}
class Customer {
constructor(name, neighborhoodId){
this.name = name;
this.neighborhoodId = neighborhoodId;
this.id = customerIds++;
store.customers.push(this)
}
deliveries(){
return store.deliveries.filter(item => {
return item.customerId === this.id;
})
}
// deliveries() — returns all of the deliveries that customer has received
meals(){
return this.deliveries().map(delivery => {
return delivery.meal();
})
}
// meals() - returns all meals that a customer has ordered
totalSpent(){
return this.meals().reduce((total,item) => (total += item.price),0)
}
// totalSpent() - returns the total amount that the customer has spent on food.
}
class Meal {
constructor(title, price){
this.price = price;
this.title = title;
this.id = mealIds++;
store.meals.push(this)
}
deliveries(){
return store.deliveries.filter(item =>{
return item.mealId === this.id;
})
}
// customers() - returns all of the customers who have had the meal delivered.
// Be careful not to return the same customer twice if they have ordered this meal multiple times.
customers(){
const allCustomers = this.deliveries().map(delivery => delivery.customer());
return [...new Set(allCustomers)];
}
static byPrice(){
return store.meals.sort((x,y) => x.price < y.price);
}
// const sampleValues = [1, 4, 5, 2, 'a', 'e', 'b', 'e', 2, 2, 4];
// const uniqueValues = [...new Set(sampleValues)];
// console.log(uniqueValues); //[1, 4, 5, 2, "a", "e", "b"]
// deliveries() - returns all of the deliveries associated with a particular meal.
}
class Delivery {
constructor(mealId, neighborhoodId, customerId){
this.mealId = mealId;
this.neighborhoodId = neighborhoodId;
this.customerId = customerId;
this.id = delveryIds++;
store.deliveries.push(this)
}
neighborhood() {
return store.neighborhoods.find(item => {
return item.id === this.neighborhoodId
})
}
// neighborhood() - returns the neighborhood associated with a particular delivery
customer() {
return store.customers.find(item => {
return this.customerId === item.id;
})
}
meal(){
return store.meals.find(meal => {
return meal.id === this.mealId;
})
}
}
|
'use strict'
/*
|--------------------------------------------------------------------------
| ThreadSeeder
|--------------------------------------------------------------------------
|
| Make use of the Factory instance to seed database with dummy data or
| make use of Lucid models directly.
|
*/
/** @type {import('@adonisjs/lucid/src/Factory')} */
const Factory = use('Factory')
const Database = use('Database')
const Thread = use('App/Models/Thread')
class ThreadSeeder {
async run() {
for (let i = 0; i < 100; i++) {
const thread = new Thread()
thread.user_id = 1
thread.title = i
thread.content = i
await thread.save()
}
}
}
module.exports = ThreadSeeder |
/*
Copyright 2019 Adobe. All rights reserved.
This file is licensed to you 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 REPRESENTATIONS
OF ANY KIND, either express or implied. See the License for the specific language
governing permissions and limitations under the License.
*/
const mockScripts = {
listeners: null,
buildUI: jest.fn(() => mockWithCallbacks()),
buildActions: jest.fn(() => mockWithCallbacks()),
deployUI: jest.fn(() => mockWithCallbacks()),
deployActions: jest.fn(() => mockWithCallbacks()),
undeployUI: jest.fn(() => mockWithCallbacks()),
undeployActions: jest.fn(() => mockWithCallbacks()),
runDev: jest.fn(() => mockWithCallbacks()),
addAuth: jest.fn(() => mockWithCallbacks())
}
const mockWithCallbacks = () => {
const lnr = mockScripts.listeners
if (lnr.onStart) {
lnr.onStart('run:start')
}
if (lnr.onProgress) {
lnr.onProgress('gettin stuff done')
}
if (lnr.onWarning) {
lnr.onWarning('you have been warned')
}
if (lnr.onEnd) {
lnr.onEnd('run:end')
}
}
module.exports = (arg) => {
arg = arg || { listeners: null }
mockScripts.listeners = arg.listeners
return mockScripts
}
|
const got = require('got')
const cheerio = require('cheerio')
class Crawler {
constructor (req) {
this.req = req
}
async findPhone () {
const response = await got(`http://${this.req.params.url}`)
const result = response.body
const $ = cheerio.load(result)
const teste = $('body').text()
const phone = teste.match(/(\(?\d{2,3}?\)?)?\s?\d{4,5}-?\d{4}/g)
return phone
}
async findAddress () {
try {
const keys = [{ key: 'Rua' }, { key: 'Av.' }, { key: 'Av ' }, { key: 'Rod' }, { key: 'Bairro' }]
const response = await got(`http://${this.req.params.url}`)
const result = response.body
const stringAddress = result.split('>')
const address = []
for (const item of keys) {
const { key } = item
for (const item of stringAddress) {
if (item.includes(key) || item.match(/[0-9]{5}-[0-9]{3}/g)) {
const element = item.replace(/(<.*)/g, '').trim()
address.push(element)
}
}
}
return address
} catch (error) {
return error
}
}
async get () {
const data = {
url: this.req.params.url,
phones: await this.findPhone(),
address: await this.findAddress()
}
return data
}
}
module.exports = Crawler
|
import React, { useRef, useState } from "react";
import SimpleReactValidator from "simple-react-validator";
import { useDispatch, useSelector } from "react-redux";
import { loginAction } from "./../redux/Actions/loginAction";
import MessageBox from "../components/MessageBox";
const LoginScreen = (props) => {
const [username, setUsername] = useState();
const [password, setPassword] = useState();
const [, forceUpdate] = useState();
const dispatch = useDispatch();
const { error } = useSelector((state) => state.login);
const validator = useRef(
new SimpleReactValidator({
messages: {
required: "پر کردن این فیلد الزامی است",
},
element: (messages) => (
<div style={{ color: "red", direction: "rtl" }}>{messages}</div>
),
})
);
const submitHandler = async (e) => {
e.preventDefault();
try {
if (validator.current.allValid()) {
dispatch(loginAction(username, password));
} else {
validator.current.showMessages();
forceUpdate(1);
}
} catch (err) {
console.log(err.message.response);
}
};
return (
<>
{error ? (
<div className='d-flex justify-content-center' >
<MessageBox variant="danger">{error.message}</MessageBox>
</div>
) : null}
<div className="d-flex justify-content-center">
<form className="form" onSubmit={(e) => submitHandler(e)}>
<div >
<h1 style={{marginLeft:"108px"}}>صفحه ورود</h1>
</div>
<div>
<label className="d-rtl" htmlFor="username">
نام کاربری:
</label>
<br />
<input
placeholder="نام کاربری خود را وارد کنید"
className="login--input"
type="text"
id="name"
name="username"
value={username}
onChange={(e) => {
setUsername(e.target.value);
validator.current.showMessageFor("username");
}}
></input>
{validator.current.message("username", username, "required")}
</div>
<div>
<label className="d-rtl" htmlFor="password">
پسورد:
</label>
<br />
<input
className="login--input"
type="password"
id="password"
placeholder="پسورد خود را وارد کنید"
name="password"
value={password}
onChange={(e) => {
setPassword(e.target.value);
validator.current.showMessageFor("password");
}}
></input>
{validator.current.message("password", password, "required")}
</div>
<div>
<label />
<button
style={{ marginLeft: "40px" }}
className=" primary d-rtl"
type="submit"
>
ورود
</button>
</div>
</form>
</div>
</>
);
};
export default LoginScreen;
|
var Bermuda,
__bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
__slice = [].slice;
Bermuda = (function() {
var DEFAULT_SETTINGS, isEmpty, merge, removePolygon, toLatLngs;
DEFAULT_SETTINGS = {
disabled: false,
autoCentered: true,
marker: {},
polygon: {},
icon: {},
map: {},
onChange: function(coords) {}
};
Bermuda.prototype.markers = [];
Bermuda.prototype.polygon = null;
Bermuda.prototype.icon = null;
function Bermuda(elem, config) {
this.elem = elem;
if (config == null) {
config = {};
}
this.redrawPolygon = __bind(this.redrawPolygon, this);
this.settings = merge(DEFAULT_SETTINGS, config);
this.initMap();
this.initIcon();
}
merge = function() {
var dest, key, obj, objs, value, _i, _len;
objs = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
dest = {};
for (_i = 0, _len = objs.length; _i < _len; _i++) {
obj = objs[_i];
for (key in obj) {
value = obj[key];
dest[key] = value;
}
}
return dest;
};
Bermuda.prototype.initMap = function() {
return this.map = new google.maps.Map(this.elem, this.settings.map);
};
Bermuda.prototype.initIcon = function() {
var size;
if (isEmpty(this.settings.icon)) {
return;
}
size = new google.maps.Size(this.settings.icon.width, this.settings.icon.height);
return this.icon = new google.maps.MarkerImage(this.settings.icon.image, null, null, null, size);
};
isEmpty = function(object) {
var property;
for (property in object) {
if (object.hasOwnProperty(property)) {
return false;
}
}
return true;
};
Bermuda.prototype.clear = function() {
this.removeMarkers();
if (this.polygon) {
return removePolygon(this.polygon);
}
};
Bermuda.prototype.removeMarkers = function() {
this.detachMarkers();
return this.markers = [];
};
Bermuda.prototype.detachMarkers = function() {
var marker, _i, _len, _ref, _results;
_ref = this.markers;
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
marker = _ref[_i];
_results.push(marker.setMap(null));
}
return _results;
};
Bermuda.prototype.disable = function() {
this.detachMarkers();
return this.settings.disabled = true;
};
Bermuda.prototype.enable = function() {
var marker, _i, _len, _ref;
_ref = this.markers;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
marker = _ref[_i];
marker.setMap(this.map);
}
return this.settings.disabled = false;
};
Bermuda.prototype.draw = function(coords) {
this.clear();
this.initMarkers(coords);
return this.initPolygon();
};
Bermuda.prototype.initMarkers = function(coords) {
var latLng, _i, _len, _ref;
_ref = toLatLngs(coords);
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
latLng = _ref[_i];
this.markers.push(this.createMarker(latLng));
}
this.listen("dragend", (function(_this) {
return function() {
return _this.settings.onChange(_this.getCoords());
};
})(this));
if (this.settings.autoCentered) {
return this.autoCenter();
}
};
toLatLngs = function(coords) {
var coord, _i, _len, _results;
_results = [];
for (_i = 0, _len = coords.length; _i < _len; _i++) {
coord = coords[_i];
_results.push(new google.maps.LatLng(coord[0], coord[1]));
}
return _results;
};
Bermuda.prototype.createMarker = function(latLng) {
var marker;
marker = new google.maps.Marker(merge(this.settings.marker, {
position: latLng,
draggable: true,
icon: this.icon
}));
if (!this.settings.disabled) {
marker.setMap(this.map);
}
return marker;
};
Bermuda.prototype.autoCenter = function() {
var bounds, position, _i, _len, _ref;
bounds = new google.maps.LatLngBounds();
_ref = this.getPositions();
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
position = _ref[_i];
bounds.extend(position);
}
return this.map.fitBounds(bounds);
};
Bermuda.prototype.listen = function(event, callback) {
var marker, _i, _len, _ref, _results;
_ref = this.markers;
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
marker = _ref[_i];
_results.push(google.maps.event.addListener(marker, event, callback));
}
return _results;
};
Bermuda.prototype.initPolygon = function() {
this.drawPolygon();
return this.listen("drag", this.redrawPolygon);
};
Bermuda.prototype.redrawPolygon = function() {
var prevPolygon;
prevPolygon = this.polygon;
this.drawPolygon();
return removePolygon(prevPolygon);
};
Bermuda.prototype.getPositions = function() {
var marker, _i, _len, _ref, _results;
_ref = this.markers;
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
marker = _ref[_i];
_results.push(marker.position);
}
return _results;
};
Bermuda.prototype.getCoords = function() {
var marker, _i, _len, _ref, _results;
_ref = this.markers;
_results = [];
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
marker = _ref[_i];
_results.push([marker.position.lat(), marker.position.lng()]);
}
return _results;
};
removePolygon = function(polygon) {
return polygon.setMap(null);
};
Bermuda.prototype.drawPolygon = function() {
return this.polygon = new google.maps.Polygon(merge(this.settings.polygon, {
map: this.map,
paths: this.getPositions(),
draggable: false,
geodesic: true
}));
};
Bermuda.prototype.zoomIn = function() {
return this.map.setZoom(this.map.zoom + 1);
};
Bermuda.prototype.zoomOut = function() {
return this.map.setZoom(this.map.zoom - 1);
};
return Bermuda;
})();
|
import React from 'react';
import { shallow } from 'enzyme';
import { App } from './App';
const setupWrapper = (initialState = {}) => {
const wrapper = shallow(<App {...initialState} />);
return wrapper;
}
describe("redux props", () => {
test("has success piece of state as prop", () => {
const success = true;
const wrapper = setupWrapper({ success });
const successProp = wrapper.instance().props.success;
expect(successProp).toBe(success);
});
test("has access to secretWord state", () => {
const secretWord = 'party';
const wrapper = setupWrapper({ secretWord });
const secretWordProp = wrapper.instance().props.secretWord;
expect(secretWordProp).toBe(secretWord);
});
test("has access to guessWords state", () => {
const guessedWords = [{ guessedWord: 'train', letterMatchCount: 3 }];
const wrapper = setupWrapper({ guessedWords });
const guessedWordsProp = wrapper.instance().props.guessedWords;
expect(guessedWordsProp).toBe(guessedWords);
});
});
test("guetSecretWord run on App mount", () => {
const getSecretWordMock = jest.fn();
const props = {
getSecretWord: getSecretWordMock,
success: false,
guessedWords: []
}
const wrapper = shallow(<App {...props} />);
wrapper.instance().componentDidMount();
const getSecretWordMockCount = getSecretWordMock.mock.calls.length;
expect(getSecretWordMockCount).toBe(1);
}); |
(function (root, factory) {
// for asynchronous module definition
if (typeof define === 'function' && define.amd) {
define(function () {
return factory;
});
}
// for commonjs
else if (typeof exports !== 'undefined') {
module.exports = factory
}
// for browser
else {
root.overl8d = factory;
}
}(this, function overl8d() {
// stores function groups like [[String, Number], function...],[[], function...]
var groups = [];
// temp array, just stores types to the anonymous function.
var types = [];
// for every argument
for (var p in arguments) {
// check is this argument is callback or not?
if (arguments[p].name.length == 0) {
// if it is callback then push new array that holds types and callback.
groups.push([types, arguments[p]]);
// create new array and store address in types
types = [];
// continue to next argument
continue;
}
// if it isn't callback then it should be a type. ok please add to types array
types.push(arguments[p]);
}
var temp = function () {
var next, p, i;
// for every group in groups
for (p in groups) {
next = false;
var temp = groups[p][0];
// if argument count is same as group argument count
if (arguments.length === temp.length) {
// if argument count is not zero
if (temp.length != 0) {
for (i in temp) {
// check every type in given parameter
if (arguments[i].constructor != temp[i]) {
// if some type is not same as group's types then continue to next group
next = true;
break;
}
}
}
} else {
// argument count is not same as the group, it's impossible to be same..
next = true;
}
// if groups is matches with argument then call function.
if (next == false) {
return groups[p][1].apply(this, arguments);
}
}
// if no arguments matches with group then throw new error :(
throw new Error("Invalid function parameters");
};
// you can get groups with this function. This function acts like reflection. You can change options runtime
temp.getGroups = function () {
return groups;
};
// return the prepared function.
return temp;
}));
|
const router = require('koa-router')()
const db = require('../data')
const fs = require('fs')
const {resolve} = require('path')
const {
users,
} = require('../secret.json')
const {
isValidString,
generateId,
getExt,
RESUME_ID,
validateParams,
} = require('../utils')
const api = require('../api')
const processArticleDoc = article => {
return {
...article,
likedCount: article.likedBy.length,
commentCount: article.comments.length,
likedBy: undefined,
comments: undefined,
}
}
router
// 写指定笔记
.post(api.SAVE_ARTICLE, async function(ctx) {
// - 普通笔记入库 简历使用文件服务, 用特殊 id 区分
const params = ctx.request.body
// 在非编辑简历时校验
// nedb 没有 schema, 手动验证
if (params.articleId !== RESUME_ID) {
const errorMessage = validateParams(params, {
articleId: 'string',
title: /^.{2,40}$/,
tagsText: /^(\s*#[^#]+){1,3}\s*$/,
dateString: /^\d{4}-\d{2}-\d{2}$/,
markdownContent: /\S+/,
})
if (isValidString(errorMessage)) {
ctx.throw(400, errorMessage)
return
}
}
if (params.articleId === '') {
params.articleId = generateId()
params.likedBy = []
params.comments = []
}
let result
if (params.articleId === RESUME_ID) {
fs.writeFileSync(
resolve(__dirname, '../data/resume.md'),
params.markdownContent,
'utf8'
)
result = {
articleId: RESUME_ID
}
} else {
result = await db.saveArticle(params)
}
ctx.body ={
articleId: result.articleId
}
})
// 读指定笔记
.get(api.GET_ARTICLE_DETAIL, async function(ctx) {
let article
if (ctx.query.id === RESUME_ID) {
article = {
markdownContent: fs.readFileSync(
resolve(__dirname, '../data/resume.md'),
'utf8'
),
title: '简历',
dateString: '',
tagsText: '',
likedCount: 0,
commentCount: 0,
}
} else {
article = await db.getArticle(ctx.query.id)
if (!article) {
ctx.throw(404, '未找到目标笔记')
return
}
article = processArticleDoc(article)
}
ctx.body = {
article
}
})
// 读全部笔记
.get(api.GET_ARTICLES, async function(ctx) {
const {tag = ''} = ctx.request.query
const articles = await db.getArticles(decodeURI(tag))
ctx.body = {
articles: articles.map(item => processArticleDoc(item))
}
})
// 删除笔记
.post(api.DELETE_ARTICLE, async function(ctx) {
const {id} = ctx.request.body
if (id === RESUME_ID) {
ctx.throw(400, '简历可别删除呀')
return
}
await db.deleteArticle(id)
ctx.body = {}
})
// 写图片
.post(api.UPLOAD_FILE, async function(ctx) {
let {articleId} = ctx.request.body
const file = ctx.request.files.file
if (file) {
if (!isValidString(articleId)) {
articleId = 'TEMP'
}
if (file.size > 1024 ** 3) {
ctx.throw(400, '请使用 1M 以下的图片')
return
}
const ext = getExt(file.name)
if (!/^\.(svg|png|gif|jpe?g|bmp)$/.test(ext)) {
ctx.throw(400, '只能上传图片文件')
return
}
const fileName = `${articleId}_${generateId()}${ext}`
fs.writeFileSync(
resolve(__dirname, '../files/', fileName),
fs.readFileSync(file.path)
)
ctx.body = {
fileName
}
}
})
// 读文件
.get('/files/:filename', async function(ctx) {
const filePath = ctx.request.url
ctx.cacheControl = {
maxAge: 60 * 60 * 24 * 30
}
ctx.type = getExt(filePath)
ctx.body = fs.createReadStream(resolve(__dirname, `../${filePath}`))
})
// 读 github 仓库
.get(api.GET_REPOS, async function(ctx) {
const repos = await db.getGithubRepos()
ctx.body = {
repos: JSON.parse(repos)
}
})
// 读站点访问次数
.get(api.VISIT_COUNT, async function (ctx) {
const visitCount = await db.getVisitCount()
ctx.body = {
visitCount
}
})
// 登录
.post(api.LOGIN, async function (ctx) {
const {
username,
password,
} = ctx.request.body
if (!isValidString(username) || !isValidString(password)) {
ctx.throw(400, '输入用户名和密码')
return
}
const user = users.find(item => item.username === username)
if (!user || user.password !== password) {
ctx.throw(401, '用户名或密码错误')
return
}
console.log(`已登录: ${username}`)
ctx.cookies.set('username', username, {
signed: true,
httpOnly: true,
overWrite: true,
})
ctx.body = {
message: '登录成功'
}
})
// 登出
.post(api.LOGOUT, async function (ctx) {
ctx.cookies.set('username', null, {
signed: true,
httpOnly: true,
overWrite: true,
})
ctx.body = {
message: '已登出'
}
})
// 点赞/取消
.post(api.TOGGLE_LIKE_ARTICLE, async function(ctx) {
const {articleId} = ctx.request.body
const clientIp = ctx.request.ip
try {
const message = await db.toggleLikeArticle({
articleId,
clientIp,
})
ctx.body = {
message
}
} catch (e) {
ctx.throw(403, e)
}
})
// 发布评论
.post(api.SAVE_COMMENT, async function(ctx) {
const params = ctx.request.body
const errorMessage = validateParams(params, {
articleId: 'string',
commentAuthor: /^\S{2,16}$/,
commentEmail: /^\w+@\w+\.\w+$/,
commentContent: /^.{2,120}$/,
})
if (isValidString(errorMessage)) {
// 翻译一下
ctx.throw(400, '请检查输入')
return
}
params.createDate = new Date().valueOf()
params.clientIp = ctx.request.ip
params.commentId = generateId()
await db.saveComment(params)
ctx.body = {}
})
// 获取评论
.get(api.GET_COMMENTS, async function(ctx) {
const {articleId} = ctx.request.query
const comments = await db.getComments(articleId)
ctx.body = {
comments: comments.map(item => ({
...item,
commentEmail: undefined,
clientIp: undefined,
}))
}
})
// 删除评论
.post(api.DELETE_COMMENT, async function(ctx) {
const params = ctx.request.body
await db.deleteComment(params)
ctx.body = {}
})
// 获取所有访客
.get(api.GET_VISITORS, async function(ctx) {
const visitors = await db.getVisitors()
ctx.body = {
visitors
}
})
module.exports = router.routes() |
import { getMarvelUrl } from "../downloaders/marvel/marvel";
export const MISERABLES = "miserables";
export const sources = [
{
label: "Les Miserables",
id: "Les Miserables",
url: MISERABLES,
readonly: true,
episodesPath: "--",
episodeCharactersPath: "--",
episodeCategoryPath: "--",
},
{
label: "Marvel",
id: "Marvel",
url: getMarvelUrl(),
readonly: true,
episodesPath: "data.data.results",
episodeCharactersPath: "characters.items[*].name",
episodeCategoryPath: "id",
},
{
label: "Game of Thrones",
id: "Game of Thrones",
url: "https://api.got.show/api/show/events",
readonly: true,
episodesPath: "data",
episodeCharactersPath: "participants",
episodeCategoryPath: "_id",
},
{
label: "Custom",
id: "Custom",
url: "https://www.breakingbadapi.com/api/episodes",
readonly: false,
episodesPath: "data",
episodeCharactersPath: "characters",
episodeCategoryPath: "series",
},
];
|
import React, { Component } from 'react'
import axios from 'axios'
import { connect } from 'react-redux'
import { Row, Col, Card, Button, Table, message, Modal } from 'antd'
import DropOption from '@/components/DropOption'
import SearchBox from './SearchBox'
import AddForm from './AddForm'
import { paginat } from '@/utils/pagination'
import { setKey } from '@/utils/setkey'
//每页请求条数
const defaultPageSize = 10;
class Category extends Component {
state = {
loading: true, //表格是否加载中
data: [],
total: 0, //总数
current: 1, //当前页数
pageSize: 10, //每页数量
visible: false,
selectedRowKeys: [], //当前有哪些行被选中, 这里只保存key
selectedRows: [], //选中行的具体信息
item: {},
isAddModal: true,
first: '',
second: '',
category: [],
searchParams: undefined, //查询参数
}
componentDidMount() {
this.getPageList()
}
/**
*
* @param {Number} limit 每页条数默认10条
* @param {Number} offset 第几页，如果当前页数超过可分页的最后一页按最后一页算默认第1页
* @param {String} name 通道名称
*/
getPageList(limit = this.state.pageSize, offset = this.state.current, name) {
if (!this.state.loading) {
this.setState({ loading: true })
}
axios.get('/back/industry/industrys', {
params: {
limit,
offset,
name,
}
}).then(({ data }) => {
setKey(data)
this.setState({
data: data,
loading: false,
})
}).catch(err => console.log(err))
}
//增加按钮
addHandle = () => {
this.setState({
item: {},
isAddModal: true,
visible: true
})
// this.selectDetail()
}
/**
* 点击删除按钮, 弹出一个确认对话框
* 注意区分单条删除和批量删除
* @param e
*/
onClickDelete = (e) => {
e.preventDefault();
Modal.confirm({
title: '确认删除?',
onOk: () => {
const id = this.state.selectedRows[0].id
axios.delete(`/back/industry/remove/${id}`).then(res => res.data).then(res => {
if (res.rel) {
message.success('删除成功')
this.getPageList()
} else {
message.error(res.msg)
}
})
}
});
}
/**
* 发送http请求，删除数据，更新表格 未使用
* @param keys:Array 选中行的key
*/
handleDelete(keys = this.state.selectedRowKeys) {
let data = this.state.data.slice()
for (let i = 0, len = data.length; i < len; i++) {
for (let j = 0; j < keys.length; j++) {
if (data[i] && data[i].key === keys[j]) {
data.splice(i, 1);
i--;
}
}
}
this.setState({
data: data,
selectedRowKeys: []
})
}
/**
* 模态框提交按钮--增加
* @param values
*/
handleOk = (e) => {
this.form.validateFields((err, values) => {
if (err) {
return
}
values.pid = values.pid && values.pid[values.pid.length - 1]
if (this.state.isAddModal) {
axios.post('/back/industry/industry', values)
.then(({ data }) => {
if (data.rel) {
message.success('添加成功！')
//重新获取一遍数据
this.getPageList();
}
})
} else {
const id = this.state.item.id
axios.put(`/back/industry/${id}`, values).then(res => res.data).then(res => {
if (res.rel) {
this.getPageList();
} else {
message.error(res.msg)
}
})
}
//这里无论提交成功失败，都要关闭模态框，清空表单内容
this.setState({
visible: false,
});
// 清空表单
this.form.resetFields()
})
}
/**
* 模态框取消按钮
*/
handleCancel = () => {
this.setState({
visible: false,
});
this.form.resetFields();
}
/**
* 处理表格的选择事件
*
* @param selectedRowKeys
*/
onTableSelectChange = (selectedRowKeys, selectedRows) => {
console.log(selectedRows)
this.setState({ selectedRowKeys, selectedRows });
};
/**
* 下拉按钮组件
*/
handleMenuClick = (record, e) => {
if (e.key === '1') {
//修改按钮
this.setState({
item: record,
isAddModal: false,
visible: true,
})
this.selectDetail(record.id, record.passwayId)
} else if (e.key === '2') {
//删除按钮
Modal.confirm({
title: '确认删除?',
onOk: () => {
axios.delete(`/back/industry/remove/${record.id}`).then(res => res.data).then(res => {
if (res.rel) {
message.success('删除成功')
this.getPageList()
} else {
message.error(res.msg)
}
})
}
})
}
}
/**
* 页码改变的回调，参数是改变后的页码及每页条数
* @param page 改变后的页码
* @param pageSize 改变页的条数
*/
pageChange = (page, pageSize) => {
this.setState({
pageSize: pageSize,
current: page
})
this.getPageList(pageSize, page, this.state.searchParams)
}
/**
* pageSize 变化的回调
* @param current 当前页码
* @param pageSize 改变后每页条数
*/
onShowSizeChange = (current, pageSize) => {
this.setState({
pageSize: pageSize,
current: current
})
this.getPageList(pageSize, current, this.state.searchParams)
}
/**
* 查询功能
* @param values
*/
search = (values) => {
console.log(values.industryName)
this.setState({
searchParams: values.industryName
})
this.getPageList(this.state.pageSize, 1, values.industryName)
}
/**
* 获取上级行业
* @param {*} id 当前行id
* @param {String} passwayId 通道id
*/
selectDetail(id, passwayId) {
axios.get('/back/industry/industrys', { params: { id, passwayId } })
.then(res => res.data)
.then(res => {
function d(s) {
s.forEach(item => {
item.value = item.id
item.label = item.industryName
// item.disable = true
if (item.children) {
d(item.children)
}
})
}
d(res)
setKey(res)
this.setState({
category: res
})
})
}
render() {
const rowSelection = {
type: 'radio',
selectedRowKeys: this.state.selectedRowKeys,
onChange: this.onTableSelectChange,
};
const hasSelected = this.state.selectedRowKeys.length > 0; // 是否选择
const multiSelected = this.state.selectedRowKeys.length > 1; // 是否选择了多项
const pagination = paginat(this, (pageSize, current, searchParams) => {
this.getPageList(pageSize, current, searchParams)
})
//表格表头信息
const columns = [
{
title: "行业名称",
dataIndex: "industryName",
}, {
title: "通道",
dataIndex: "passwayName",
}, {
title: "上级行业",
dataIndex: "parentName",
},
// {
// title: "费率",
// dataIndex: "rate",
// },
// {
// title: "结算周期T+",
// dataIndex: "cycle",
// },
// {
// title: "创建人",
// dadaIndex: "creatorId",
// },
{
title: "创建时间",
dataIndex: "createTime",
},
// {
// title: "修改人",
// dataIndex: "lastEditorid",
// },
{
title: "修改时间",
dataIndex: "lastEdittime",
}, {
title: "操作",
render: (text, record) => (
<DropOption
onMenuClick={(e) => this.handleMenuClick(record, e)}
menuOptions={[{ key: '1', name: '修改' }, { key: '2', name: '删除' }]}
/>
)
}
]
return (
<div className="foundation-category">
<div>
<Card
bordered={false}
bodyStyle={{ backgroundColor: "#f8f8f8", marginRight: 32 }}
noHovering
>
<SearchBox loading={this.state.loading} search={this.search} />
</Card>
<Card bordered={false} noHovering bodyStyle={{ paddingLeft: 0 }}>
<Row gutter={40} style={{ marginBottom: 20 }}>
<Col span={24} style={{ marginLeft: 14 }}>
<Button
className="btn-add"
size="large"
shape="circle"
type="primary"
icon="plus"
onClick={this.addHandle}
/>
<Button
className="btn-delete"
type="primary"
size="large"
shape="circle"
icon="delete"
disabled={!hasSelected}
onClick={this.onClickDelete}
/>
<Modal
onOk={this.handleOk}
title={this.state.isAddModal ? "新增-行业类目" : "修改-行业类目"}
okText="提交"
width="50%"
wrapClassName="vertical-center-modal"
visible={this.state.visible}
onCancel={this.handleCancel}
isAddModal={this.state.isAddModal}
>
<AddForm
ref={e => this.form = e}
item={this.state.item || {}}
category={this.state.category}
selectDetail={(undefined, value) => this.selectDetail(undefined, value)}
/>
</Modal>
</Col>
</Row>
<Row>
<Col>
<Table
// scroll={{ x: 944 }}
loading={this.state.loading}
columns={columns}
dataSource={this.state.data}
rowSelection={rowSelection}
pagination={pagination}
/>
</Col>
</Row>
</Card>
</div>
</div >
)
}
}
const mapStateToProps = (state) => {
return {
category: state.category
}
}
const mapDispatchToProps = (dispatch) => {
return dispatch => {
axios.get('/back/industry/industrys').then(({ data }) => {
dispatch({
type: 'GET_CATEGORY_LIST',
data: data
})
})
}
}
export default connect(
// mapStateToProps,
// mapDispatchToProps
)(Category)
|
export default {
namespaced: true,
state: {
products: []
},
getters: {
inCart: (state) => (id) => state.products.some((el) => el.id === id),
total(){
//hw
}
},
mutations: {
add(state, id){
state.products.push({
id
});
},
remove(state, id){
let index = state.products.findIndex((el) => el.id === id);
state.products.splice(index, 1);
}
},
actions: {
add(store, id){
return new Promise(function(resolve, reject){
if(!store.getters.inCart(id)){
store.commit('add', id);
resolve();
}
// reject
});
},
remove(store, id){
return new Promise(function(resolve, reject){
if(store.getters.inCart(id)){
store.commit('remove', id);
resolve();
}
// reject
});
}
}
} |
import {Value} from 'slate';
import {getQuestionById} from '../../../services/questions/question-service';
import { getTestSeriseById } from '../../../services/exam-test';
import { getAllCourses, getCourseById } from '../../../services/ref-data/course';
import { getChaptersBySubject } from '../../../services/ref-data/chapter';
import { getAllSubjects, getSubjectByCourse } from '../../../services/ref-data/subject';
export let loadData =(props,component)=>{
getAllCourses().then((data)=>{
// component.setState({courses:data.courses});
}).catch(error =>{
component.setState({isError:true,message:error.message});
});
getAllSubjects()
.then(data =>{
// component.setState({subjects:data.subjects});
}).catch(error =>{
component.setState({isError:true,message:error.message});
});
if(props.testId){
getTestSeriseById(props.testId)
.then(testData =>{
if(testData.test.instructions){
testData.test.instructions = Value.fromJSON(JSON.parse(testData.test.instructions));
}
component.setState({isError:false,
test:testData.test,
});
if(testData.test.courseId){
getSubjectByCourse(testData.test.courseId)
.then(subjectData =>{
// component.setState({isError:false,
//subjects:subjectData.subjects
//});
})
.catch(error =>{
component.setState({message:'', isError:false,test:testData.test});
});
component.setState({test:testData.test,message:'', isError:false});
}
if(testData.test.subjectId){
getChaptersBySubject(testData.test.subjectId)
.then(chapterData =>{
/* component.setState({isError:false,
chapters:chapterData.chapters
}); */
})
.catch(error =>{
component.setState({message:'', isError:false,test:testData.test});
});
component.setState({test:testData.test,message:'', isError:false});
}
}
)
.catch(error =>{
component.setState({isError:true,message:error.message});
});
}else{
component.setState({isError:false,message:''});
}
};
export let loadAllSubjects = (fieldName,fieldValue,component)=>{
getCourseById(fieldValue).then(courseData =>{
getSubjectByCourse(courseData.course.id).then((data)=>{
component.setState({
inProgress:true,
isError:false,
test:{...component.state.test,
[fieldName]:fieldValue,
subjectId:'',
chapterId:'',
},
subjects:data.subjects,});
}).catch(data =>{
component.setState({
inProgress:true,
isError:true,
test:{...component.state.test,
[fieldName]:fieldValue,
subjectId:'',
chapterId:'',
},
subjects:[],});
});
}).catch(error =>{
component.setState({isError:true, message:error.message});
});
};
export let loadChapters=(fieldName,fieldValue,component)=>{
getChaptersBySubject(fieldValue).then((data)=>{
component.setState({
inProgress:true,
test:{...component.state.test,
[fieldName]:fieldValue,
chapter:'',
},
chapters:data.chapters
});
}).catch(data =>{
component.setState({
inProgress:true,
test:{...component.state.test,
[fieldName]:fieldValue,
chapter:'',
},
chapters:[]
});
});
};
export let loadQuestion=(props,component)=>{
getQuestionById(props.id).then(data =>{
component.setState({question:data.question});
});
}; |
const { body } = require('express-validator');
const { Pool } = require('pg')
const pool = new Pool({
host: 'localhost',
user: 'postgres',
password: 'admin',
database: 'eventos',
port: '5433'
})
class Metodos {
constructor() {}
//------------------------------- Peticiones de Tipo empleados --------------------------------
getTipos_empleado = async (req, res) => {
const response = await pool.query('select * from eventos.tipos_empleado');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postTipos_empleado = async(req, res) => {
const { nombre } = req.body;
const response = await pool.query('insert into eventos.tipos_empleado(nombre) values ($1)', [nombre])
console.log({nombre})
res.status(201).json({messege:'Tipo de Empleado Registrado', body:{nombre} });
}
deleteTipos_empleado = async (req, res) => {
const {nombre} = req.body;
await pool.query('delete from eventos.tipos_empleado where nombre= $1', [nombre]);
console.log({nombre});
res.status(201).json({messege:"Tipo de Empleado Eliminado", body:{nombre}});
}
//-------------------------------- Peticiones de Tipo Contratación ----------------------------
getTipos_contratacion = async (req, res) => {
const response = await pool.query('select * from eventos.tipos_contratacion');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postTipos_contratacion = async(req, res) => {
const { nombre } = req.body;
const response = await pool.query('insert into eventos.tipos_contratacion(nombre) values ($1)', [nombre])
console.log({nombre})
res.status(201).json({messege:'Tipo de Contratación ingresada', body:{nombre} });
}
deleteTipos_contratacion = async (req, res) => {
const {nombre} = req.body;
await pool.query('delete from eventos.tipos_contratacion where nombre= $1', [nombre]);
console.log({nombre});
res.status(201).json({messege:"Tipo de Contratación Eliminada", body:{nombre}});
}
//--------------------------------- Peticiones Sedes ------------------------------------------
getSedes = async (req, res) => {
const response = await pool.query('select * from eventos.sedes');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postSedes = async(req, res) => {
const { codigo,nombre,cod_ciudad } = req.body;
const response = await pool.query('insert into eventos.sedes(codigo,nombre,cod_ciudad) values ($1,$2,$3)', [codigo,nombre,cod_ciudad])
console.log({codigo,nombre,cod_ciudad})
res.status(201).json({messege:'Sede ingresada', body:{codigo,nombre,cod_ciudad} });
}
deleteSedes = async (req, res) => {
const {codigo} = req.body;
await pool.query('delete from eventos.sedes where codigo= $1', [codigo]);
console.log({codigo});
res.status(201).json({messege:"Sede Eliminada", body:{codigo}});
}
putSedes = async(req, res) => {
const codigo = req.body.codigo;
console.log("codigo", codigo);
const { nombre,cod_ciudad } = req.body;
const response = await pool.query('update eventos.sedes set nombre= $1,cod_ciudad=$2 where codigo = $3', [nombre,cod_ciudad,codigo]);
console.log({nombre,cod_ciudad});
res.status(201).json({messege:'Sede Actualizada', body:{codigo,nombre,cod_ciudad}});
}
//--------------------------------- Peticiones Programas --------------------------------------
getProgramas = async (req, res) => {
const response = await pool.query('select * from eventos.programas');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postProgramas = async(req, res) => {
const { codigo,nombre,codigo_area } = req.body;
const response = await pool.query('insert into eventos.programas(codigo,nombre,codigo_area) values ($1,$2,$3)', [codigo,nombre,codigo_area])
console.log({codigo,nombre,codigo_area})
res.status(201).json({messege:'Programa ingresado', body:{codigo,nombre,codigo_area} });
}
deleteProgramas = async (req, res) => {
const {codigo} = req.body;
await pool.query('delete from eventos.programas where codigo= $1', [codigo]);
console.log({codigo});
res.status(201).json({messege:"Programa Eliminado", body:{codigo}});
}
putProgramas = async(req, res) => {
const codigo = req.body.codigo;
console.log("codigo", codigo);
const { nombre,codigo_area } = req.body;
const response = await pool.query('update eventos.programas set nombre= $1,codigo_area=$2 where codigo = $3', [nombre,codigo_area,codigo]);
console.log({nombre,codigo_area});
res.status(201).json({messege:'Programa Actualizado', body:{codigo,nombre,codigo_area}});
}
//---------------------------------- Peticiones Paises ----------------------------------------
getPaises = async (req, res) => {
const response = await pool.query('select * from eventos.paises');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postPaises = async(req, res) => {
const { codigo,nombre } = req.body;
const response = await pool.query('insert into eventos.paises(codigo,nombre) values ($1,$2)', [codigo,nombre])
console.log({codigo,nombre})
res.status(201).json({messege:'Pais ingresado', body:{codigo,nombre} });
}
deletePaises = async (req, res) => {
const {codigo} = req.body;
await pool.query('delete from eventos.paises where codigo= $1', [codigo]);
console.log({codigo});
res.status(201).json({messege:"Pais Eliminado", body:{codigo}});
}
putPaises = async(req, res) => {
const codigo = req.body.codigo;
console.log("codigo", codigo);
const { nombre } = req.body;
const response = await pool.query('update eventos.paises set nombre= $1 where codigo = $2', [nombre,codigo]);
console.log({nombre});
res.status(201).json({messege:'Pais Actualizada', body:{codigo,nombre}});
}
//---------------------------------- Peticiones Facultades ------------------------------------
getFacultades = async (req, res) => {
const response = await pool.query('select * from eventos.facultades');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postFacultades = async(req, res) => {
const { codigo,nombre,ubicacion,nro_telefono,id_decano } = req.body;
const response = await pool.query('insert into eventos.facultades(codigo,nombre,ubicacion,nro_telefono,id_decano) values ($1,$2,$3,$4,$5)', [codigo,nombre,ubicacion,nro_telefono,id_decano])
console.log({codigo,nombre,ubicacion,nro_telefono,id_decano})
res.status(201).json({messege:'Facultad ingresada', body:{codigo,nombre,ubicacion,nro_telefono,id_decano} });
}
deleteFacultades = async (req, res) => {
const {codigo} = req.body;
await pool.query('delete from eventos.facultades where codigo= $1', [codigo]);
console.log({codigo});
res.status(201).json({messege:"Facultad Eliminada", body:{codigo}});
}
putFacultades = async(req, res) => {
const codigo = req.body.codigo;
console.log("codigo", codigo);
const { nombre,ubicacion,nro_telefono,id_decano } = req.body;
const response = await pool.query('update eventos.facultades set nombre= $1,ubicacion=$2,nro_telefono=$3,id_decano=$4 where codigo = $5', [nombre,ubicacion,nro_telefono,id_decano,codigo]);
console.log({nombre,ubicacion,nro_telefono,id_decano});
res.status(201).json({messege:'Facultad Actualizada', body:{codigo,nombre,ubicacion,nro_telefono,id_decano}});
}
//---------------------------------- Peticiones Departamentos ---------------------------------
getDepartamentos = async (req, res) => {
const response = await pool.query('select * from eventos.departamentos');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postDepartamentos = async(req, res) => {
const { codigo,nombre,cod_pais } = req.body;
const response = await pool.query('insert into eventos.departamentos (codigo,nombre,cod_pais) values ($1,$2,$3)', [codigo,nombre,cod_pais])
console.log({codigo,nombre,cod_pais})
res.status(201).json({messege:'Departamento ingresado', body:{codigo,nombre,cod_pais} });
}
deleteDepartamentos = async (req, res) => {
const {codigo} = req.body;
await pool.query('delete from eventos.departamentos where codigo= $1', [codigo]);
console.log({codigo});
res.status(201).json({messege:"Departamento eliminado", body:{codigo}});
}
putDepartamentos = async(req, res) => {
const codigo = req.body.codigo;
console.log("codigo", codigo);
const { nombre,cod_pais } = req.body;
const response = await pool.query('update eventos.departamentos set nombre= $1,cod_pais=$2 where codigo = $3', [nombre,cod_pais,codigo]);
console.log({codigo,nombre,cod_pais});
res.status(201).json({messege:'Ciudad Actualizada', body:{codigo,nombre,cod_pais}});
}
//-------------------------------------- Peticiones Areas ----------------------------------
getAreas = async (req, res) => {
const response = await pool.query('select * from eventos.areas');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postAreas = async(req, res) => {
const { codigo,nombre,codigo_facultad,id_coordinador } = req.body;
const response = await pool.query('insert into eventos.areas (codigo,nombre,codigo_facultad,id_coordinador) values ($1,$2,$3,$4)', [codigo,nombre,codigo_facultad,id_coordinador])
console.log({codigo,nombre,codigo_facultad,id_coordinador})
res.status(201).json({messege:'Area ingresada', body:{codigo,nombre,codigo_facultad,id_coordinador} });
}
deleteAreas = async (req, res) => {
const {codigo} = req.body;
await pool.query('delete from eventos.areas where codigo= $1', [codigo]);
console.log({codigo});
res.status(201).json({messege:"Area eliminada", body:{codigo}});
}
putAreas = async(req, res) => {
const codigo = req.body.codigo;
console.log("codigo", codigo);
const { nombre,codigo_facultad,id_coordinador } = req.body;
const response = await pool.query('update eventos.areas set nombre= $1,codigo_facultad=$2,id_coordinador=$3 where codigo = $4', [nombre,codigo_facultad,id_coordinador,codigo])
console.log({nombre,codigo_facultad,id_coordinador})
res.status(201).json({messege:'Ciudad Actualizada', body:{nombre,codigo_facultad,id_coordinador} });
}
//--------------------------------------- Peticiones Empleados ------------------------------
getEmpleados = async (req, res) => {
const response = await pool.query('select * from eventos.empleados');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postEmpleados = async(req, res) => {
const { identificacion,nombres,apellidos,email,tipo_contratacion,tipo_empleado,cod_facultad,codigo_sede,lugar_nacimiento } = req.body;
const response = await pool.query('insert into eventos.empleados (identificacion,nombres,apellidos,email,tipo_contratacion,tipo_empleado,cod_facultad,codigo_sede,lugar_nacimiento) values ($1,$2,$3,$4,$5,$6,$7,$8,$9)', [identificacion,nombres,apellidos,email,tipo_contratacion,tipo_empleado,cod_facultad,codigo_sede,lugar_nacimiento])
console.log({identificacion,nombres,apellidos,email,tipo_contratacion,tipo_empleado,cod_facultad,codigo_sede,lugar_nacimiento})
res.status(201).json({messege:'Empleado Registrado', body:{identificacion,nombres,apellidos,email,tipo_contratacion,tipo_empleado,cod_facultad,codigo_sede,lugar_nacimiento} });
}
deleteEmpleados = async (req, res) => {
const {identificacion} = req.body;
await pool.query('delete from eventos.empleados where identificacion= $1', [identificacion]);
console.log({identificacion});
res.status(201).json({messege:"Empleado Eliminado", body:{identificacion}});
}
putEmpleados = async(req, res) => {
const identificacion = req.body.identificacion
console.log("Identificación", identificacion);
const { nombres,apellidos,email,tipo_contratacion,tipo_empleado,cod_facultad,codigo_sede,lugar_nacimiento } = req.body;
const response = await pool.query('update eventos.empleados set nombres= $1,apellidos=$2,email=$3,tipo_contratacion=$4,tipo_empleado=$5,cod_facultad=$6,codigo_sede=$7,lugar_nacimiento=$8 where identificacion = $9', [nombres,apellidos,email,tipo_contratacion,tipo_empleado,cod_facultad,codigo_sede,lugar_nacimiento,identificacion])
console.log({nombres,apellidos,email,tipo_contratacion,tipo_empleado,cod_facultad,codigo_sede,lugar_nacimiento})
res.status(201).json({messege:'Empleado Actualizado', body:{nombres,apellidos,email,tipo_contratacion,tipo_empleado,cod_facultad,codigo_sede,lugar_nacimiento} });
}
//--------------------------------------- Peticiones Ciudades -------------------------------
getCiudades = async (req, res) => {
const response = await pool.query('select * from eventos.ciudades');
console.log(response.rows);
res.status(201).json({messege:response.rows});
}
postCiudades = async(req, res) => {
const { codigo,nombre,cod_dpto } = req.body;
const response = await pool.query('insert into eventos.ciudades (codigo,nombre,cod_dpto) values ($1,$2,$3)', [codigo,nombre,cod_dpto])
console.log({codigo,nombre,cod_dpto})
res.status(201).json({messege:'Ciudad ingresada', body:{codigo,nombre,cod_dpto} });
}
deleteCiudad = async (req, res) => {
const {codigo} = req.body;
await pool.query('delete from eventos.ciudades where codigo= $1', [codigo]);
console.log({codigo});
res.status(201).json({messege:"Ciudad eliminada", body:{codigo}});
}
putCiudad = async(req, res) => {
const codigo = req.body.codigo
console.log("codigo", codigo);
const { nombre,cod_dpto } = req.body;
const response = await pool.query('update eventos.ciudades set nombre= $1,cod_dpto=$2 where codigo = $3', [nombre,cod_dpto,codigo])
console.log({nombre,cod_dpto})
res.status(201).json({messege:'Ciudad Actualizada', body:{codigo,nombre,cod_dpto} });
}
}
module.exports = {Metodos}; |
define([
'/BrainAcademy-examples/node_modules/backbone/backbone.js'
],function(Backbone){
return Backbone.View.extend({
initialize: function(){
document.body.innerHTML += '<div id="chat"></div>';
},
getEl: function(){
return document.getElementById('chat');
}
});
}); |
//------------------------------------------------------------------------------
function bin(raw) {
raw = atob(raw.substr(raw.indexOf(';base64,') + 8));
let i = raw.length;
const b = new ArrayBuffer(i);
const a = new Uint8Array(b);
while (i !== 0) {
i--;
a[i] = raw.charCodeAt(i);
}
return b;
}
//------------------------------------------------------------------------------
const wasmBinary = bin('@@import ./build/webpjs.wasm');
const webpRaw = [
bin('@@import test1.webp'),
bin('@@import test2.webp'),
bin('@@import test3.webp'),
bin('@@import test4.webp'),
bin('@@import test5.webp'),
bin('@@import test6.webp')
];
//------------------------------------------------------------------------------
|
var searchData=
[
['lacze_5fdo_5fgnuplota_2ehh_42',['lacze_do_gnuplota.hh',['../lacze__do__gnuplota_8hh.html',1,'']]],
['laczedognuplota_43',['LaczeDoGNUPlota',['../class_pz_g_1_1_lacze_do_g_n_u_plota.html',1,'PzG']]],
['length_44',['length',['../class_vector.html#a83081aef0a91d492eb0f879bec414791',1,'Vector']]],
['lot_5fdo_5fgory_45',['lot_do_gory',['../class_drone.html#a9f3330dc98c1117e8bf97606206f3715',1,'Drone']]]
];
|
import './style.css';
import {refs} from './JS/refs.js';
import {searchOptions} from './JS/options.js';
// import {observerOptions} from './JS/options.js';
import getPictures from './JS/apiService';
import cardTpl from './templates/photo-card.hbs';
import * as basicLightbox from 'basiclightbox';
import {
alert,
defaultModules,
notice,
info,
success,
error,
} from '../node_modules/@pnotify/core/dist/PNotify.js';
import '@pnotify/core/dist/BrightTheme.css';
// const formRef = document.querySelector('#search-form');
// const galleryOptionsRef = document.querySelector('.gallery-options');
// const refs = {
// imageType: galleryOptionsRef.querySelector('#image-type'),
// imageOrientation: galleryOptionsRef.querySelector('#image-orientation'),
// imagesPerPage: galleryOptionsRef.querySelector('[name="images-per-page"]'),
// imageQuery: formRef.querySelector('[name="query"]'),
// gallery: document.querySelector('.gallery'),
// // formSubmitBtn: formRef.querySelector('.form-submit'),
// loadMoreBtn: document.querySelector('.load-more-btn'),
// // labelSpan: document.querySelector('.label'),
// loaderSpan: document.querySelector('.loader'),
// };
// const observer = new IntersectionObserver(onLoadMoreImages, observerOptions);
refs.loadMoreBtn.style.visibility = 'hidden';
refs.form.addEventListener('submit', onSearchImages);
refs.loadMoreBtn.addEventListener('click', onLoadMoreImages);
refs.gallery.addEventListener('click', openModal);
function onSearchImages(event) {
event.preventDefault();
searchOptions.query = event.currentTarget.elements.query.value.trim();
searchOptions.imageType = refs.imageType.value;
searchOptions.imageOrientation = refs.imageOrientation.value;
searchOptions.imagesPerPage = refs.imagesPerPage.value;
getPictures(
searchOptions.imageType,
searchOptions.imageOrientation,
searchOptions.imagesPerPage,
searchOptions.query,
searchOptions.pageNumber,
)
.then(({ data: { hits } }) => {
refs.gallery.innerHTML = cardTpl(hits);
if (hits.length > searchOptions.imagesPerPage - 1) {
refs.loadMoreBtn.style.visibility = 'visible';
}
})
.catch(err => error({ text: `${err.message}` }));
}
function onLoadMoreImages() {
searchOptions.pageNumber += 1;
getPictures(
searchOptions.imageType,
searchOptions.imageOrientation,
searchOptions.imagesPerPage,
searchOptions.query,
searchOptions.pageNumber,
)
.then(({ data: { hits } }) => {
refs.gallery.insertAdjacentHTML('beforeend', cardTpl(hits));
refs.gallery.scrollIntoView({
behavior: 'smooth',
block: 'end',
});
if (hits.length < searchOptions.imagesPerPage) {
refs.loadMoreBtn.style.visibility = 'hidden';
}
// if (searchOptions.pageNumber === 2) {
// observer.observe(refs.loadMoreBtn);
// }
})
.catch(err => console.log(err));
}
function openModal(e) {
if (e.target.nodeName !== "IMG") {
return
}
const instance = basicLightbox.create(`
<img src="${e.target.dataset.src}" width="800" height="600">
`)
instance.show()
}
|
import { createStore, combineReducers, applyMiddleware, compose } from "redux";
import createSagaMiddleware from "redux-saga";
import { authReducer } from "./Auth/reducers";
import { storyStart } from "../store/sagas";
import { boardReducer } from "./Board/reducers";
import { profileReducer } from "./Profile/reducers";
import { createGameReducer } from "./GameCreate/reducers";
export const createReduxStore = () => {
const reducer = combineReducers({
auth: authReducer,
board: boardReducer,
profile: profileReducer,
createGame: createGameReducer
});
const sagaMiddleware = createSagaMiddleware();
const middleware = [sagaMiddleware];
const store = createStore(reducer, compose(applyMiddleware(...middleware)));
sagaMiddleware.run(storyStart);
return store;
};
|
const appConfig = require('./app-config');
module.exports = [appConfig];
|
import React, { PureComponent } from 'react';
import { PushNotificationIOS, Platform, AppState } from 'react-native';
export default class PushNotificationSetting extends PureComponent {
constructor(props) {
super(props);
this._onRemoteNotification = this._onRemoteNotification.bind(this)
}
componentWillMount(){
PushNotificationIOS.addEventListener('register', this._onRegistered);
PushNotificationIOS.addEventListener('registrationError', this._onRegistrationError);
PushNotificationIOS.addEventListener('notification', this._onRemoteNotification);
PushNotificationIOS.requestPermissions()
}
componentWillUnmount(){
PushNotificationIOS.removeEventListener('register', this._onRegistered);
PushNotificationIOS.removeEventListener('registrationError', this._onRegistrationError);
PushNotificationIOS.removeEventListener('notification', this._onRemoteNotification);
}
_onRegistered(deviceToken) {
console.log("PushNotificationSetting", deviceToken);
}
_onRegistrationError(error) {
console.log(error.code, error.message);
}
_onRemoteNotification(notification) {
const result = `Message: ${notification.getMessage()};\n
badge: ${notification.getBadgeCount()};\n
sound: ${notification.getSound()};`;
console.log(result);
}
render() {
return this.props.children;
}
}
|
function CandidatePersonal() { }
CandidatePersonal.prototype.insert = function (req, res, dbObj, details, callback) {
console.log('Inserting personal details');
// console.log(moment(req.body.personalDetails.placeOfBirth).format('DD-MM-YYYY'));
console.log(stringToDate(req.body.personalDetails.dateOfBirth,"dd-mm-yyyy","-"));
var spouseDOB= null;
if(req.body.personalDetails.spouseDOB != null && req.body.personalDetails.spouseDOB != undefined ){
spouseDOB= stringToDate(req.body.personalDetails.spouseDOB,"dd-mm-yyyy","-");
}
var args = {TITLE :req.body.personalDetails.title,
FIRSTNAME:req.body.personalDetails.firstName,
MIDDLENAME:req.body.personalDetails.middleName,
LASTNAME: req.body.personalDetails.lastName,
DOB:stringToDate(req.body.personalDetails.dateOfBirth,"dd-mm-yyyy","-"),
PLACE_OF_BIRTH:req.body.personalDetails.placeOfBirth,
MOB_NUMBER:req.body.personalDetails.mobileNumber,
ALT_MOB_NUM:req.body.personalDetails.alternateNumber,
PERSONAL_EMAILID:req.body.personalDetails.personalEmail,
NATIONALITY:req.body.personalDetails.nationality,
PASSPORT_NO:req.body.personalDetails.passportNumber,
PAN_NO:req.body.personalDetails.pan,
NASSCOM_NSR_ITPIN:req.body.personalDetails.nsr,
FATHER_NAME:req.body.personalDetails.fathersName,
FATHER_DOB:stringToDate(req.body.personalDetails.fathersDOB,"dd-mm-yyyy","-"),
MOTHER_NAME:req.body.personalDetails.mothersName,
MOTHER_DOB: stringToDate(req.body.personalDetails.mothersDOB,"dd-mm-yyyy","-"),
SPOUSE_NAME: req.body.personalDetails.spouseName,
SPOUSE_DOB:spouseDOB,
GENDER:req.body.personalDetails.gender,
CHILD_DETAILS :JSON.stringify(req.body.personalDetails.children),
CID:details.cid
};
var insQuery = 'insert into PERSONAL_DETAILS SET ?';
var query = dbObj.query(insQuery, args, function (err, rows, fields) {
if (!err) {
callback();
}
else {
console.log('Error while performing Query.' + err);
}
});
}
function stringToDate(_date,_format,_delimiter)
{
var formatLowerCase=_format.toLowerCase();
var formatItems=formatLowerCase.split(_delimiter);
var dateItems=_date.split(_delimiter);
var monthIndex=formatItems.indexOf("mm");
var dayIndex=formatItems.indexOf("dd");
var yearIndex=formatItems.indexOf("yyyy");
var month=parseInt(dateItems[monthIndex]);
month-=1;
var formatedDate = new Date(dateItems[yearIndex],month,dateItems[dayIndex]);
return formatedDate;
}
var candidatePersonal = new CandidatePersonal();
module.exports = candidatePersonal; |
/**
* Created by oliver on 4/2/17.
*/
/**
* The Node object can be hacked and can initiate attacks.
*/
var Node = function(obj) {
this.id = 'xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
return v.toString(16);
});
this.defense = 100;
this.attack = 10;
this.description = "Generic Node";
this.x = 100;
this.y = 100;
this.r = 30;
this.baseColor = '#e8e8e8';
this.owner = 0;
this.health = 100;
var _owner = 0;
if(typeof obj == 'object') {
for(var i in obj) {
if(obj[i]) { this[i] = obj[i]; }
}
};
/** Does something */
Node.prototype.doSomething = function () {
};
Object.defineProperty(this, "owner", {
get: function () {
return _owner;
},
set: function (owner) {
_owner = owner;
if (owner == 0) {
setBaseColor('#e8e8e8') // grey
}
}
});
};
module.exports = Node;
|
function betweener(){
setTimeout(function(){$('#edo').animate({opacity:"1",}, 100, after2wait())}, 300)
}
function sendoff() {
window.location.replace("main.html")
}
function after2wait() {
setTimeout(function(){$('#edo').animate({opacity: "0",}, 250, sendoff());}, 600)
}
function after1wait() {
setTimeout(function(){$('#poly').animate({opacity:"0",}, 100, betweener());}, 600)
}
function openfunc(){
setTimeout(function(){
$('#poly').animate({
opacity: "1",
}, 100, after1wait()
)
},500)
};
|
$(document).ready(function() {
var menu = $('.mainmenu');
function scroll() {
if ($(window).scrollTop() >= 1) {
$('.mainmenu').addClass('sticky');
$('.content').addClass('menu-padding');
} else {
$('.mainmenu').removeClass('sticky');
$('.content').removeClass('menu-padding');
}
}
document.onscroll = scroll;
});
var price = document.getElementById("price").innerHTML;
var quantity = document.getElementById("quantity").value;
var total = document.getElementById("total").innerHTML;
document.getElementById('total').innerHTML = quantity * price; |
const Web3 = require('web3') // Works with web3 1.0.0-beta27
const contractArtifact = require('./build/contracts/TutorialToken.json')
const web3 = new Web3()
const providerUrl = 'ws://localhost:8545' // requires # https://github.com/trufflesuite/ganache-cli/releases/tag/v7.0.0-beta.0 or https://github.com/trufflesuite/ganache/releases/tag/v1.1.0-beta.0
const provider = new Web3.providers.WebsocketProvider(providerUrl)
web3.setProvider(provider)
web3.eth.net.getId()
.then(networkId => {
const contractAddr = contractArtifact.networks[networkId].address
const TutorialToken = new web3.eth.Contract(contractArtifact.abi, contractAddr)
TutorialToken.events.Transfer({fromBlock: 0}, function(error, event){ console.log(error) })
.on('data', (log) => {
let { returnValues: { from, to, value }, blockNumber } = log
console.log(`----BlockNumber (${blockNumber})----`)
console.log(`from = ${from}`)
console.log(`to = ${to}`)
console.log(`value = ${value}`)
console.log(`----BlockNumber (${blockNumber})----`)
})
.on('changed', (log) => {
console.log(`Changed: ${log}`)
})
.on('error', (log) => {
console.log(`error: ${log}`)
})
})
|
import { forwardRef } from 'react';
import { Link } from 'react-router-dom';
import { GrClose } from 'react-icons/gr';
import Modal from '../Modal';
import * as S from './styles';
const ModalFollowing = forwardRef((props, ref) => {
return (
<Modal ref={ref}>
<S.Content>
<header>
<strong>Following</strong>
<GrClose size={18} onClick={() => ref.current.close()} />
</header>
<ul>
{props.profiles.map((user) => (
<li key={user.id}>
<img
src={
user.image
? user.image
: `https://eu.ui-avatars.com/api/?name=${user.username}`
}
alt={user.username}
/>
<div>
<Link to={`/${user.username}`}>
<strong>{user.username}</strong>
</Link>
<span>{user.fullName}</span>
</div>
</li>
))}
</ul>
</S.Content>
</Modal>
);
});
export default ModalFollowing;
|
var colorChoices = ["red", "orangered", "gold", "limegreen", "dodgerblue", "slateblue", "rebeccapurple"]
var currentColor = colorChoices[0];
var divItems = document.getElementsByClassName("shape");
function clear() {
for(var i=0; i < divItems.length; i++) {
var item = divItems[i];
item.style.backgroundColor = 'white';
}
}
function getNextColor(currentColor) {
currentIndex = this.colorChoices.indexOf(currentColor);
if (currentIndex < (colorChoices.length - 1)) {
return colorChoices[currentIndex + 1]
} else {
return colorChoices[0]
}
}
function changeColor(item) {
console.log('changed color')
var currentColor = item.style.backgroundColor;
if (colorChoices.includes(currentColor)) {
item.style.backgroundColor = "peachpuff"
this.currentColor = this.colorChoices[0]
} else {
item.style.backgroundColor = this.currentColor;
this.currentColor = getNextColor(this.currentColor)
}
} |
var express = require("express");
const kubeProbe = require('kube-probe');
const promClient = require('prom-client');
var request = require('request');
var sleep = require('system-sleep');
const newman = require('newman');
/*
#########################################################
Example HTTP SERVER
#########################################################
*/
var app = express();
var router = express.Router();
var path = __dirname + '/';
router.use(function(req, res, next) {
console.log("/" + req.method);
next();
});
router.get("/", function(req, res) {
res.sendFile(path + "index.html");
});
app.use(express.static(path));
app.use("/", router);
app.listen(8080, function() {
console.log('HTTP Web Server is running on internal port 8080!')
})
/*
#########################################################
MONITORING SERVER
https://github.com/siimon/prom-client
#########################################################
*/
const SSO_URL = process.env.SSO_URL;
checkIfNullOrEmpty('SSO_URL', SSO_URL);
const CLIENT_ID = process.env.CLIENT_ID;
checkIfNullOrEmpty('CLIENT_ID', CLIENT_ID);
const CLIENT_SECRET = process.env.CLIENT_SECRET;
checkIfNullOrEmpty('CLIENT_SECRET', CLIENT_SECRET);
const PARTNER_URL = process.env.PARTNER_URL;
checkIfNullOrEmpty('PARTNER_URL', PARTNER_URL);
const metricServer = express();
const register = new promClient.Registry();
const gauge = new promClient.Gauge({ name: 'PARTNER_URL_TEST', help: 'Shows Availability of Endpoint.' });
register.registerMetric(gauge);
metricServer.get('/metrics', (req, res) => {
res.set('Content-Type', register.contentType);
res.end(register.metrics());
});
console.log('Server listening to 3001, metrics exposed on "/metrics" endpoint');
metricServer.listen(3001)
/*
#########################################################
LIVENESS AND READINESS PROBES IN K8S
https://github.com/nodeshift/kube-probe
#########################################################
*/
const options = {
readinessURL: '/health/readiness',
livenessURL: '/health/liveness'
}
console.log('Server listening to 3001, liveness and readiness exposed via "/health/readiness" and "/health/liveness" endpoints');
kubeProbe(metricServer, options);
while (1) {
ExecutePostmanTestAndSetAvailabilityMetric();
sleep(10000);
}
// CHECK ENV VARIABLES
function checkIfNullOrEmpty(parameterName, parameterValue) {
if (!parameterValue) {
throw new Error(`${parameterName} is null or empty!`);
}
console.log(`${parameterName}: ${parameterValue}`);
}
// EXECUTE POSTMAN TEST
function ExecutePostmanTestAndSetAvailabilityMetric() {
try {
console.log('Starting postman scripts: ');
// check if proxy setting is needed!
//const SocksProxyAgent = require('socks-proxy-agent');
//const requestAgent = new SocksProxyAgent({ host: 'add_proxy_url', port: 'add_proxy_port' });
newman.run({
collection: require('./test/PARTER_URL_TEST.postman_collection.json'),
environment: {
"id": "9904cbd9-1c54-4a94-9576-d739dbd925ff",
"name": "ENVIRONMENT",
"values": [{
"key": "SSO_URL",
"value": SSO_URL,
"enabled": true
},
{
"key": "CLIENT_ID",
"value": CLIENT_ID,
"enabled": true
},
{
"key": "CLIENT_SECRET",
"value": CLIENT_SECRET,
"enabled": true
},
{
"key": "ACCESS_TOKEN",
"value": "",
"enabled": true
},
{
"key": "PARTNER_URL",
"value": PARTNER_URL,
"enabled": true
}
],
"_postman_variable_scope": "environment"
},
//requestAgents: {
//http: requestAgent, // agent used for HTTP requests
//http: requestAgent, // agent used for HTTPS requests
//},
reporters: 'cli'
},
function(err) {
if (err) { throw err; }
console.log('collection run complete!');
});
console.log("Set Status of Metric to 1");
gauge.set(1);
} catch {
console.log("Set Status of Metric to 0");
gauge.set(0);
}
} |
import { BrowserRouter, Switch, Route } from 'react-router-dom'
import './App.css';
import Home from './pages/Home'
import Cookie from './pages/Cookie'
import Team from './pages/Team'
import { StoreProvider } from "./store";
import Number from "./pages/Number"
import Login from './pages/Login'
import Register from './pages/Register'
import Profile from './pages/Profile'
import Order from './pages/Order'
import Change from './pages/Change'
import Event from './pages/Event'
function App() {
return (
<div>
<StoreProvider>
<BrowserRouter>
<Switch>
<Route exact path="/" component={Home} />
<Route path="/home/:pageName" component={Home} />
<Route path="/cookie" component={Cookie} />
<Route path="/cookie/:cookieStyle" component={Cookie} />
<Route path="/team" component={Team} />
<Route path="/number" component={Number} />
<Route path="/login" component={Login} />
<Route path="/register" component={Register} />
<Route path="/profile" component={Profile} />
<Route path="/order/:orderId" component={Order} />
<Route path="/change" component={Change} />
<Route path="/event" component={Event} />
</Switch>
</BrowserRouter>
</StoreProvider >
</div>
);
}
export default App; |
'use strict';
const Message = require( '../models/message' );
module.exports = io => {
io.on( 'connection', client => {
console.log( 'new connection' );
Message.find( {} )
.sort( { createdAt: -1 } )
.limit( 10 )
.then( messages => {
client.emit( 'load all messages', messages.reverse() );
} );
client.on( 'disconnect', () => {
client.broadcast.emit( 'user disconnected' );
console.log( 'user disconnected' );
} );
client.on( 'message', ( data ) => {
let messageAttributes = {
content: data.content,
userName: data.userName,
user: data.userId
},
m = new Message( messageAttributes );
m.save()
.then( () => {
io.emit( 'message', messageAttributes );
} )
.catch( error => console.log( `error: ${error.message}` ) );
} );
} );
};
|
import React from 'react'
import _ from 'lodash'
import { RouteTo, IP_ADDRESS } from 'components/Utils/RouterAction'
import {
Typography,
ExpansionPanel,
ExpansionPanelDetails,
ExpansionPanelSummary,
Snackbar,
IconButton,
Button
} from '@material-ui/core'
import CloseIcon from '@material-ui/icons/Close';
import ExpandMoreIcon from '@material-ui/icons/ExpandMore'
import List from '@material-ui/core/List'
import ListItem from '@material-ui/core/ListItem'
import ListItemIcon from '@material-ui/core/ListItemIcon'
import ListItemText from '@material-ui/core/ListItemText'
import VideoCam from '@material-ui/icons/Videocam'
import OfflineBolt from '@material-ui/icons/OfflineBolt'
import InsertDriveFile from '@material-ui/icons/InsertDriveFile'
class OpenCourseExpansion extends React.Component {
state = {
expanded: true,
open: false,
vertical: 'top',
horizontal: 'center',
message: 'Enroll and pay to open.'
}
handleChange = panel => (event, expanded) => {
this.setState({
expanded: expanded ? panel : false,
})
}
handleClick = state => () => {
this.setState({ open: true, ...state });
};
handleClose = () => {
this.setState({ open: false });
};
render() {
const { expanded } = this.state;
const { vertical, horizontal, open } = this.state;
return (
<ExpansionPanel expanded={expanded} onChange={this.handleChange(this.props.detail.id)}>
<ExpansionPanelSummary expandIcon={<ExpandMoreIcon />}>
<Typography variant="subheading">{this.props.detail.section_title} </Typography>
</ExpansionPanelSummary>
<ExpansionPanelDetails style={{ display: 'block', padding: '0px 24px 24px' }} onClick={this.handleClick({ vertical: 'bottom', horizontal: 'right' })}>
{/* <h1>{`this.props.detail.content`}</h1> */}
{/* <Snackbar
anchorOrigin={{ vertical, horizontal }}
open={open}
onClose={this.handleClose}
ContentProps={{
'aria-describedby': 'message-id',
}}
message={<span id="message-id">{this.state.message}</span>}
// action={[
// <Button key="undo" color="secondary" size="small" onClick={this.handleClose}>
// CLOSE
// </Button>,
// <IconButton
// key="close"
// aria-label="Close"
// color="inherit"
// onClick={this.handleClose}
// >
// <CloseIcon />
// </IconButton>,
// ]}
/> */}
<div style={{ marginBottom: 10 }}>
<List component="nav">
{_.map(this.props.detail.course_items, data => {
if(data.type === 'video')
return (
<ListItem button>
<ListItemIcon>
<VideoCam />
</ListItemIcon>
<ListItemText
primary={data.title}
// secondary={data.description}
/>
</ListItem>
)
else if(data.type === 'document')
{
return (
<ListItem button>
<ListItemIcon>
<InsertDriveFile />
</ListItemIcon>
<ListItemText
primary={data.title}
// secondary={data.description}
/>
</ListItem>
)
}
else {
return (
<ListItem button>
<ListItemIcon>
<OfflineBolt />
</ListItemIcon>
<ListItemText
primary={data.title}
// secondary={data.description}
/>
</ListItem>
)
}
})}
</List>
</div>
</ExpansionPanelDetails>
</ExpansionPanel>
)
}
}
export default OpenCourseExpansion
|
var searchData=
[
['tray_5frecording_2ecpp',['tray_recording.cpp',['../tray__recording_8cpp.html',1,'']]],
['tray_5frecording_2eh',['tray_recording.h',['../tray__recording_8h.html',1,'']]],
['tray_5fsystem_2ecpp',['tray_system.cpp',['../tray__system_8cpp.html',1,'']]],
['tray_5fsystem_2eh',['tray_system.h',['../tray__system_8h.html',1,'']]]
];
|
var myApp = angular.module('myApp', ['app.routes']);
myApp.controller('mainController', ($scope, $http, $location) => {
//Get Images:
console.log("something");
$http.get('/images')
.then((response) => {
$scope.images = response.data;
});
//Upload images:
$scope.title = '';
$scope.username = '';
$scope.description = '';
$scope.directions = '';
$scope.ingredients = '';
$scope.file = {};
$scope.submit = () => {
var file = $('input[type="file"]').get(0).files[0];
var username = $scope.username;
var title = $scope.title;
var description = $scope.description;
var directions = $scope.directions;
var ingredients = $scope.ingredients;
var formData = new FormData();
formData.append('file', file);
formData.append('username', username);
formData.append('title', title);
formData.append('description', description);
formData.append('directions', directions);
formData.append('ingredients', ingredients);
$http({
url: '/upload',
method: 'POST',
data: formData,
headers: {
'Content-Type': undefined
},
transformRequest: angular.identity
}).then(() => {
console.log('Success!');
});
}
//Form functionality:
$scope.upload = () => {
if ($scope.username && $scope.title && $scope.description && $scope.directions && $scope.ingredients && $scope.file) {
setTimeout(() => {
$http.get('/images')
.then((response) => {
$scope.images = response.data;
$scope.username = ""
$scope.title = ""
$scope.file = {}
$scope.description = ""
$scope.directions = ""
$scope.ingredients = ""
});
}, 3500)
}
}
});
//Single image view:
myApp.controller('clickedImage', ($scope, $http, $location, $stateParams) => {
var imageUrl = '/image/' + $location.path().split('/').pop();
console.log(imageUrl);
$http.get(imageUrl)
.then((response) => {
console.log(response);
console.log(response.data[0]);
console.log(response.data[1]);
$scope.singleImage = response.data[0];
$scope.comments = response.data[1];
});
//Add a comment:
$scope.commentNow = function() {
var username = $scope.username;
var comment = $scope.comment;
var id = $stateParams.id;
console.log('Form data: ', username, comment, id);
console.log('here');
$http({
url: '/post-comment/' + $stateParams.id,
method: 'POST',
data: {
username,
comment,
id
}
})
.then(() => {
console.log('POSTED!');
})
}
//Refresh comments when user posts a new one:
$scope.refresh = function() {
setTimeout(()=> {
$http.get(imageUrl)
.then((response) => {
console.log(response.data[1]);
$scope.comments = response.data[1];
$scope.comment =""
$scope.username =""
});
}, 1000)
}
//Show & hide comments:
let message = 'See';
$scope.message = message;
$scope.toggle = function() {
if (message === 'See') {
message = 'Hide';
$scope.message = message;
} else if (message === 'Hide') {
message = 'See';
$scope.message = message;
}
$('#comments').slideToggle();
}
})
|
define(["Backbone"], function(Backbone){
var Router = Backbone.Router.extend({
routes:{
home: "home",
store: "store",
cart: "cart",
mine: "mine",
"":"home"
},
home: function(){
require(["01js"],function(home){
home.init();
})
},
store: function(){
require(["02js"],function(store){
store.init();
})
},
cart: function(){
require(["03js"],function(store){
store.init();
})
},
mine: function(){
require(["04js"],function(store){
store.init();
})
},
});
return new Router();
});
|
'use strict';
let num = 50;
//console.log(num);
switch (num) {
case num < 49:
console.log("|не верно");
break;
case num > 100:
console.log("много");
break;
case 50:
console.log("в5050");
break;
default:
console.log("что-то не так");
break;
}
(num == 50) ? console.log("верно"): console.log(" не верно")
var leftBorderWidth = 1; {
let second = 2;
console.log(second);
}
const pi = 3.14;
var string = "Hello olga";
console.log(string);
let something;
console.log(something);
let person = {
name: "Jhon",
age: 25,
isMarried: false
}
let person1 = {
name: "Jhon",
age: 25,
isMarried: false
}
console.log(person["name"]);
let arr = ['plum.png', 'orange.jpg', 'apple.bmp'];
console.log(arr[0]);
//alert("hello world");
//let answer = confirm("Are you here&?");
//console.log(answer);
//let answer = +prompt("Есть ли вам 18", "Да");
//console.log(typeof(answer));
//console.log(4+"-obg");
let incr = 10,
decr = 10;
console.log(incr++);
console.log(incr);
console.log(decr--);
console.log(decr);
console.log("2" == 2);
console.log("2" === 2);
let isChecked = true,
isClose = false;
console.log(!isChecked || !isClose); |
/* Copyright (c) 2020 Red Hat, Inc. */
'use strict'
import React from 'react'
import { Query } from 'react-apollo'
import { withRouter } from 'react-router-dom'
import PropTypes from 'prop-types'
import resources from '../../lib/shared/resources'
import { getResourceData } from '../tableDefinitions'
import { connect } from 'react-redux'
import { updateSecondaryHeader } from '../actions/common'
import { SINGLE_POLICY } from '../../lib/client/queries'
import { getPollInterval } from '../components/common/RefreshTimeSelect'
import { GRC_REFRESH_INTERVAL_COOKIE } from '../../lib/shared/constants'
import { Spinner } from '@patternfly/react-core'
import { DangerNotification } from '../components/common/DangerNotification'
// eslint-disable-next-line import/no-named-as-default
import PolicyDetailsOverview from '../components/modules/PolicyDetailsOverview'
import { setRefreshControl } from '../../lib/client/reactiveVars'
import { getTabs } from '../../lib/client/resource-helper'
import msgs from '../../nls/platform.properties'
import { LocaleContext } from '../components/common/LocaleContext'
import NoResource from '../components/common/NoResource'
resources(() => {
require('../../scss/policy-yaml-tab.scss')
})
class PolicyDetailsTab extends React.Component{
constructor(props) {
super(props)
}
static contextType = LocaleContext
getBreadcrumb() {
const breadcrumbItems = []
const { location } = this.props,
{ locale } = this.context,
urlSegments = location.pathname.split('/')
const hubNamespace = urlSegments.length > 4 ? urlSegments.slice(4, 5) : ''
const policyName = urlSegments.length > 5 ? urlSegments.slice(5, 6) : ''
breadcrumbItems.push({
label: msgs.get('tabs.hcmcompliance', locale),
noLocale: true,
url: `${urlSegments.slice(0, 3).join('/')}/all`
},
{
label: policyName,
noLocale: true,
url: `${urlSegments.slice(0, 3).join('/')}/all/${hubNamespace}/${policyName}`
})
return breadcrumbItems
}
componentDidMount() {
const { policyName } = this.props
const { tabs, url, updateSecondaryHeader: localUpdateSecondaryHeader } = this.props
localUpdateSecondaryHeader(
policyName,
getTabs(tabs, (tab, index) => index === 0 ? url : `${url}/${tab}`),
this.getBreadcrumb()
)
}
render() {
const {
policyName,
policyNamespace,
resourceType
} = this.props
const pollInterval = getPollInterval(GRC_REFRESH_INTERVAL_COOKIE)
return <Query
query={SINGLE_POLICY}
variables={{name: policyName, namespace: policyNamespace}}
pollInterval={pollInterval}
notifyOnNetworkStatusChange
>
{( result ) => {
const {data={}, loading, startPolling, stopPolling, refetch} = result
const { items } = data
const error = items ? null : result.error
const staticResourceData = getResourceData(resourceType)
if (!loading) {
this.timestamp = new Date().toString()
}
setRefreshControl(loading, this.timestamp, startPolling, stopPolling, refetch)
if (error) {
return <DangerNotification error={error} />
} else if (loading && items === undefined) {
return <Spinner className='patternfly-spinner' />
} else if (items.length === 0){
return <NoResource
title={msgs.get('error.not.found', this.context.locale)}
svgName='EmptyPagePlanet-illus.png'>
</NoResource>
} else {
const item = items[0]
return <PolicyDetailsOverview
loading={!items && loading}
error={error}
item={item}
resourceType={resourceType}
staticResourceData={staticResourceData}
/>
}
}}
</Query>
}
}
PolicyDetailsTab.propTypes = {
location: PropTypes.object,
policyName: PropTypes.string,
policyNamespace: PropTypes.string,
resourceType: PropTypes.object,
tabs: PropTypes.array,
updateSecondaryHeader: PropTypes.func,
url: PropTypes.string,
}
const mapDispatchToProps = (dispatch) => {
return {
updateSecondaryHeader: (title, tabs, breadcrumbItems, links) => dispatch(updateSecondaryHeader(title, tabs, breadcrumbItems, links))
}
}
export default withRouter(connect(null, mapDispatchToProps)(PolicyDetailsTab))
|
import * as React from 'react';
import {
CommonActions,
StackActions,
NavigationContainerRef,
} from '@react-navigation/native';
import {HOME_SCREEN, LOGIN_SCREEN} from '@app/navigation/ScreenName';
export const navigationRef: React.RefObject<NavigationContainerRef> =
React.createRef();
export function navigateToScreen(name: string, params = {}) {
navigationRef.current?.navigate(name, params);
}
export function navigateToScreenAndReplace(name: string, params = {}) {
navigationRef.current?.dispatch(StackActions.replace(name, params));
}
export function popToTop() {
navigationRef.current?.dispatch(StackActions.popToTop());
}
export function pop(number = 1) {
navigationRef.current?.dispatch(StackActions.pop(number));
}
export function goBack() {
navigationRef.current?.goBack();
}
export const backToLogin = () => {
navigationRef?.current?.dispatch(
CommonActions.reset({
index: 1,
routes: [{name: LOGIN_SCREEN}],
}),
);
};
export const backToHome = () => {
navigationRef?.current?.dispatch(
CommonActions.reset({
index: 1,
routes: [{name: HOME_SCREEN}],
}),
);
};
|
import React, {Component} from 'react';
import 'antd/dist/antd.css';
import {Table, LocaleProvider} from 'antd';
import zhCN from 'antd/lib/locale-provider/zh_CN';
import PropTypes from 'prop-types'
export default class UpLoadButton extends Component {
componentWillReceiveProps(Props) {
this.setState({})
}
componentWillMount() {
}
componentDidMount() {
}
render() {
return (
<div>
</div>
);
}
} |
const mongoose = require('mongoose')
const eventSchema = new mongoose.Schema({
name: {
type: String
},
email: {
type: String
},
phone: {
type: String
},
desc: {
type: String
},
start: {
type: Date,
required: true
},
end: {
type: Date
},
status: {
type: String,
required: true
},
user: {
type: mongoose.ObjectId,
ref: 'User',
required: true
},
service: {
type: mongoose.ObjectId,
ref: 'Service',
required: true
},
schedule: {
type: mongoose.ObjectId,
ref: 'Schedule',
required: true
}
})
module.exports = mongoose.model('event', eventSchema) |
import React, {Component} from 'react';
class Cart extends Component {
constructor(props) {
super(props);
this.state={
quantity:this.props.cart.quantity
};
this.onChange=this.onChange.bind(this);
this.onRemove=this.onRemove.bind(this);
}
onChange(e){
this.setState({[e.target.name]: e.target.value});
this.props.updateCart(this.props.cart.productId,e.target.value);
}
onRemove(e){
this.props.removeCart(this.props.cart.productId);
}
render() {
return (
<tr>
<td>{this.props.number}</td>
<td>{this.props.cart.product.name}</td>
<td><img src={this.props.cart.product.image} height="50" /></td>
<td>{this.props.cart.product.price}</td>
<td><input type="number" name="quantity" value={this.state.quantity} className="input txtQuantity" onChange={this.onChange} /></td>
<td id="amount_1">{this.props.cart.product.price*this.state.quantity}</td>
<td><button className="btn btn-danger btnDeleteItem" onClick={this.onRemove}><i className="fa fa-close"></i></button></td>
</tr>
)
}
}
export default Cart; |
/*
* Kita
*
* cookies.test.js
*
* Cookie Tests for the Kita JS library
*
* Shann McNicholl (@shannmcnicholl)
*/
define(
['libs/chai', 'sinon', '../../utilities/cookies.js'],
function(chai, sinon, Cookies) {
console.log(" - Running Cookies Test Suite");
var expect = chai.expect;
describe("Cookies should", function() {
beforeEach(function() {
});
afterEach(function() {
Cookies.deleteAll();
});
it("exist", function() {
expect(Cookies).to.be.an("object");
});
it("return an empty object when no cookies are defined", function() {
expect(Cookies.getAll()).to.deep.equal({});
});
it("set the cookie", function() {
Cookies.set("test", "12345", 23);
expect(Cookies.get("test")).to.equal("12345");
});
it("set many cookies", function() {
Cookies.set("test1", "abc", 10);
Cookies.set("test2", "def", 10);
Cookies.set("test3", "ghi", 10);
expect(Cookies.getAll()).to.deep.equal({
"test1": "abc",
"test2": "def",
"test3": "ghi"
});
});
it("delete a cookie", function() {
Cookies.set("test123", "123");
expect(Cookies.delete("test123")).to.be.true;
expect(Cookies.getAll()).to.deep.equal({});
});
it("delete all cookies", function() {
Cookies.set("test1", "abc", 10);
Cookies.set("test2", "def", 10);
Cookies.set("test3", "ghi", 10);
expect(Cookies.deleteAll()).to.be.true;
expect(Cookies.getAll()).to.deep.equal({});
});
});
}); |
import gamePlay from '..';
import getRandom from '../lib/rand';
export default () => {
const description = 'Answer "yes" if number even otherwise answer "no"';
const isNumEven = num => (num % 2 === 0 ? 'yes' : 'no');
const args = () => {
const num = getRandom(100);
const question = String(num);
const correctAnswer = String(isNumEven(num));
return [question, correctAnswer];
};
return gamePlay(description, args);
};
|
var checkSubmitFlg = false;
function checkSubmit() {
if(checkSubmitFlg == true) return false; //当表单被提交过一次后checkSubmitFlg将变为true,根据判断将无法进行提交。
checkSubmitFlg = true;
return true;
}
function myajax(url, params, callback){
//1.创建ajax对象
var xmlHttp = new XMLHttpRequest();
//2.绑定监听函数
xmlHttp.onreadystatechange = function(){
//判断数据是否正常返回
if(xmlHttp.readyState==4&&xmlHttp.status==200){
//6.接收数据
var res = xmlHttp.responseText;
callback(res); //document.getElementById("span1").innerHTML = res;
}
}
//3.绑定处理请求的地址,true为异步，false为同步
//GET方式提交把参数加在地址后面?key1:value&key2:value
xmlHttp.open("POST", url, true);
//4.POST提交设置的协议头（GET方式省略）
xmlHttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
//POST提交将参数，如果是GET提交send不用提交参数
//5.发送请求
xmlHttp.send(params);
}
|
import { connect } from 'react-redux';
import LoadLibrary from '../components/LoadLibrary2';
import { ADD_FILE_FROM_DB } from '../actions/file';
/* this has been replaced with LoadLibrary2 */
function mapDispatchToProps(dispatch) {
return {
addFiles: (docs) =>
dispatch({
type: ADD_FILE_FROM_DB,
files: docs,
}),
};
}
export default connect(null, mapDispatchToProps)(LoadLibrary);
|
import banner from 'Assets/Images/banner.jpg'
import { Button, Col, Row } from 'Components/UI-Library'
import { ROUTER } from 'Constants/CommonConstants'
import React from 'react'
import { Link } from 'react-router-dom'
import './index.less'
export const Banner = () => {
return (
<Row>
<Col className="banner">
<img src={banner} alt="" />
<div className="banner-content">
Reusable
<br />
Face Masks
<div className="mt-lg">
<Link to={ROUTER.Shop}>
<Button className="btn-shop-now">Shop Now</Button>
</Link>
</div>
</div>
</Col>
</Row>
)
}
|
const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const bcrypt = require('bcrypt-nodejs');
//Define model
const userSocialSchema = new Schema({
email:{type:String, unique:true, lowercase:true},
userId:{type:String},
name:{type:String},
});
//model class
const ModelClass = mongoose.model('usersocialauthentication',userSocialSchema);
//export model
module.exports = ModelClass;
|
var Configurations = (function()
{
function _config()
{
this.baseUrl = BASE_URL;
this.api =
{
url: "https://haqdarshak.com/",
services:
{
'save-contact': {id:1001, url:'contact/save'},
'user-login': {id:1002, url:'login'},
'user-registration': {id:1003, url:'register'},
'get-scheme-list': {id:1004, url:'scheme/list'},
'get-scheme-details': {id:1005, url:'scheme/get'},
'get-state-list': {id:1006, url:''},
'get-city-list': {id:1007, url:'data/getCities'},
'get_person': {id:1008, url:'user/getPerson'},
'save-user': {id:1009, url:'user/save'},
'logout': {id:1010, url:'logout'},
'user-forgotPassword': {id:1011, url:'forgotPassword'},
'sub-caste': {id:1012, url:'forgotPassword'},
'save-profile': {id:1013, url:'user/profile'},
'get-profile': {id:1014, url:'user/getProfiles'},
'get-eligible-scheme-list': {id:1015, url:'getEligibleSchemes'},
"save-questionnaire": {id:1016,url:"user/saveQuestionnaire"},
'mark-profile': {id:1017, url:'user/markProfile'},
'user-otpVerify': {id:1018, url:'otpVerify'},
'user-updatePassword': {id:1019, url:'updatePassword'},
'user-fileUpload': {id:1020, url:'fileUpload'},
'bookHaqdarshak': {id:1021, url:'bookHaqdarshak'},
'verify-registration': {id:1022, url:'verifyRegistration'},
'verify-booking': {id:1023, url:'verifyBooking'},
'get-booking-details': {id:1024, url:'getBookingdetails'},
'get-booking-summary': {id:1025, url:'getBookingsummary'},
'get-booking-list': {id:1026, url:'getBookinglist'},
'mb-resend-otp': {id:1027, url:'mbresendotp'},
'reg-resend-otp': {id:1028, url:'reg-resend-otp'},
'forget-resend-otp': {id:1029, url:'forget-resend-otp'},
'state-session': {id:1030, url:'scheme/state-session'},
"org-registration": {id:1031, url:"orgRegister"},
"save_org_payment": {id:1032, url:"saveOrgPayment"},
"get-video-list": {id:1033, url:"scheme/videolist"},
"login-otp-verify": {id:1034, url:"loginOTP"},
"resend-login-otp": {id:1035, url:"resend-login-otp"},
"new-get-video-list": {id:1036, url:"scheme/newvideolist"},
"get-all-videos": {id:1037, url:"scheme/allvideos"}
}
};
this.video =
{
url: "https://haqdarshak.com/assets/schemes/"
};
this.video1 =
{
url: "https://haqdarshak.com/assets/schemes1/"
};
}
return _config;
})();
var CONFIG = new Configurations(); |
import React, { Fragment } from "react";
import PropTypes from "prop-types";
import UserItem from "../user-item/user-item.component";
import Spinner from "../../spinner/spinner.component";
const UserList = ({ loading, users }) => (
<Fragment>
{loading ? (
<Spinner />
) : (
<div style={userListStyle}>
{users.map(user => (
<UserItem key={user.id} user={user} />
))}
</div>
)}
</Fragment>
);
UserList.propTypes = {
loading: PropTypes.bool.isRequired,
users: PropTypes.array.isRequired
};
const userListStyle = {
display: "grid",
gridTemplateColumns: "repeat(3,1fr)",
gridGap: "1rem"
};
export default UserList;
|
#!/usr/bin/env node
// eslint-disable-next-line import/no-unresolved
require('core-js/stable');
require('regenerator-runtime/runtime');
const babelrc = require('../../.babelrc');
require('@babel/register')({ // This will override `node_modules` ignoring - you can alternatively pass
// an array of strings to be explicitly matched or a regex / glob
ignore: [(file) => {
if (file.match(/relient-cli[/\\]src/)) {
return false;
}
return file.match(/node_modules/);
}],
babelrc: false,
...babelrc });
const run = require('../tools/run').default;
if (require.main === module && process.argv.length > 2) {
// eslint-disable-next-line no-underscore-dangle
delete require.cache[__filename];
// eslint-disable-next-line global-require, import/no-dynamic-require
const module = require(`../tools/${process.argv[2]}.js`).default;
run(module).catch((err) => {
console.error(err.stack);
process.exit(1);
});
}
|
import {observable} from 'mobx'
class ListStore {
@observable list = []
addItem(item) {
this.list.push(item);
}
removeItem(index) {
this.list.splice(index, 1);
}
}
const listStore = new ListStore();
export default listStore;
|
import React from 'react'
import { Helmet } from 'react-helmet'
import LoginContainer from '../comps/Login/Login.container'
function LoginPage() {
return (
<React.Fragment>
<Helmet>
<title>Авторизоваться|Education</title>
</Helmet>
<LoginContainer />
</React.Fragment>
)
}
export default LoginPage
|
const express = require('express');
const router = express.Router();
const Note = require('../models/noteModel');
// Add new note
router.route('/notes').post((req, res) => {
const newNote = new Note(req.body);
console.log(req.body);
newNote.save()
.then(res => console.log(res))
.catch(err => console.log(err))
});
// Get all notes
router.route('/notes').get((req, res) => {
Note.find()
.then(result => {
return res.json(result)
}).catch(err => console.log(err))
});
// Get single note
router.route('/notes/:id').get((req, res) => {
Note.findById(req.params.id)
.then(result => res.json(result))
.catch(err => console.log(err))
});
// Edit note
router.route('/notes/:id').put((req, res) => {
Note.findByIdAndUpdate(req.params.id, req.body)
.then(result => res.json(result))
.catch(err => console.log(err))
});
// Delete Note
router.route('/notes/:id').delete((req, res) => {
Note.findByIdAndDelete(req.params.id)
.then(result => res.json(result))
.catch(err => console.log(err))
});
module.exports = router; |
import React from 'react';
import './style.css';
import '../../index.css';
import Svg from './demo.svg';
export default function SvgAndHtml(){
let timeoutID = null;
const c = 2 * Math.PI * 100;
// animation
function getAnimate(){
// 已经在加载动画的话则不再重新加载
if(timeoutID) return;
const nodeID = document.getElementById("cir_ani");
const textNode = document.getElementById("cir_text");
let precent = 1;
timeoutID = setInterval(() => {
if(precent > c){
precent = 0;
}
++precent;
let pp = ((precent / c) * 100).toFixed(0);
textNode.innerHTML = pp + '%';
nodeID.setAttribute("stroke-dasharray", `${precent},${c}`)
}, 50)
}
function stopAnimate(){
if(timeoutID){
clearInterval(timeoutID);
}
timeoutID = null;
}
return (
<div>
<button onClick={getAnimate}>播放动画</button>
<button onClick={stopAnimate}>停止动画</button>
{/* <button className="gradient-border" onClick={getAnimate}>播放动画</button> */}
<svg version="1.1" baseProfile="full" width="1000" height="1000" xmlns="http://www.w3.org/2000/svg" zoomAndPan="magnify">
<defs>
<linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="0%">
<stop offset="0%" style={{stopColor:'#ffff00', stopOpacity:1}} />
<stop offset="50%" style={{stopColor:'#00ff00', stopOpacity:1}} />
<stop offset="100%" style={{stopColor:'#ff0000', stopOpacity:1}} />
</linearGradient>
<radialGradient id="grad2" cx="50%" cy="50%" r="50%" fx="50%" fy="50%">
<stop offset="0%" style={{stopColor:'#ffffff', stopOpacity:0}} />
<stop offset="100%" style={{stopColor:'#0000ff', stopOpacity:1}} />
</radialGradient>
<filter id="f1" x="0" y="0" width="200%" height="200%">
<feOffset result="offOut" in="SourceGraphic" dx="20" dy="20" />
<feBlend in="SourceGraphic" in2="offOut" mode="normal" />
</filter>
</defs>
{/* Rect */}
<rect x="20" y="20" width="300" height="200" fill="red" />
{/* <rect x="20" y="20" width="300" height="200" fill="red" filter="url(#f1)" /> */}
<circle cx="170" cy="120" r="80" fill="green" />
<text x="170" y="145" fontSize="60" textAnchor="middle" fill="white">SVG</text>
{/* circle 圆*/}
<circle cx="500" cy="140" r="120" stroke="orange" strokeWidth="2" fill="white" />
<circle
id="cir_ani"
cx="500"
cy="140"
r="100"
fill="white"
stroke="pink"
strokeWidth="20"
strokeLinecap="round"
strokeDasharray="1,700"
/>
<circle cx="500" cy="140" r="80" fill="white" />
<text id="cir_text" x="470" y="150" fill="red" fontSize="30" strokeWidth="2" stroke="red">circle</text>
{/* rect 矩形 */}
<rect x="20" y="400" width="60" height="40" style={{fill:'yellow', stroke:'black', strokeWidth: 2, fillOpacity:0.5, strokeOpacity:0.6, rx:3 }} />
<text x="25" y="425" fill="black" fontSize="24">rect</text>
{/* ellipse 椭圆*/}
<ellipse cx="80" cy="300" rx="60" ry="40" fill="url(#grad1)" style={{ stroke: 'black', strokeWidth:4 }} />
<ellipse cx="200" cy="300" rx="60" ry="40" fill="url(#grad2)" style={{stroke: 'black', strokeWidth:4 }} />
<ellipse cx="320" cy="300" rx="60" ry="40" style={{fill:'purple', stroke: 'black', strokeWidth:4 }} />
<text x="45" y="310" fontSize="24" fill="white">ellipse</text>
<text x="170" y="310" fontSize="24" fill="white">ellipse</text>
<text x="290" y="310" fontSize="24" fill="white">ellipse</text>
{/* line 直线 */}
<line x1="650" y1="50" x2="690" y2="150" stroke="#34870b" strokeWidth="6" />
<text x="670" y="90" fontSize="30" fill="black">line</text>
{/* polygon 多边形 */}
<polygon
points="800,20,760,40,730,40,760,60,730,80,800,60,850,80,830,60,860,40,830,20"
strokeWidth="1"
stroke="black"
fill="pink"
fillRule="evenodd"
/>
{/* polyline 折线 */}
<polyline points="200,400,260,400,260,440,320,440" stroke="orange" fill="white" strokeWidth="2" fillRule="nozero" />
{/* path 路径 */}
<path d="M300 400 L350 400 T400 400 Z" stroke="purple" strokeWidth="2" />
</svg>
</div>
)
}
|
import './sass/main.scss';
import refs from './js/refs';
import PixabayApiServise from './js/apiService';
import ImageItemTemplate from './templates/ImageItemTemplate';
import '@pnotify/core/dist/BrightTheme.css';
import { info, error } from '@pnotify/core';
refs.searchForm.addEventListener('submit', onSearch);
refs.loadMore.addEventListener('click', onLoadMore);
const apiServise = new PixabayApiServise();
function onSearch(e){
e.preventDefault();
apiServise.query = e.currentTarget.elements.query.value;
if (apiServise.query === '') {
return error({
text: 'Please, enter a text!',
delay: 500,
});
}
apiServise.resetPage();
clearListItems();
onLoadMore();
}
function onLoadMore(e) {
apiServise
.fetchImages()
.then(data => onMarkUp(data))
.catch(data => alert(`Ошибка: ${data}`));
}
function onMarkUp(data) {
refs.loadMore.style.display = 'block';
refs.gallery.insertAdjacentHTML('beforeend', ImageItemTemplate(data));
}
function clearListItems(){
refs.gallery.innerHTML = '';
} |
/**
* This file contains the basic configuration for the api calls
* @author Ericky Dos Santos
* @file api.js
*/
import axios from 'axios';
import { API_METHOD_GET, API_METHOD_POST } from 'rdx/constants';
const {
REACT_APP_API_ENDPOINT,
} = process.env;
// Base url of the node server
export const BASE_URL = `${REACT_APP_API_ENDPOINT}/api/`;
/**
* All endpoints of the aplication.
* The rdx modules uses this variable to create actions/reducers/selectors/types.
* Actions will be named in the following convention:
* getTestRequest, getTestSuccess, getTestError, getTestReset
* postTestRequest, postTestSuccess, postTestError, postTestReset
* Reducers will be named in the following convention:
* testData
* postTestData
* Selectors will be named in the following convention:
* getTestData
* getPostTestData
* Types will be named in the following convention:
* GET_TEST_DATA_REQUEST, GET_TEST_DATA_SUCCESS, GET_TEST_DATA_ERROR, GET_TEST_DATA_RESET
* POST_TEST_DATA_REQUEST, POST_TEST_DATA_SUCCESS, POST_TEST_DATA_ERROR, POST_TEST_DATA_RESET
*/
export const API_ENDPOINTS = {
[API_METHOD_GET]: {},
[API_METHOD_POST]: {},
};
export const api = axios.create({
baseURL: BASE_URL,
timeout: 1000,
});
|
var Store = require('flux/utils').Store;
var FollowConstants = require('../constants/follow_constants.js');
var AppDispatcher = require('../dispatcher/dispatcher.js');
var FollowStore = new Store(AppDispatcher);
var _follows = {};
var _allFollowers = {};
var _allFollowing = {};
var updateFollows = function(yourObject, otherUserObject, userId, currentUserId) {
if ( _allFollowers[userId] === undefined ) {
_allFollowers[userId] = {};
// to pervent fetchCount from erroring out at _allFollowing[userId]
// also I want user follower following object to be complete
_allFollowing[userId] = {};
}
if ( _allFollowers[currentUserId] === undefined ) {
_allFollowers[currentUserId] = {};
_allFollowing[currentUserId] = {};
}
if ( yourObject ) {
_allFollowers[userId][currentUserId] = yourObject;
_allFollowing[currentUserId][userId] = otherUserObject;
} else if ( yourObject === null ) {
// MUST be null to delete
delete _allFollowers[userId][currentUserId];
delete _allFollowing[currentUserId][userId];
}
};
var updatePile = function( set, userId ) {
var followers = {};
var following = {};
var types = ["followers", "followees"];
var objects = [ followers, following ];
for (var i = 0; i < Math.max( set.followers.length, set.followees.length ); i++) {
for (var j = 0; j < types.length; j++) {
if ( set[types[j]][i] ) {
objects[j][set[types[j]][i].id] = set[types[j]][i];
}
}
}
// looks something like _allFollowers = { userId: { followerId: { his/her data }, anotherFollowerId: { his/her data } ... } }
_allFollowers[userId] = followers;
_allFollowing[userId] = following;
};
FollowStore.fetchFollowStatus = function( userId, currentUserId ) {
if ( _allFollowers[userId] && _allFollowers[userId][currentUserId] ) {
// the first condition accounts of mulitple asyn calls on Index page
// second condition ensures _allFollowers[userId] !== {}
return true;
} else {
return false;
}
};
FollowStore.fetchCount = function( userId ) {
return { followersCount: Object.keys(_allFollowers[userId]).length, followingCount: Object.keys(_allFollowing[userId]).length };
};
FollowStore.fetchAllUsers = function( userId, type ) {
if ( type === "followers" ) {
return _allFollowers[userId];
} else if ( type === "following" ) {
return _allFollowing[userId];
}
};
FollowStore.__onDispatch = function(payload) {
switch( payload.actionType ) {
case FollowConstants.FETCH_FOLLOW_OBJECT:
updateFollows(payload.yourObject, payload.otherUserObject, payload.userId, payload.currentUserId);
FollowStore.__emitChange();
break;
case FollowConstants.TOGGLE_FOLLOW:
updateFollows(payload.yourObject, payload.otherUserObject, payload.userId, payload.currentUserId);
FollowStore.__emitChange();
break;
case FollowConstants.ALL_FOLLOWERS_AND_FOLLOWEES:
updatePile( payload.set, payload.userId );
FollowStore.__emitChange();
break;
}
};
module.exports = FollowStore;
|
import React from 'react';
import {BrowserRouter, Route} from 'react-router-dom';
import Student from './Student';
import Scst from './Scst'
import Internal from './Internal'
class App extends React.Component {
render() {
return (
<div>
<BrowserRouter>
<div>
<Route exact path="/" component={Student} />
<Route exact path="/internal" component={Internal}/>
<Route exact path="/scst" component={Scst}/>
</div>
</BrowserRouter>
</div>
);
}
}
export default App;
|
var fs = require('fs'),
groups = module.parent.require('./groups'),
winston = module.parent.require('winston'),
Meta = module.parent.require('./meta'),
Sockets = module.parent.require('./socket.io/plugins'),
User = module.parent.require('./user'),
Emailer = module.parent.require('./emailer'),
Plugins = module.parent.require('./plugins'),
nconf = module.parent.require('nconf'),
Invitation = {},
invitedUsers = [],
invitedGroup = null,
uninvitedGroup = null,
nonapprovedUserGroup = null,
approvedUserGroup = null;
function sendInvite(email, group) {
var url = nconf.get('url') + (nconf.get('url').slice(-1) === '/' ? '' : '/');
if (!group) {
Plugins.fireHook('action:email.send', {
to: email,
from: Meta.config['email:from'] || 'no-reply@localhost.lan',
subject: "Invitation to join " + url,
html: 'Join us by visiting <a href="' + url + 'register">' + url + 'register</a>',
plaintext: 'Join us by visiting ' + url + 'register'
});
}else{
Plugins.fireHook('action:email.send', {
to: email,
from: Meta.config['email:from'] || 'no-reply@localhost.lan',
subject: "Invitation to join the group " + invitedGroup + " at " + url,
html: 'Join the group ' + invitedGroup + ' by visiting <a href="' + url + 'invitation/' + email + '">' + url + 'invitation/' + email + '</a>',
plaintext: 'Join the group ' + invitedGroup + ' by visiting ' + url + 'invitation/' + email,
});
}
}
Invitation.init = function(params, callback) {
Sockets.invitation = {
check: function (socket, data, callback) {
User.email.available(data.email, function (err, available) {
if (available) {
if (Plugins.hasListeners('action:email.send')) {
sendInvite(data.email);
} else {
winston.warn('[emailer] No active email plugin found!');
}
callback();
}else{
if (!invitedGroup) {
callback(new Error('[[fail_email_taken]]'));
}else{
User.getUidByEmail(data.email, function (err, uid) {
if (!err && uid) {
groups.getUserGroups([uid], function (err, payload) {
var alreadyInvited = false;
payload = payload[0];
for (var i in payload) {
if (payload[i].name.toLowerCase() === invitedGroup.toLowerCase()) alreadyInvited = true;
}
if (!alreadyInvited) {
if (Plugins.hasListeners('action:email.send')) {
sendInvite(data.email, true);
callback();
} else {
winston.warn('[emailer] No active email plugin found!');
callback();
}
callback();
}else{
callback(new Error('[[fail_already_invited]]'));
}
});
}else{
if (!err) {
callback(new Error('[[fail_already_invited]]'));
}else{
callback(new Error('[[fail_database_error]]'));
}
}
});
}
}
});
},
setInvitedUsers: function (socket, data, callback) {
winston.info(data);
Meta.settings.setOne('newuser-invitation', 'invitedUsers', JSON.stringify(data.users), function (err, data) {
Invitation.sync();
});
callback();
},
send: function (socket, data, callback) {
sendInvite(data.email, invitedGroup || uninvitedGroup);
callback();
}
};
function render(req, res, next) {
res.render('admin/plugins/newuser-invitation', {});
}
Invitation.sync();
params.router.get('/admin/plugins/newuser-invitation', params.middleware.admin.buildHeader, render);
params.router.get('/api/admin/plugins/newuser-invitation', render);
params.router.get('/invitation/:email', function (req, res, next) {
winston.info(invitedUsers);
if (!!~invitedUsers.indexOf(req.params.email) && invitedGroup) {
groups.exists(invitedGroup, function (err, exists) {
if (!err && exists) {
User.getUidByEmail(req.params.email, function (err, uid) {
if (!err && uid) {
groups.join(invitedGroup, uid);
invitedUsers.splice(invitedUsers.indexOf(req.params.email), 1);
Meta.settings.setOne('newuser-invitation', 'invitedUsers', JSON.stringify(invitedUsers));
res.send("You have been added to the group " + invitedGroup + "! " + nconf.get('url') + 'groups/' + invitedGroup + " ");
}else{
res.send("Invitation Expired.");
winston.warn(req.params.email + " tried to join group " + invitedGroup + " but it was not possible!");
}
});
}else{
res.send("Invitation Expired.");
winston.warn(req.params.email + " tried to join group " + invitedGroup + " but it doesn't exist!");
}
});
}else{
res.send("Invitation Expired.");
if (invitedGroup) {
winston.warn(req.params.email + " tried to join group " + invitedGroup + " but was not invited!");
}else{
winston.warn(req.params.email + " tried to join the invited group but it doesn't exist!");
}
}
});
callback();
};
Invitation.sync = function () {
Meta.settings.get('newuser-invitation', function(err, settings) {
winston.info(settings);
try {
invitedUsers = settings.invitedUsers ? JSON.parse(settings.invitedUsers) : [];
}catch(e){
invitedUsers = [];
Meta.settings.setOne('newuser-invitation', invitedUsers, '[]');
}
invitedGroup = settings.invitedGroup ? settings.invitedGroup : null;
uninvitedGroup = settings.uninvitedGroup ? settings.uninvitedGroup : null;
// approvedUserGroup = settings.approvedUserGroup;
// nonapprovedUserGroup = settings.nonapprovedUserGroup;
if (uninvitedGroup == null && invitedGroup == null) {
winston.warn('[plugins/newuser-invitation] Restricting new user registration to invited users only!!!');
}
});
};
Invitation.moveUserToGroup = function(userData) {
var invited = invitedUsers ? invitedUsers.indexOf(userData.email) : -1;
// If invited, add to invited group.
if (!!~invited) {
if (invitedGroup != null) {
invitedUsers.splice(invited, 1);
Meta.settings.setOne('newuser-invitation', 'invitedUsers', JSON.stringify(invitedUsers));
groups.exists(invitedGroup, function (err, exists) {
if (!err && exists) {
groups.join(invitedGroup, userData.uid);
}else{
winston.warn('[plugins/newuser-invitation] Invited Group does not exist!');
}
});
}
// If not invited, add to uninvited group.
}else{
if (uninvitedGroup != null) {
groups.exists(uninvitedGroup, function (err, exists) {
if (!err && exists) {
groups.join(uninvitedGroup, userData.uid);
}else{
winston.warn('[plugins/newuser-invitation] Uninvited Group does not exist!');
}
});
}
}
};
Invitation.checkInvitation = function(data, next) {
Invitation.sync();
// Don't restrict registration if invite groups are set.
if (invitedGroup || uninvitedGroup) return next(null, data);
var invited = invitedUsers ? invitedUsers.indexOf(data.userData.email) : -1;
if (!!~invited) {
invitedUsers.splice(invited, 1);
Meta.settings.setOne('newuser-invitation', 'invitedUsers', JSON.stringify(invitedUsers));
return next(null, data);
}else{
return next(new Error('[[error:not-invited]] ' + data.userData.email));
}
};
Invitation.admin = {
menu: function(custom_header, callback) {
custom_header.plugins.push({
"route": '/plugins/newuser-invitation',
"icon": 'fa-check',
"name": 'New User Invitation'
});
callback(null, custom_header);
}
};
module.exports = Invitation;
|
var Game = require('../models/game');
function getAllGames(req, res){
Game
.find()
.exec(function(err,games){
if(err){
console.log(err)
} else
res.json(games);
});
}
function addGame(req, res){
var game = new Game();
console.log(req.body)
game.name = req.body.name;
game.save((err,t) => {
if(err)
res.json(err)
res.json(t)
});
}
module.exports = {getAllGames,addGame}; |
'use strict';
const heredoc = require('heredoc'),
sendQuery = require('./helpers/accessDb').sendQuery;
const getUserQuery = heredoc(function () {/*
SELECT key
FROM users
WHERE wallet_id = ?;
*/});
const updateLocationQuery = heredoc(function () {/*
UPDATE locations
SET latitude = $latitude, longitude = $longitude
WHERE user_id = $user_id;
*/});
const updateUserWithLocationQuery = heredoc(function () {/*
UPDATE users
SET location = $location_key
WHERE key = $user_id;
*/});
const getAllLocations = heredoc(function () {/*
SELECT key
FROM locations
WHERE user_id = ?;
*/});
const checkLocationAndUpdateUser = function(user_id) {
let locationKey;
sendQuery(getAllLocations, user_id, (err, rows) => {
if (err) {
throw err;
} else {
locationKey = rows[0];
if (locationKey) {
sendQuery(updateUserWithLocationQuery, {
$location_key: locationKey.key,
$user_id: user_id
}, (err) => {
if (err) {
throw err
}
})
}
}
})
}
const updateLocation = function(latitude, longitude, user_wallet_id) {
let user;
if (!(sendQuery instanceof Error)) {
sendQuery(getUserQuery, user_wallet_id, (err, rows) => {
if (err) {
throw err;
} else {
user = rows[0];
if (user) {
sendQuery(updateLocationQuery, {
$latitude: latitude,
$longitude: longitude,
$user_id: user.key
}, (err) => {
if (err) {
throw err;
} else {
checkLocationAndUpdateUser(user.key);
}
});
}
}
});
}
}
module.exports = updateLocation;
|
module.exports = {
// rootURL:'/',
location: 'hash',
// location:'history'
};
|
import Store from './store';
export * from './initState';
export {
Store,
};
|
const fs = require('fs');
const path = require('path');
const pathToRegexp = require('path-to-regexp');
module.exports = (options) => {
let routes = fs.readFileSync(options.routes, 'utf8')
.split(/\r|\n/)
.filter((line) => {
return line && !/^[;|#|/]/g.test(line);
}).map((line) => {
let parts = String(line).trim().split(/\s+/);
if (parts.length == 4) {
let module = parts[ 3 ].split('#');
return {
method: parts[ 0 ],
path: parts[ 1 ],
file: module[ 0 ],
name: module[ 1 ]
};
}
});
routes = routes.map((route) => {
let file = path.join(options.controllers, route.file);
try {
let keys = [];
route.func = require(file)[ route.name ];
route.regexp = pathToRegexp(route.path, keys);
route.keys = keys;
return route;
} catch (e) {
console.error('can not resolve %s', file, e.stack);
}
});
function matches(ctx, method) {
if (!method) { return true; }
if (ctx.method.toUpperCase() === method.toUpperCase()) { return true; }
if (method === 'GET' && ctx.method === 'HEAD') { return true; }
return false;
}
return async function(ctx, next) {
let route = routes.filter((r) => {
if (!matches(ctx, r.method)) return false;
if (r.regexp.test(ctx.path)) return true;
});
if (route && route.length && typeof route[ 0 ].func === 'function') {
ctx.params = {};
let matchs = route[ 0 ].regexp.exec(ctx.path).slice(1);
route[ 0 ].keys.forEach((key, index) => {
ctx.params[ key.name ] = matchs[ index ];
});
await route[ 0 ].func.apply(ctx);
} else {
await next();
}
};
};
|
import TableProducts from './components/TablePodructs.jsx';
import './App.css';
function App() {
return (
<div>
<TableProducts />
</div>
);
}
export default App;
|
define([], function(){
return 'ktulhu_7';
}); |
const quizzes = [
{
"topic": "Norway",
"questions": [
{
"question": "What is the capital of Norway?",
"answers": [
"Oslo",
"Trondheim",
"Ålesund",
"Bergen"
],
"correctAnswer": 0
},
{
"question": "What is the currenct in Norway?",
"answers": [
"Euro",
"Krone",
"Pound",
"Dollar"
],
"correctAnswer": 1
},
{
"question": "Norway is not a member of ",
"answers": [
"The European Union",
"North Atlantic Treaty Organization",
"World Trade Organization",
"International Organization for Standardization"
],
"correctAnswer": 0
},
{
"question": "In 1905, which country did Norway become officially independent from?",
"answers": [
"Great Britain",
"Denmark",
"Sweden",
"Finland"
],
"correctAnswer": 2
},
{
"question": "The indigenous people of Norway are known as",
"answers": [
"Maya",
"Basque",
"Ojibew",
"Sami"
],
"correctAnswer": 3
},
{
"question": "In 1905, which country did Norway become officially independent from?",
"answers": [
"Great Britain",
"Denmark",
"Sweden",
"Finland"
],
"correctAnswer": 2
},
{
"question": "Which of the following is most rude according to Norwegian social codes?",
"answers": [
"Getting drunk in front of your superiors",
"Leaving a party without saying goodbye",
"Talking to a stranger sitting next to you on a bus",
"Not talking to anyone"
],
"correctAnswer": 2
}
]
},
{
"topic": "ReactJS",
"questions": [
{
"question": "JSX is typesafe",
"answers": [
"True",
"False"
],
"correctAnswer": 0
},
{
"question": "Which is the smallest building block in ReactJS?",
"answers": [
"None of these",
"Props",
"Components",
"Elements"
],
"correctAnswer": 3
},
{
"question": "In React state can be accessed using",
"answers": [
"current",
"state",
"current()",
"state()"
],
"correctAnswer": 1
},
{
"question": "How can we prevent default behavior in React?",
"answers": [
"None of these",
"revokeDefault()",
"preventDefault()",
"avoidDefault()"
],
"correctAnswer": 2
},
{
"question": "Invoked only once on the client, after rendering",
"answers": [
"componentDidMount",
"componentWillMount",
"shouldComponentUpdate",
"componentWillUnmount"
],
"correctAnswer": 0
},
{
"question": "Lifecycle methods are mainly used to..",
"answers": [
"Keep track of event history",
"To enhance components",
"Free up resources",
"None of these"
],
"correctAnswer": 2
},
]
}
];
function getRandomQuiz() {
return quizzes[Math.floor(Math.random()*quizzes.length)];
}
module.exports = {getRandomQuiz}; |
/**
* Rend le fonctionnement d'un formulaire en ajax pour un système de filtre produit par exemple
*
* ## Exemple :
*
* <form class="js-ajax-filter" action="...." data-target="#content">
* ....
* </form>
* <div id="content">
*
* </div>
*/
const options = {
selector: '.js-ajax-filter',
loadingClass: 'is-loading'
}
export default function ({ selector, loadingClass } = options) {
const onSubmit = async function (e) {
e.preventDefault()
const form = e.target
const targetSelector = form.dataset.target
if (form.classList.contains(loadingClass)) return
form.classList.add(loadingClass)
try {
let action = form.getAttribute('action')
if (action.startsWith('//')) action = location.protocol + action
const url = new URL(action)
const data = new FormData(form)
const urlParts = url.href.split('#')
let anchor = null
if (urlParts.length > 1) {
anchor = '#' + urlParts[1]
}
url.search = new URLSearchParams(data)
const response = await fetch(url).then(r => r.text())
const fragment = document.createRange().createContextualFragment(response)
const content = fragment.querySelector(targetSelector)
const title = fragment.querySelector('title').innerHTML
const target = document.querySelector(targetSelector)
target.parentNode.replaceChild(content, target)
history.replaceState({}, title, url)
if (anchor !== null) {
document.querySelector(anchor).scrollIntoView({ behavior: 'smooth', block: 'start', inline: 'start' })
}
} catch (e) {
alert(e)
}
form.classList.remove(loadingClass)
}
document.querySelectorAll(selector).forEach(form => form.addEventListener('submit', onSubmit))
}
|
import estraverse from 'estraverse'
import { generate } from 'escodegen'
import esutils from 'esutils'
import _ from 'lodash'
var cartesianIterable = function(array1, array2) {
return {
[Symbol.iterator]: function* () {
if (array1 === array2) {
for (let i = 0; i < array1.length; i++) {
for (let j = i + 1; j < array2.length; j++) {
yield [array1[i], array2[j]];
}
}
} else {
for (let i = 0; i < array1.length; i++) {
for (let j = 0; j < array2.length; j++) {
yield [array1[i], array2[j]];
}
}
}
}
};
};
var findClones = ast => {
var clones = []; // each clone is an array of 2 or more nodes
var ifNodes = [];
var paramExprs = [];
estraverse.traverse(ast, {
enter: (node, parent) => {
},
leave: (node, parent) => {
if (node.type === "IfStatement") {
ifNodes.push(node);
} else if (esutils.ast.isExpression(node) && parent.type === "CallExpression") {
// TODO: create a function to measure the size of the expression
if (node.type === "BinaryExpression") {
paramExprs.push(node);
}
}
}
});
console.log("");
console.log("redundant if statements");
for (let [first, second] of cartesianIterable(ifNodes, ifNodes)) {
// TODO replace _.isEqual with a custom compare function which ignores location data
// TODO: look at complexity of the statement
// if it's a single function call or a single logic operator then it's okay
// but if there's a lot of logic or math that's repeated then it should probably have its own function
if (_.isEqual(first.test, second.test)) {
console.log(`"${generate(first.test)}" = "${generate(second.test)}"`);
}
}
// TODO: provide options to the comparison function that allow for close matches
// e.g. mouseY >= btnMinY && mouseY <= btnMaxY ... is similar to
// mouseY > btnMinY && mouseY < btnMaxY
console.log("");
// TODO: count how many times they're repeated
var count = 0;
console.log("redundant binary expressions (used as arguments)");
for (let [first, second] of cartesianIterable(paramExprs, paramExprs)) {
if (_.isEqual(first, second)) {
console.log(`"${generate(first)}" = "${generate(second)}"`);
if (count++ > 5) {
break;
}
}
}
// TODO: repeated calls to the same method with the same paramters
// TODO: making the same call inside the "if" and "else" blocks -> pull it outside
return clones;
};
export { findClones };
|
var searchData=
[
['name',['name',['../interface_c1_connector_offer.html#a6c64624a2579f62538634568f7972525',1,'C1ConnectorOffer']]],
['nickname',['nickname',['../interface_c1_connector_user_master_data.html#a60223ec1e4216d015a063f4e272012d8',1,'C1ConnectorUserMasterData']]]
];
|
import React from "react";
import FullPageImage from "../common/FullWidthImage";
import Layer from "../common/Layer";
export default function SelectTopic(props) {
let selectedIndex = props.index;
let topics = props.topics;
let onClickArrow = (offset) => {
if ((selectedIndex === 0 && offset === -1) || (selectedIndex === topics.length - 1 && offset === 1)) {
return;
}
props.changeSelectedIndex(selectedIndex + offset);
}
return (
<div className="select-quiz-container">
<FullPageImage image={topics[selectedIndex].bgImg} alt={topics[selectedIndex].name} />
<Layer />
<div className="container">
<div className="description">
<p>{topics[selectedIndex].name}</p>
<p>{topics[selectedIndex].description}</p>
</div>
<div className="list-container">
<div className={"list selected-" + selectedIndex}>
{topics.map((topic, index) =>
<div className={"list-item" + (index === selectedIndex ? " selected" : "")} key={index} onClick={() => props.changeSelectedIndex(index)} >
<img src={topic.primaryImg} alt={topic.name} />
</div>
)}
</div>
</div>
<div className="arrows">
<div className="arrow left-arrow" onClick={() => onClickArrow(-1)}></div>
<div className="arrow right-arrow" onClick={() => onClickArrow(1)}></div>
</div>
<div className="start" onClick={ () => props.onClickStart() }>Start</div>
</div>
</div>
)
} |
import gen from '../helpers/idGenerator'
export default {
Query: {
allNews: (root,args,{models}) => {
return models.News.findAll()
},
newsByCategory: (root,args,{models})=>{
return models.News.findAll({where:{CategoryId:args.categoryId}})
},
news: (root,args,{models}) =>{
return models.News.findById(args.id)
}
},
News: {
author: (news) =>{
return news.getUser()
},
category: (news) =>{
return news.getCategory()
},
comment: (news)=>{
return news.getComments()
},
pictures: (news) =>{
return news.getFiles()
}
},
Mutation: {
addNews: async (root, args,{models}) => {
const newNews = await models.News.create({
id:gen(),
UserId:args.userId,
CategoryId:args.categoryId,
title: args.title,
clickCount:0,
content:args.content,
isFeatured:args.featured,
pictureDetail:args.pictureDetail
});
const file = await models.File.create({
id:gen(),
path:args.picturePath,
NewsId:newNews.id
})
return newNews;
},
updateClickCount: async(root,args,{models})=>{
const thisNews = await models.News.findById(args.newsId)
const updateClick = await thisNews.update({clickCount:thisNews.clickCount+1})
return updateClick
},
editNews: async (root,args,{models}) =>{
const news = await models.News.findById(args.newsId)
const edit = await news.updateAttributes(args)
const destroy = await models.File.destroy({where:{NewsId:news.id}})
const file = await models.File.create({
id:gen(),
path:args.picturePath,
NewsId:news.id
})
return news
}
},
}; |
var data = 2;
//透過被賦予的值，以require載入資料
//module.exports = data;
module.exports = {
content: data,
title: 'title'
};
|
tripnoutApp.controller('myTutorials', function($rootScope, $scope, $location, $state, $stateParams, $mdToast, $animate, Auth, Trip, Tutorial) {
//get info if a person is logged in
$scope.loggedIn = Auth.isLoggedIn();
Auth.getUser()
.success(function(data) {
console.log(data);
$scope.myData = data;
});
}); |
function Slide() {
console.log("slide");
var logo = document.getElementById("fullscreenDiv");
TweenLite.to(logo, 0.5, {
ease:Sine.easeOut,
right: "0%"
//backgroundColor: "black",
// borderBottomColor: "#90e500",
// color: "white"
});
var logo2 = document.getElementById("middle");
TweenLite.to(logo2, 1.0, {
ease:Expo.easeIn,
right: "0%"
});
}
function SlideBack() {
var logo = document.getElementById("fullscreenDiv");
TweenLite.to(logo, 0.3, {
ease:Sine.easeOut,
right: "-100%"
//backgroundColor: "black",
// borderBottomColor: "#90e500",
// color: "white"
});
var logo2 = document.getElementById("middle");
TweenLite.to(logo2, 0.7, {
ease:Sine.easeIn,
right: "-100%"
//backgroundColor: "black",
// borderBottomColor: "#90e500",
// color: "white"
});
}
function setCore() {
console.log(1);
text.innerHTML = "<h1>Core Cell</h1>";
Slide();
}
function setEcell() {
console.log(2);
var text = document.getElementById("text");
text.innerHTML = "<h1>E Cell</h1>";
Slide();
}
function setRobo() {
console.log(3);
var text = document.getElementById("text");
text.innerHTML = "<h1>Robo Cell</h1>";
Slide();
}
function setRDI() {
console.log(4);
var text = document.getElementById("text");
text.innerHTML = "<h1>RD&I Cell</h1>";
Slide();
}
function setWDCT() {
console.log(5);
var text = document.getElementById("text");
text.innerHTML = "<h1>WDCT</h1>";
Slide();
} |
import { addDecorator } from '@storybook/react'
import withThemeProvider from './theme-decorator'
addDecorator(withThemeProvider)
|
import React from 'react';
import './styles.css';
import heroesImg from '../../assets/heroes.png';
import heroesLogo from '../../assets/logo.svg';
import {FiLogIn} from 'react-icons/fi';
export default function Logon() {
return (
<div className="logon-container">
<section className="form">
<img src={heroesLogo} alt="logo" />
<form>
<h1>Faça seu logon</h1>
<input placeholder="Sua ID" />
<button className="button" type="submit">Entrar</button>
<a href="/register">
<FiLogIn size="16" color="#E02041" />
Não tenho cadastro
</a>
</form>
</section>
<img src={heroesImg} alt="heroes" />
</div>
);
}
|
(function() {
'use strict';
angular
.module('atentamente')
.controller('TopNavController', TopNavController);
function TopNavController($scope, Auth, authModal) {
var vm = this
vm.signedIn = Auth.isAuthenticated
vm.logout = Auth.logout
vm.openRegister = function() {
authModal.openRegister()
}
vm.openLogin = function() {
authModal.openLogin()
}
Auth.currentUser().then(function (user){
vm.user = user
})
$scope.$on('devise:login', function (e, user){
vm.user = user
})
$scope.$on('devise:logout', function (e, user){
vm.user = {}
})
}
})();
|
const profiles = require('./resizer_profiles.json');
console.log(profiles); |
import Node from './Node.js';
import Edge from './Edge.js';
import Region from './Region.js';
class SproutsBoard {
regions;
nodes;
edges;
constructor() {
this.regions = [
new Region([], []),
];
this.nodes = [];
this.edges = [];
}
getRegionOfXy(x, y) {
// this is wrong
return this.regions[0];
}
addUnconnectedNode(x, y) {
var region = this.getRegionOfXy(x, y);
var node = new Node(x, y, [region]);
this.nodes.push(node);
}
addEdgeWithNode(src, dst, x, y) {
var region = this.getRegionOfXy(x, y);
var mid = new Node(x, y, [region]);
var wssm = [], wsmd = [];
if (src == dst) {
var dx = mid.x - src.x;
var dy = mid.y - src.y;
var wssm = [{
x: src.x + dx / 2 + dy / 2,
y: src.y + dy / 2 - dx / 2,
}];
var wsmd = [{
x: src.x + dx / 2 - dy / 2,
y: src.y + dy / 2 + dx / 2,
}];
}
var esm = new Edge(src, mid, wssm);
var emd = new Edge(mid, dst, wsmd);
mid.edges = [esm, emd];
src.edges.push(esm);
dst.edges.push(emd);
this.nodes.push(mid);
this.edges.push(esm);
this.edges.push(emd);
this.maybeSplitRegion(mid);
}
maybeSplitRegion(mid) {
var origRegion = mid.regions[0];
var l = mid.edges[0].getOtherEnd(mid);
var r = mid.edges[1].getOtherEnd(mid);
var e1 = l.dfs(r, [mid], node => {
return node.regions.filter(r => r === origRegion).length > 0;
})
if (e1) {
e1.unshift(mid);
var nr = new Region(e1, []);
e1.forEach(node => {
node.regions.push(nr);
if (node !== l && node !== r && node !== mid) {
node.regions = node.regions.filter(r => r !== origRegion);
}
});
this.regions.push(nr);
}
console.log(e1);
}
}
export default SproutsBoard;
|
const express = require('express');
const app = express();
const port = 3000;
const connection = require('./conf');
const parser = require("body-parser");
app.use(parser.json());
app.use(parser.urlencoded({
extended: true
}));
app.get('/api/movies', (req, res) => {
if (req.query.rating) {
let sql = 'SELECT * FROM movie';
const sqlValues = [];
sql += ' WHERE rating = ?';
sqlValues.push(req.query.rating);
// send an SQL query to get all employees
connection.query(sql, sqlValues, (err, results) => {
if (err) {
// If an error has occurred, then the client is informed of the error
res.status(500).send(`An error occurred: ${err.message}`);
} else {
// If everything went well, we send the result of the SQL query as JSON
res.json(results);
}
});
}
else if (req.query.genre) {
let sql = 'SELECT * FROM movie';
const sqlValues = [];
sql += ' WHERE genre = ?';
sqlValues.push(req.query.genre);
// send an SQL query to get all employees
connection.query(sql, sqlValues, (err, results) => {
if (err) {
// If an error has occurred, then the client is informed of the error
res.status(500).send(`An error occurred: ${err.message}`);
} else {
// If everything went well, we send the result of the SQL query as JSON
res.json(results);
}
});
}
else {
connection.query('SELECT * FROM movie', (err, results) => {
if (err) {
res.status(500).send('Erreur lors de la récupération des films');
} else {
res.json(results);
};
})
}
});
app.get('/api/movies/:id', (req, res) => {
const movieId = req.params.id;
connection.query('SELECT * FROM movie WHERE id=?', [movieId], (err, results) => {
if (err) {
res.status(500).send(`An error occurred: ${err.message}`);
}
if (results.length === 0) {
return res.status(404).send('Movie not found');
}
return res.json(results[0]);
});
});
// app.get('/api/movies', (req, res) => {
// let sql = 'SELECT * FROM movie';
// const sqlValues = [];
// if (req.query.rating) {
// sql += ' WHERE rating = ?';
// sqlValues.push(req.query.rating);
// }
// // send an SQL query to get all employees
// connection.query(sql, sqlValues, (err, results) => {
// if (err) {
// // If an error has occurred, then the client is informed of the error
// res.status(500).send(`An error occurred: ${err.message}`);
// } else {
// // If everything went well, we send the result of the SQL query as JSON
// res.json(results);
// }
// });
// });
// ************ Données Employee ******************
// app.get('/api/employees', (req, res) => {
// const employeeId= req.params.id;
// connection.query('SELECT * FROM employee', (err, results) => {
// if (err) {
// res.status(500).send('Erreur lors de la récupération de employée');
// } else {
// res.json(results);
// };
// });
// });
// app.get('/api/employees/:id', (req, res) => {
// const employeeId= req.params.id;
// connection.query('SELECT * FROM employee WHERE id=?', [employeeId], (err, results) => {
// if (err) {
// res.status(500).send(`An error occurred: ${err.message}`);
// }
// if (results.length === 0) {
// return res.status(404).send('Employee not found');
// }
// return res.json(results[0]);
// });
// });
// app.get('/api/employees', (req, res) => {
// let sql = 'SELECT * FROM employee';
// const sqlValues = [];
// if (req.query.department) {
// sql += ' WHERE department = ?';
// sqlValues.push(req.query.department);
// }
// // send an SQL query to get all employees
// connection.query(sql, sqlValues, (err, results) => {
// if (err) {
// // If an error has occurred, then the client is informed of the error
// res.status(500).send(`An error occurred: ${err.message}`);
// } else {
// // If everything went well, we send the result of the SQL query as JSON
// res.json(results);
// }
// });
// });
app.listen(port, (err) => {
if (err) {
throw new Error('Something bad happened...');
}
console.log(`Server is listening on ${port}`);
});
|
import { createActions } from 'redux-yo';
export const paymentsActions = createActions(
['setPayments', 'watchPayments', 'stopWatchPayments', 'reset'],
'payments'
);
|
'use strict';
var localforage = require('localforage');
localforage.config({
driver: localforage.LOCALSTORAGE,
name: 'justStorage',
storeName: 'pageStorage',
description: 'page-local storage for EventStore.'
});
module.exports = localforage;
|
const { Schema, model } = require('mongoose');
const courseMemberSchema = new Schema({
courseId: {
type: Schema.Types.ObjectId,
ref: 'Courses',
required: true,
minlength: 6,
maxlength: 255,
trim: true,
},
alumn: {
type: Schema.Types.ObjectId,
ref: "Users",
required: true,
minlength: 6,
maxlength: 255,
trim: true,
},
});
module.exports = model('CourseMembers', courseMemberSchema);
|
"use strict";
exports.default = void 0;
var _uiGrid_core = _interopRequireDefault(require("../grid_core/ui.grid_core.utils"));
var _uiGrid_core2 = _interopRequireDefault(require("../grid_core/ui.grid_core.modules"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
var _default = _extends({}, _uiGrid_core2.default, _uiGrid_core.default, {
modules: []
});
exports.default = _default;
module.exports = exports.default;
module.exports.default = exports.default; |
import React, { Component } from 'react';
class game extends Component {
constructor(props) {
super(props);
this.state = {
name : '',
ops : [],
min : '',
max: '',
firstR: localStorage.getItem("from"),
lastR: localStorage.getItem("from"),
op : '',
first : '',
second : '',
answer: '',
input : '',
seconds : 30,
score : 0
}
this.onChange = this.onChange.bind(this);
this.countDown = this.countDown.bind(this);
}
componentDidMount() {
console.log(localStorage.getItem("garr"));
if(localStorage.getItem("garr") === null || !localStorage.getItem("garr")){this.props.history.push("/"); return;}
const min = localStorage.getItem("min");
const max = parseInt(localStorage.getItem("max"));
const garr = localStorage.getItem("garr").split(',');
let tops = []
console.log(garr)
if(garr[4] === "true"){
console.log("tabletime")
this.setState({
min: min,
max : max,
first: min,
second: min,
op: "*",
ops: "Multiplcation Table",
answer: min*min,
seconds: 0,
type: "table"
}, () => {
console.log("multime")
this.timer = setInterval(this.countDown, 1000)
})
//mul table run
} else {
console.log(garr[0])
if(garr[0] === 'true'){
tops = tops+"+";
}
if(garr[1] === 'true'){
tops = tops+"-";
}
if(garr[2] === 'true'){
tops = tops+"/";
}
if(garr[3] === 'true'){
tops = tops+"*";
}
this.setState({
min: min,
max : max+1,
type: "rand",
ops: tops,
seconds: 60
}, () => {
this.getRandomProblem()
this.timer = setInterval(this.countDown, 1000)
})
//start game
}
}
getNextTableProblem(){
if(this.state.second+"" === this.state.max+"" && this.state.first+"" === this.state.max+""){//End the game due to the player clearing the last problem with
//Store important values
//Switch to scoreboard
localStorage.setItem("score", this.state.score);
localStorage.setItem("seconds", this.state.seconds);
this.props.history.push("/scores")
}else if(this.state.second+"" === this.state.max+""){ //If the second value reaches the cap.
let tfirst = parseInt(this.state.first)+1
this.setState({
first: tfirst,
second: this.state.min,
answer: tfirst*this.state.min
})
}else{//Continue as normal
let tsecond = parseInt(this.state.second)+1
this.setState({
second: tsecond,
answer: this.state.first*tsecond
})
}
}
getRandomProblem(){
let tops = this.state.ops;
let fir = Math.floor(Math.random() * (this.state.max - this.state.min) + this.state.min);//Grab a number between the values
let sec = Math.floor(Math.random() * (this.state.max - this.state.min) + this.state.min);
let rop = tops[Math.floor(Math.random() * tops.length)];//Use the length to grab a random symbol.
let ans = "";
switch(rop){
case "+":
ans = fir+sec;
break;
case "-":
ans = fir-sec;
break;
case "/":
if(sec === 0){sec = sec+1}
ans = Math.round(((fir/sec) + Number.EPSILON) * 100) / 100;
break;
case "*":
ans = fir*sec;
break;
}
this.setState({
first: fir,
second: sec,
op: rop,
answer: ans
})
}
countDown() {
let s = this.state.seconds
if(this.state.type === "table"){
s = this.state.seconds + 1;
} else{
s = this.state.seconds - 1;
}
this.setState({seconds : s})
if (this.state.seconds === 0) {
clearInterval(this.timer);
localStorage.setItem("score", this.state.score);
this.props.history.push("/scores")
}
}
countUp(){
let s = this.state.seconds + 1;
this.setState({seconds : s})
}
onChange(event) {
const state = this.state
state[event.target.name] = event.target.value;
this.setState(state);
// console.log(typeof this.state.input)
// console.log(typeof this.state.answer)
// console.log(this.state.input === this.state.answer)
if(this.state.input === this.state.answer+""){
if(this.state.type === "table"){
this.getNextTableProblem()
}else{
this.getRandomProblem();
}
let sco = this.state.score + 1
this.setState({
input : '',
score : sco
});
}
}
render() {
return (
<div className="container p-2 shadow rounded bg-light">
<div className="row">
<div className="col-2">
<h3>Score: {this.state.score}</h3>
</div>
<div className="col-8 text-center">
<h3>{this.state.ops}</h3>
</div>
<div className="col-2">
<h3 className="text-right">Time: {this.state.seconds}</h3>
</div>
</div>
<div className="text-center mb-4">
<h3>{this.state.first + " " + this.state.op + " " + this.state.second}</h3>
</div>
<div>
<input type="number" name="input" value={this.state.input} onChange={this.onChange} className="form-control" autocomplete="off" autoFocus/>
</div>
</div>
);
}
}
export default game;
|
const DataUploads = {
props: ['project_id'],
data() {
return {batches: []};
},
created() {
this.loadBreakdowns();
},
methods: {
loadBreakdowns() {
$.ajax({
url: '/api/cost/batches/' + this.project_id, dataType: 'json'
}).success(response => {
if (response.ok) {
this.batches = response.batches;
}
}).error(() => {
this.batches = [];
});
}
},
events: {
reload_data_uploads() {
this.loadBreakdowns();
}
}
};
export { DataUploads }; |
const DISCOVERY_DOCS = ['https://sheets.googleapis.com/$discovery/rest?version=v4']
const SCOPES = 'https://www.googleapis.com/auth/spreadsheets'
const connectButton = document.getElementById('connect_button')
const authorizeButton = document.getElementById('authorize_button')
const signoutButton = document.getElementById('signout_button')
const form = document.getElementById('form')
const authorize = document.getElementById('authorize')
const connected = document.getElementById('connected')
const clientId = document.getElementById('client-id')
const apiKey = document.getElementById('api-key')
const spreadsheetId = document.getElementById('spreadsheet-id')
const previousClientId = localStorage.getItem('clientId')
if (!!previousClientId) {
clientId.value = previousClientId
}
const previousApiKey = localStorage.getItem('apiKey')
if (!!previousApiKey) {
apiKey.value = previousApiKey
}
const previousSpreadSheetId = localStorage.getItem('spreadsheetId')
if (!!previousSpreadSheetId) {
spreadsheetId.value = previousSpreadSheetId
}
let app
let lastResourceVersion
let params
const MAX_ROWS = 100
const CLIENT_ID = clientId.value
const API_KEY = apiKey.value
connectButton.addEventListener('click', (event) => {
localStorage.setItem('clientId', clientId.value)
localStorage.setItem('apiKey', apiKey.value)
localStorage.setItem('spreadsheetId', spreadsheetId.value)
gapi.load('client:auth2', initClient)
})
function initClient() {
if (clientId.value.trim() === '' || apiKey.value.trim() === '' || spreadsheetId.value.trim() === '') {
return
}
params = { spreadsheetId: spreadsheetId.value }
gapi.client
.init({
apiKey: apiKey.value.trim(),
clientId: clientId.value.trim(),
discoveryDocs: DISCOVERY_DOCS,
scope: SCOPES,
})
.then(
function () {
form.style.display = 'none'
// Listen for sign-in state changes.
gapi.auth2.getAuthInstance().isSignedIn.listen(updateSigninStatus)
// Handle the initial sign-in state.
updateSigninStatus(gapi.auth2.getAuthInstance().isSignedIn.get())
authorizeButton.onclick = () => gapi.auth2.getAuthInstance().signIn()
signoutButton.onclick = () => gapi.auth2.getAuthInstance().signOut()
},
function (error) {
form.style.display = 'block'
authorize.style.display = 'none'
connected.style.display = 'none'
appendPre(JSON.stringify(error, null, 2))
},
)
}
function updateSigninStatus(isSignedIn) {
if (isSignedIn) {
authorize.style.display = 'none'
connected.style.display = 'block'
start()
} else {
authorize.style.display = 'block'
connected.style.display = 'none'
}
}
function appendPre(message) {
var pre = document.getElementById('content')
var textContent = document.createTextNode(message + '\n')
pre.appendChild(textContent)
}
function start() {
getAllSheetNames()
.then((sheets) => (app = App(sheets)))
.then(() => {
return fetch('/apis/apps/v1/deployments')
})
.then((response) => response.json())
.then((response) => {
const deployments = response.items
lastResourceVersion = response.metadata.resourceVersion
deployments.forEach((pod) => {
const deploymentId = `${pod.metadata.namespace}-${pod.metadata.name}`
app.upsert(deploymentId, pod)
})
})
.then(() => streamUpdates())
setInterval(() => {
poll()
}, 5000)
}
function poll() {
getAllSheetNames()
.then((sheets) => {
return gapi.client.sheets.spreadsheets.values.batchGet({
...params,
ranges: sheets.filter((it) => it !== 'Sheet1').map((it) => `${it}!A2:C${MAX_ROWS}`),
})
})
.then((response) => {
response.result.valueRanges.forEach(({ range, values }) => {
const namespace = range.split('!')[0].replace(/'/g, '')
values.forEach((row) => {
if (row[0] === '') {
return
}
if (row[1] === '') {
return
}
if (`${row[1]}` !== `${row[2]}`) {
console.log('SCALE', row[0], ' in ', namespace)
fetch(`/apis/apps/v1/namespaces/${namespace}/deployments/${row[0]}`, {
method: 'PATCH',
body: JSON.stringify({ spec: { replicas: parseInt(row[1], 10) } }),
headers: {
'Content-Type': 'application/strategic-merge-patch+json',
},
})
}
})
})
})
}
function streamUpdates() {
fetch(`/apis/apps/v1/deployments?watch=1&resourceVersion=${lastResourceVersion}`)
.then((response) => {
const stream = response.body.getReader()
const utf8Decoder = new TextDecoder('utf-8')
let buffer = ''
return stream.read().then(function processText({ done, value }) {
if (done) {
console.log('Request terminated')
return
}
buffer += utf8Decoder.decode(value)
buffer = findLine(buffer, (line) => {
if (line.trim().length === 0) {
return
}
try {
const event = JSON.parse(line)
console.log('PROCESSING EVENT: ', event)
const deployment = event.object
const deploymentId = `${deployment.metadata.namespace}-${deployment.metadata.name}`
switch (event.type) {
case 'ADDED': {
app.upsert(deploymentId, deployment)
break
}
case 'DELETED': {
app.remove(deploymentId)
break
}
case 'MODIFIED': {
app.upsert(deploymentId, deployment)
break
}
default:
break
}
lastResourceVersion = deployment.metadata.resourceVersion
} catch (error) {
console.log('Error while parsing', line, '\n', error)
}
})
return stream.read().then(processText)
})
})
.catch(() => {
console.log('Error! Retrying in 5 seconds...')
setTimeout(() => streamUpdates(), 5000)
})
function findLine(buffer, fn) {
const newLineIndex = buffer.indexOf('\n')
if (newLineIndex === -1) {
return buffer
}
const chunk = buffer.slice(0, buffer.indexOf('\n'))
const newBuffer = buffer.slice(buffer.indexOf('\n') + 1)
fn(chunk)
return findLine(newBuffer, fn)
}
}
function renderSheet(rows, sheetName) {
return gapi.client.sheets.spreadsheets.values.batchUpdate(params, {
valueInputOption: 'RAW',
data: [
{
range: `${sheetName}!A1:A${rows.length + 1}`,
values: [['Deployment'], ...rows.map((it) => [it.name])],
},
{
range: `${sheetName}!B1`,
values: [['Desired']],
},
{
range: `${sheetName}!C1:C${rows.length + 1}`,
values: [['Actual'], ...rows.map((it) => [it.replicas])],
},
{
range: `${sheetName}!A${rows.length + 2}:C${MAX_ROWS}`,
values: [...range(MAX_ROWS - rows.length - 1).map((i) => ['', '', ''])],
},
],
})
}
function createSheets(titles) {
if (titles.length === 0) {
return Promise.resolve()
}
return gapi.client.sheets.spreadsheets.batchUpdate(params, {
requests: titles.map((it) => ({
addSheet: {
properties: {
title: it,
},
},
})),
})
}
function deleteSheets(sheetNames) {
if (sheetNames.length === 0) {
return Promise.resolve()
}
return gapi.client.sheets.spreadsheets
.get(params)
.then((response) => {
const mappings = response.result.sheets.reduce((acc, it) => {
acc[it.properties.title] = it.properties.sheetId
return acc
}, {})
return sheetNames.map((it) => mappings[it]).filter((it) => !!it)
})
.then((sheetIds) => {
return gapi.client.sheets.spreadsheets.batchUpdate(params, {
requests: sheetIds.map((it) => ({
deleteSheet: {
sheetId: it,
},
})),
})
})
.catch(() => {})
}
function getAllSheetNames() {
return gapi.client.sheets.spreadsheets.get(params).then((it) => it.result.sheets.map((it) => it.properties.title))
}
function range(n) {
return [...Array(n).keys()]
}
function App(sheets = ['Sheet1']) {
const allDeployments = new Map()
async function render() {
const deployments = Array.from(allDeployments.values())
if (deployments.length !== 0) {
const deploymentsByNamespace = groupBy(deployments, (it) => it.namespace)
const namespaces = Object.keys(deploymentsByNamespace)
const { added, removed } = diff({ previous: sheets, current: ['Sheet1', ...namespaces] })
added.forEach((it) => sheets.push(it))
removed.forEach((it) => {
const index = sheets.findIndex((sheet) => sheet === it)
sheets.splice(index, 1)
})
try {
await Promise.all([createSheets(added), deleteSheets(removed)])
await Promise.all(
namespaces.map((namespace) => {
return renderSheet(deploymentsByNamespace[namespace], namespace)
}),
)
} catch (error) {
console.log('ERROR in rendering', error)
}
}
setTimeout(render, 1500)
}
render()
return {
upsert(deploymentId, deployment) {
allDeployments.set(deploymentId, {
name: deployment.metadata.name,
namespace: deployment.metadata.namespace,
replicas: deployment.spec.replicas,
})
},
remove(deploymentId) {
allDeployments.delete(deploymentId)
},
}
}
function groupBy(arr, groupByKeyFn) {
return arr.reduce((acc, c) => {
const key = groupByKeyFn(c)
if (!(key in acc)) {
acc[key] = []
}
acc[key].push(c)
return acc
}, {})
}
function diff({ previous, current }) {
const uniqueCurrentIds = current.filter(onlyUnique)
const uniquePreviousIds = previous.filter(onlyUnique)
return {
removed: uniquePreviousIds.filter((a) => uniqueCurrentIds.findIndex((b) => a === b) === -1),
unchanged: uniquePreviousIds.filter((a) => uniqueCurrentIds.findIndex((b) => a === b) > -1),
added: uniqueCurrentIds.filter((b) => uniquePreviousIds.findIndex((a) => a === b) === -1),
}
}
function onlyUnique(value, index, self) {
return self.map((it) => `${it}`).indexOf(`${value}`) === index
}
function debounce(func, wait, immediate) {
var timeout
return function () {
var context = this,
args = arguments
var later = function () {
timeout = null
if (!immediate) func.apply(context, args)
}
var callNow = immediate && !timeout
clearTimeout(timeout)
timeout = setTimeout(later, wait)
if (callNow) func.apply(context, args)
}
}
|
import config from '../js/helpers/config';
import { debugLog } from '../js/helpers/tracking';
import { store } from '@/js/stores/compass-store.js';
const About = () => import('../js/views/About.vue');
const Compass = () => import('../js/views/Compass.vue');
const Homepage = () => import('../js/views/Homepage.vue');
const Report = () => import('../js/views/Report.vue');
const Embed = () => import('../js/views/CompassEmbed.vue');
const routes = [
{
name: 'compass',
path: '/:locale/compass/:metric/:geographyLevel?/',
component: Compass,
},
{
name: 'report',
path: '/:locale/report/:geographyLevel/:selectGroupType?/:selectGroupName?/',
component: Report,
},
{
name: 'embed',
path: '/:locale/embed/:metric/:geographyLevel/',
component: Embed,
},
{
name: 'about',
path: '/:locale/about/',
component: About,
},
{
name: 'homepage',
path: '/:locale/',
component: Homepage,
},
{
name: 'homepage-en',
path: '/',
redirect: { name: 'homepage', params: { locale: 'en' } },
},
{
name: 'wildcard',
path: '/:pathMatch(.*)/*',
redirect: { name: 'homepage', params: { locale: 'en' } },
},
];
const routerOptions = {
encodeQuery: true,
routes,
scrollBehavior(to, from, savedPosition) {
if (to.hash) {
return { selector: to.hash, offset: { x: 0, y: 60 } };
} if (savedPosition) {
return savedPosition;
}
return { x: 0, y: 0 };
},
};
function getValidGeographyLevelForMetric(geographyLevel, metricId) {
if (config.dataConfig[`m${metricId}`].geographies.includes(geographyLevel)) {
return geographyLevel;
}
return config.dataConfig[`m${metricId}`].geographies[0];
}
const setUpRouterHooks = function(router) {
// Validate params.
router.beforeEach((to, from) => {
debugLog('Route guard: Validate params');
debugLog(`${from.path} => ${to.path}`);
debugLog(to);
// Check locale.
if (to.params.locale && !(['en', 'es'].includes(to.params.locale))) {
return {...to, params: {...to.params, locale: 'en'}};
}
// Validate Geography Level & metric
let geographyLevel = null;
if (to.name === 'compass') {
if (!('metric' in to.params) || !(`m${to.params.metric}` in config.dataConfig)) {
return {
name: 'homepage',
params: {locale: ('locale' in to.params) ? to.params.locale : 'en'}
};
}
// First set default value for geography level.
if ('geographyLevel' in to.params) {
geographyLevel = to.params.geographyLevel;
}
else if ('geographyLevel' in from.params) {
geographyLevel = from.params.geographyLevel;
} else {
geographyLevel = 'blockgroup';
}
// Then check if that is valid for metric and otherwise choose something else.
geographyLevel = getValidGeographyLevelForMetric(geographyLevel, to.params.metric);
if (geographyLevel !== to.params.geographyLevel) {
return {
name: 'compass',
params: {...to.params, geographyLevel}
};
}
}
});
// // Load geography & selected on each route.
router.afterEach(async (to) => {
if (to.name === 'compass') {
debugLog("Route guard: store last compass path");
store.lastCompassRoute = to;
}
});
return router;
}
export { routerOptions, setUpRouterHooks };
|
// @flow
/* **********************************************************
* File: components/Settings/ZeroBtn.js
*
* Brief: React component for zeroing the sensor
* Authors: Craig Cheney
*
* 2017.10.02 CC - Document created
*
********************************************************* */
import React, { Component } from 'react';
import { Col, ButtonToolbar, Row, Button, ButtonGroup } from 'react-bootstrap';
import type { idType } from '../../types/paramTypes';
import type { thunkType } from '../../types/functionTypes';
/* Type def */
type propsT = {
deviceId: idType,
sensorId: idType,
zeroSensor: (
deviceId: idType,
sensorId: idType
) => thunkType
};
export default class ZeroBtn extends Component<propsT> {
/* Render function */
render() {
return (
<div>
<ButtonToolbar>
<Col md={4} xs={4}>
<label htmlFor='zeroBtn'>Zero:</label>
</Col>
<Row />
<Col md={12} xs={12}>
<ButtonGroup
id='zeroBtn'
bsSize='small'
onClick={() => this.props.zeroSensor(this.props.deviceId, this.props.sensorId)}
>
<Button>Zero</Button>
</ButtonGroup>
</Col>
</ButtonToolbar>
</div>
);
}
}
/* [] - END OF FILE */
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.