text stringlengths 7 3.69M |
|---|
'use strict';
angular.module('myApp.selectedList', ['ngRoute'])
.config(['$routeProvider', function($routeProvider) {
$routeProvider.when('/selectedList', {
templateUrl: 'selectedList/selectedList.html',
controller: 'SelectedListCtrl'
});
}])
.controller('SelectedListCtrl', function($scope, $http, $rootScope) {
}); |
import * as MyTaxiRulesActionType from '../actiontypes/myTaxi';
const INITIAL_STATE = {
ids: [],
content: {},
};
function normalize(taxiesList) {
const ids = [];
const content = {};
taxiesList.poiList.forEach((taxi) => {
ids.push(taxi.id);
content[taxi.id] = taxi;
});
return {
ids,
content,
};
}
export default function mytaxies(state = INITIAL_STATE, action) {
switch (action.type) {
case MyTaxiRulesActionType.GET_TAXI_LIST:
return normalize(action.myTaxies);
default:
return state;
}
}
|
const fs = require('fs')
const storage_path = base+'Storage/';
function putAs(path,fileName, fileBuffer){
save(path+'/'+fileName, fileBuffer)
}
function put(path, fileBuffer) {
save(realPath(path)+uniqueString(), fileBuffer)
}
function save(path,fileBuffer) {
try {
fs.writeFile(realPath(path), fileBuffer, () => {});
return true
}catch (e) {
return e
}
}
function uniqueString() {
return '_' + Math.random().toString(36).substr(2, 9)+new Date().getTime();
}
function realPath(path){
return storage_path+path
}
module.exports = {
put, putAs
}; |
import React, { Component } from 'react'
import { Container, Row, Col } from 'react-bootstrap';
import ButtonGr from '../Elements/ButtonGr';
class CallOut extends Component {
render() {
return (
<div className="call-out-sec">
<Container>
<Row>
<Col xs={12} sm={6}><h4 className="text-h4">ARE YOU READY TO BE BELOWN AWAY? </h4></Col>
<Col xs={12} sm={6}>
<ButtonGr title="CLICK HERE TO FIND OUT" align="right"/>
</Col>
</Row>
</Container>
</div>
)
}
}
export default CallOut; |
/*
Not a *real* interface, as JS doesn't support them!
The Provider's service.js file should have all of the below functions
held in a global Video object attached to the Window
**This file WILL NOT WORK as a Javascript file**
*/
// loads the video into the given DIV element
Video.embedVideo(videoId, elementID);
// returns a Promise, that when resolved, gives the current position of the video, in seconds
Video.getCurrentPosition(); |
console.log(Number("555"));
console.log(typeof(Number("555")));
console.log(String(2345));
console.log(typeof(String(2345)));
console.log(Boolean(1));
console.log(typeof(Boolean(1)));
console.log("");
console.log(!!4);
console.log(!!0);
console.log(typeof(453 + ""));
console.log(typeof(+ "453"));
var number = 15;
console.log(number.toString());
console.log(number.toString(8));//8 с/с
console.log(number.toString(2));//2 с/с
console.log(typeof(false.toString()));
console.log(parseInt("25 px", 10));//10 c/c
console.log(parseFloat("30.25 em"));
console.log(typeof String(Infinity));
console.log(typeof String(NaN));
console.log(+"");
//false
console.log(!!"");
console.log(!!NaN);
console.log(!!0);
console.log(!!null);
console.log(!!undefined);
console.log(!!"Hello");
console.log(+" 23");
console.log(+" x 23");
console.log(+true);
|
const addResult = document.querySelector(".add-result");
let addressUser = (user) => {
addResult.addEventListener("click", () => {
if (user == "") alert("Vui lòng đăng nhập để sử dụng tính năng này");
else {
(async (id) => {
let addressCollection = await db.collection("Addresses").doc(id);
let getDataAddressCollection = await addressCollection.get();
let dataFind = getDataAddressCollection.data();
// console.log(Object.keys(dataFind).length);
var numberAll = Object.keys(dataFind).length;
document.querySelector(".forecast-table.search-results").style.display =
"none";
//add lon and lat
addressCollection.update({
[`${numberAll}`]: [latSearch, lonSearch],
});
})(user.uid);
}
});
};
|
import React from 'react'
import DetailPostContainer from '../containers/DetailPostContainer'
function DetailPost() {
return (
<div>
<DetailPostContainer />
</div>
)
}
export default DetailPost
|
const express = require('express'),
router = express.Router(),
Cinema = require('../models/cinema');
router.get('/', function(req, res){
Cinema.find({}, function(err, cinemaLists){
if(err){
req.flash('error', 'Something went wrong.');
res.redirect('/');
}else{
res.render('cinema/cinemas.ejs', {cinema: cinemaLists});
}
});
});
module.exports = router;
|
// Copyright (c) 2016-2018, BuckyCloud, Inc. and other BDT contributors.
// The BDT project is supported by the GeekChain Foundation.
// All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of the BDT nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
'use strict';
const EventEmitter = require('events');
const Base = require('../base/base.js');
const {HashDistance, Result: DHTResult, Config, EndPoint, GetValueFlag, TOTAL_KEY} = require('./util.js');
const {Peer, LocalPeer} = require('./peer.js');
const Bucket = require('./bucket.js');
const DistributedValueTable = require('./distributed_value_table.js');
const TaskMgr = require('./taskmgr.js');
const DHTPackage = require('./packages/package.js');
const DHTPackageFactory = require('./package_factory.js');
const {PackageSender} = require('./package_sender.js');
const PackageProcessor = require('./package_processor.js');
const RouteTable = require('./route_table.js');
const LocalValueMgr = require('./local_value_mgr.js');
const PiecePackageRebuilder = require('./piece_package_rebuilder.js');
const net = require('net');
const assert = require('assert');
const BaseUtil = require('../base/util.js');
const Stat = require('./stat.js');
const DHTAPPID = require('../base/dhtappid.js');
const TimeHelper = BaseUtil.TimeHelper;
const DHTCommandType = DHTPackage.CommandType;
const LOG_TRACE = Base.BX_TRACE;
const LOG_INFO = Base.BX_INFO;
const LOG_WARN = Base.BX_WARN;
const LOG_DEBUG = Base.BX_DEBUG;
const LOG_CHECK = Base.BX_CHECK;
const LOG_ASSERT = Base.BX_ASSERT;
const LOG_ERROR = Base.BX_ERROR;
const ROOT_SERVICE_PATH = [];
const BASE_DHT_SERVICE_ID = '';
class DHTBase extends EventEmitter {
constructor(mixSocket, localPeer, packageFactory, taskMgr, remoteFilter) {
super();
this.m_bucket = new Bucket(localPeer, {appid: packageFactory.appid});
this.m_distributedValueTable = new DistributedValueTable({appid: packageFactory.appid});
this.m_packageSender = new PackageSender(mixSocket, this.m_bucket, remoteFilter);
this.m_packageFactory = packageFactory;
this.m_broadcastEventEmitter = new EventEmitter();
let env = {
bucket: this.m_bucket,
packageSender: this.m_packageSender,
packageFactory: this.m_packageFactory,
distributedValueTable: this.m_distributedValueTable,
broadcastEventEmitter: this.m_broadcastEventEmitter,
taskMgr: taskMgr,
taskExecutor: null,
};
this.m_taskExecutor = taskMgr.createTaskExecutor(env);
this.m_packageSender.taskExecutor = this.m_taskExecutor;
this.m_packageSender.on(PackageSender.Events.localPackage,
cmdPackage => {
this.rootDHT._process(cmdPackage, this.m_bucket.localPeer);
});
env.taskExecutor = this.m_taskExecutor;
this.m_packageProcessor = new PackageProcessor(env);
this.m_routeTable = new RouteTable(env);
this.m_localValueMgr = new LocalValueMgr(env);
this.m_subServiceDHTs = new Map();
}
// 返回本地peer当前状态信息的一个副本，不随peer运行状态改变而改变
get localPeer() {
let localPeer = this.m_bucket.localPeer;
let peer = new Peer(localPeer);
peer.answer = localPeer.answer;
peer.question = localPeer.question;
return peer;
}
get rootDHT() {
let _rootDHT = this;
while (_rootDHT.m_father) {
_rootDHT = _rootDHT.m_father;
}
return _rootDHT;
}
// callback({dht, result, peerlist})
// options:
// onStep({dht, result, peerlist}): 阶段性返回找到的peer，部分应用更需要响应的及时性，返回true将中断本次搜索，callback返回result=ABORT(7)
findPeer(peerid, options, callback) {
const onStep = options? options.onStep : null;
let appendLocalHost = (peers) => {
if (!this.m_bucket.localPeer.inactive && peerid === this.m_bucket.localPeer.peerid) {
let serviceDescriptor = this.m_bucket.localPeer.findService(this.servicePath);
if (!serviceDescriptor || !serviceDescriptor.isSigninServer()) {
return;
}
let localPeer = null;
if (peers.length === 0 || peers[0].peerid !== peerid) {
localPeer = new Peer(this.m_bucket.localPeer);
peers.unshift(localPeer);
} else {
localPeer = peers[0];
}
let getLocalListenEPList = () => {
let eplist = [];
this.m_packageSender.mixSocket.eplist.forEach(ep => {
let addr = EndPoint.toAddress(ep);
if (addr) {
if (EndPoint.isZero(addr)) {
addr.address = EndPoint.loopback(addr.family);
ep = EndPoint.toString(addr);
}
eplist.push(ep);
}
});
return eplist;
}
localPeer.unionEplist(getLocalListenEPList());
}
}
const generateCallback = (handler) => (result, peers = []) => {
if (!handler) {
return;
}
if (peerid === this.m_bucket.localPeer.peerid) {
result = 0;
appendLocalHost(peers);
}
return handler({dht: this, result, peerlist: peers});
}
if (callback) {
this._findPeer(peerid, generateCallback(callback), generateCallback(onStep));
} else {
return new Promise(resolve => {
this._findPeer(peerid, generateCallback(resolve), generateCallback(onStep));
});
}
}
_findPeer(peerid, callback, onStep) {
if (!Peer.isValidPeerid(peerid)) {
if (callback) {
callback(DHTResult.INVALID_ARGS, []);
}
LOG_ASSERT(false, `[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}) findPeer peerid is invalid args:${peerid}.`);
return DHTResult.INVALID_ARGS;
}
/* 就算是搜索自己，也可以返回距离自己较近的几个节点，在某些应用场景也是有价值的
let peer = this.m_bucket.findPeer(peerid);
if (peer && this.m_bucket.localPeer.peerid === peerid) {
callback(DHTResult.SUCCESS, []);
return DHTResult.SUCCESS;
}
*/
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) findPeer peerid(${peerid}).`);
this.m_taskExecutor.findPeer(peerid, true, callback, onStep);
return DHTResult.PENDING;
}
saveValue(tableName, keyName, value) {
if (typeof tableName === 'string' && tableName.length > 0
&& typeof keyName === 'string' && keyName.length > 0 && keyName != TOTAL_KEY
&& value !== undefined && value !== null) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) saveValue (${tableName}:${keyName}:${value}).`);
this.m_localValueMgr.saveValue(tableName, keyName, value);
return DHTResult.SUCCESS;
} else {
LOG_ASSERT(false, `[DHT(${this.appid})] SaveValue invalid args, (tableName: ${tableName}, keyName: ${keyName}, value: ${value}).`);
return DHTResult.INVALID_ARGS;
}
}
deleteValue(tableName, keyName) {
if (typeof tableName === 'string' && tableName.length > 0
&& typeof keyName === 'string' && keyName.length > 0) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) deleteValue (${tableName}:${keyName}).`);
this.m_localValueMgr.deleteValue(tableName, keyName);
return DHTResult.SUCCESS;
} else {
LOG_ASSERT(false, `[DHT(${this.appid})] DeleteValue invalid args, (tableName: ${tableName}, keyName: ${keyName}).`);
return DHTResult.INVALID_ARGS;
}
}
// callback({dht, result, values: Map<key, value>})
getValue(tableName, keyName, flags = GetValueFlag.Precise, callback = undefined) {
const generateCallback = handler => {
this._getValue(tableName, keyName, flags, (result, values = new Map()) => {
handler({dht: this, result, values})
});
}
if (callback) {
generateCallback(callback)
} else {
return new Promise(resolve => generateCallback(resolve))
}
}
_getValue(tableName, keyName, flags = GetValueFlag.Precise, callback = undefined) {
if (typeof tableName === 'string' && tableName.length > 0
&& typeof keyName === 'string' && keyName.length > 0) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) getValue (${tableName}:${keyName}), flags:${flags}.`);
// 可能本地节点就是最距离目标table最近的节点
/* let values = null;
if (keyName === TOTAL_KEY
|| (flags & GetValueFlag.Precise)) {
values = this.m_distributedValueTable.findValue(tableName, keyName);
} else {
values = this.m_distributedValueTable.findClosestValues(tableName, keyName);
}
if (values) {
let localValues = this.m_localValueMgr.getValue(tableName, keyName);
if (localValues && localValues.size > 0) {
localValues.forEach((value, key) => values.set(key, value));
}
if (callback) {
callback(DHTResult.SUCCESS, values);
}
return DHTResult.SUCCESS;
}
*/
const getValueCallback = (result, values, arrivedPeerids) => {
let localValues = this.m_localValueMgr.getValue(tableName, keyName);
if (localValues && localValues.size > 0) {
if (!values) {
values = new Map();
}
localValues.forEach((value, key) => values.set(key, value));
}
if (callback) {
if (values && values.size > 0) {
result = DHTResult.SUCCESS;
}
callback({result, values});
}
}
this.m_taskExecutor.getValue(tableName, keyName, flags, {ttl: 1, isForward: false}, getValueCallback);
return DHTResult.PENDING;
} else {
LOG_ASSERT(false, `[DHT(${this.appid})] GetValue invalid args, (tableName: ${tableName}, keyName: ${keyName}).`);
return DHTResult.INVALID_ARGS;
}
}
emitBroadcastEvent(eventName, params) {
return this._emitBroadcastEvent(eventName, params);
}
_emitBroadcastEvent(eventName, params) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) emitBroadcastEvent(${eventName}:${params})`);
if (typeof eventName === 'string') {
this.m_taskExecutor.emitBroadcastEvent(eventName,
params,
this.m_bucket.localPeer,
null,
{});
return DHTResult.PENDING;
} else {
LOG_ASSERT(false, `[DHT(${this.appid})] emitBroadcastEvent invalid args, (eventName type: ${typeof eventName}).`);
return DHTResult.INVALID_ARGS;
}
}
// listener(eventName, params, sourcePeer)
attachBroadcastEventListener(eventName, listener) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) attachBroadcastEventListener(${eventName})`);
if (typeof eventName === 'string' && typeof listener === 'function') {
this.m_broadcastEventEmitter.on(eventName, listener);
return {eventName, listener, result: DHTResult.SUCCESS};
} else {
LOG_ASSERT(false, `[DHT(${this.appid})] attachBroadcastEventListener invalid args type, (eventName type: ${typeof eventName}, listener type: ${typeof listener}).`);
return {result: DHTResult.INVALID_ARGS};
}
}
// attachBroadcastEventListener相同输入参数
detachBroadcastEventListener(eventName, listener) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) detachBroadcastEventListener(${eventName})`);
if (typeof eventName === 'string' && typeof listener === 'function') {
this.m_broadcastEventEmitter.removeListener(eventName, listener);
return DHTResult.SUCCESS;
} else {
LOG_ASSERT(false, `[DHT(${this.appid})] detachBroadcastEventListener invalid args type, (eventName type: ${typeof eventName}, listener type: ${typeof listener}).`);
return DHTResult.INVALID_ARGS;
}
}
get servicePath() {
return ROOT_SERVICE_PATH;
}
get serviceID() {
return BASE_DHT_SERVICE_ID;
}
/**
* 准备一个访问/提供特定服务的DHT子网
* @param {string|Array[string]} servicePath: 服务子网路径，字符串表示就在当前路径下，数组表示相对当前路径的相对路径
*/
prepareServiceDHT(servicePath) {
if (typeof servicePath === 'string') {
servicePath = [servicePath];
}
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) prepareServiceDHT(${servicePath})`);
if (!servicePath || servicePath.length <= 0) {
LOG_ASSERT(false, `[DHT(${this.appid})] prepareServiceDHT invalid args type, (servicePath: ${servicePath}).`);
return null;
}
let fatherDHT = this;
let serviceDHT = null;
for (let serviceID of servicePath) {
serviceDHT = fatherDHT.m_subServiceDHTs.get(serviceID);
if (!serviceDHT) {
serviceDHT = new ServiceDHT(fatherDHT, serviceID);
fatherDHT.m_subServiceDHTs.set(serviceID, serviceDHT);
}
fatherDHT = serviceDHT;
}
return serviceDHT;
}
findServiceDHT(servicePath) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) prepareServiceDHT(${servicePath})`);
if (!servicePath || servicePath.length <= 0) {
LOG_ASSERT(false, `[DHT(${this.appid})] findServiceDHT invalid args type, (servicePath: ${servicePath}).`);
return null;
}
let fatherDHT = this;
let serviceDHT = null;
for (let serviceID of servicePath) {
serviceDHT = fatherDHT.m_subServiceDHTs.get(serviceID);
if (!serviceDHT) {
return null;
}
fatherDHT = serviceDHT;
}
return serviceDHT;
}
getAllOnlinePeers() {
let peerList = [];
this.m_bucket.forEachPeer(peer => {
if (peer.isOnline(this.m_bucket.TIMEOUT_MS)) {
peerList.push(new Peer(peer));
}
});
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) getAllOnlinePeers(count=${peerList.length})`);
return peerList;
}
// @param <number> count 期望找多少个peer
// @param <boolean> fromLocal 是否只从本地路由表中搜索
// @param <function> callback({dht, result, peerlist}) 完成回调
// @param <object> options: {
// <function> onStep({dht, result, peerlist}), 定时返回已经搜索到的全部peer列表，搜索完成时间可能比较长，部分要求及时响应的需求可以处理该事件，返回true停止搜索
// <function> filter(peer)，过滤搜索到的节点，返回true表示该peer有效
// }
getRandomPeers(count, fromLocal, options, callback) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) getRandomPeers count(${count}).`);
options = options || {};
// @var <array> peers
if (fromLocal) {
const peerlist = this.m_bucket.getRandomPeers({count}).map(peer => new Peer(peer));
if (callback) {
callback({dht: this, result: DHTResult.SUCCESS, peerlist});
} else {
return Promise.resolve({dht: this, result: DHTResult.SUCCESS, peerlist});
}
return DHTResult.SUCCESS;
}
const generateCallback = (handler) => (result, peers = []) => {
if (!handler) {
return;
}
return handler({dht: this, result, peerlist: peers});
}
if (callback) {
this.m_taskExecutor.findRandomPeer(count, true, generateCallback(callback), generateCallback(options.onStep), options.filter);
return DHTResult.PENDING;
} else {
return new Promise(resolve => {
this.m_taskExecutor.findRandomPeer(count, true, generateCallback(resolve), generateCallback(options.onStep), options.filter);
});
}
}
// private:
// servicePath是协议包所属目标服务相对当前子服务的子路径
_process(cmdPackage, remotePeer, remoteAddr, localAddr, servicePath) {
LOG_TRACE(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) Got package(${DHTCommandType.toString(cmdPackage.cmdType)}), servicePath: ${cmdPackage.servicePath}`);
if (!servicePath) {
let targetServicePath = cmdPackage.servicePath || [];
let selfServicePath = this.servicePath;
if (targetServicePath.length < selfServicePath.length) {
return;
}
for (let i = 0; i < selfServicePath.length; i++) {
if (selfServicePath[i] !== targetServicePath[i]) {
return;
}
}
servicePath = targetServicePath.slice(selfServicePath.length);
}
let [childServiceID, ...grandServicePath] = servicePath;
if (!childServiceID) {
if (this.isRunning()) {
this.m_packageProcessor.process(cmdPackage, remotePeer, remoteAddr, localAddr);
}
} else {
let childServiceDHT = this.m_subServiceDHTs.get(childServiceID);
if (childServiceDHT) {
childServiceDHT._process(cmdPackage, remotePeer, remoteAddr, localAddr, grandServicePath);
}
}
}
// serviceDescriptor是当前子服务网络的描述符
_activePeer(peer, isSent, isReceived, isTrust, serviceDescriptor, cmdPackage) {
// LOG_DEBUG(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) Got new peer(${peer.peerid}) for (send:${isSent},recv:${isReceived},trust:${isTrust}),serviceDescriptor=${serviceDescriptor}`);
if (!serviceDescriptor && !peer.inactive) {
serviceDescriptor = peer.findService(this.servicePath);
}
let activedPeer = peer;
if (!peer.inactive && serviceDescriptor && serviceDescriptor.isSigninServer()) {
if (this.isRunning()) {
let existPeer = this.m_bucket.findPeer(peer.peerid);
let isOnlineBefore = existPeer? existPeer.isOnline(this.m_bucket.TIMEOUT_MS) : true;
let {peer: activedPeer, isNew, discard, replace} = this.m_bucket.activePeer(peer, isSent, isReceived, isTrust);
if (isNew && !discard) {
LOG_DEBUG(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) Got new peer(${peer.peerid}) for (send:${isSent},recv:${isReceived},trust:${isTrust}),serviceDescriptor=${serviceDescriptor}`);
this.m_routeTable.ping(activedPeer);
}
}
} else {
LOG_DEBUG(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) remove peer(${peer.peerid}) from bucket for (inactive:${peer.inactive}),serviceDescriptor=${serviceDescriptor? serviceDescriptor.isSigninServer() : undefined}`);
this.m_bucket.removePeer(peer.peerid);
}
let servicesForPeer = serviceDescriptor? serviceDescriptor.services : null;
if (this.m_subServiceDHTs) {
this.m_subServiceDHTs.forEach((serviceDHT, serviceID) => {
let serviceDescriptor = servicesForPeer? servicesForPeer.get(serviceID) : null;
serviceDHT._activePeer(activedPeer, isSent, isReceived, isTrust, serviceDescriptor);
});
}
}
_update() {
if (this.m_subServiceDHTs) {
this.m_subServiceDHTs.forEach(serviceDHT => serviceDHT._update());
}
if (this.isRunning()) {
this.m_localValueMgr.updateToRemote();
this.m_distributedValueTable.clearOuttimeValues();
// 刷新路由表带有盲目性，最后做，因为前面各种操作过后，路由表刷新中的部分操作（比如ping）就不需要了
this.m_routeTable.refresh();
}
}
isRunning() {
return true;
}
_onSubServiceDHTStartWork(subServiceDHT) {
this._fillNewSubServiceDHT(subServiceDHT);
}
_onSubServiceDHTOffWork(subServiceDHT) {
// 不删掉它，避免再次生成时产生多个对象
// this.m_subServiceDHTs.delete(subServiceDHT.serviceID);
if (this.m_subServiceDHTs.size === 0 && !this.isRunning() && this.m_father) {
this.m_father._onSubServiceDHTOffWork(this);
}
}
_fillNewSubServiceDHT(subServiceDHT) {
this.m_bucket.forEachPeer(peer => subServiceDHT._activePeer(peer, false, false, false));
if (this.m_father) {
this.m_father._fillNewSubServiceDHT(subServiceDHT);
}
}
_logStatus() {
let now = TimeHelper.uptimeMS();
this.__lastLogTime = this.__lastLogTime || 0;
if (now - this.__lastLogTime >= 600000) {
this.__lastLogTime = now;
LOG_DEBUG(`[DHT(${this.appid})] DHT.status(serviceID:${this.servicePath}):`);
LOG_DEBUG(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath})<><><><><>connected to ${this.m_bucket.peerCount} peers, bucketCount = ${this.m_bucket.bucketCount}.`);
// print other peers (peerid, addres, eplist) except myself
this.m_bucket.m_buckets.forEach( bucket => {
// @var {array<object>} get other peers
let peerList = bucket.peerList.filter(peer => {
return true;
}).map(peer => {
return {
peerid: peer.peerid,
eplist: peer.eplist,
address:peer.address,
RTT: peer.RTT,
};
});
LOG_DEBUG(`[DHT(${this.appid})]`, 'peerlist:', peerList);
});
let logPkgStat = stat => {
LOG_DEBUG(`[DHT(${this.appid})] udp:${JSON.stringify(stat.udp)}`);
LOG_DEBUG(`[DHT(${this.appid})] tcp:${JSON.stringify(stat.tcp)}`);
let pkgsArray = [...stat.pkgs];
LOG_DEBUG(`[DHT(${this.appid})] pkgs(cmdType,count):${JSON.stringify(pkgsArray)}`);
};
LOG_DEBUG(`[DHT(${this.appid})] pkg.stat.recv:`);
logPkgStat(Stat.stat().recv);
LOG_DEBUG(`[DHT(${this.appid})] pkg.stat.send:`);
logPkgStat(Stat.stat().send);
}
this.m_subServiceDHTs.forEach(sub => sub._logStatus());
}
}
class DHT extends DHTBase {
/*
PEERINFO: {
peerid: string,
eplist: ARRAY[ep_string], // 因为tcp端口不可复用，主动向其他peer发起的连接都可能用不同的端口，无法通过通信端口识别本地监听端口;
// 所以使用tcp监听时必须用以下两种方式告知哪些地址是监听地址：
// 1.eplist指定其监听EndPoint
// 2.在调用process处理包时为socket.isReuseListener指定该socket是否使用了监听地址;
// 而UDP协议本地发出和接收的端口就是监听端口，可以通过通信端口发现自己监听的eplist；
// 初始化eplist和后面发现的监听地址都会被传播出去，而TCP主动发起连接的随机地址不会被传播；
additionalInfo: ARRAY[[key_string, value]],
}
localPeerInfo: PEERINFO
*/
constructor(mixSocket, localPeerInfo, appid = DHTAPPID.none, remoteFilter) {
LOG_INFO(`[DHT(${appid})] DHT will be created with mixSocket:${mixSocket}, and localPeerInfo:(peerid:${localPeerInfo.peerid}, eplist:${localPeerInfo.eplist})`);
LOG_ASSERT(Peer.isValidPeerid(localPeerInfo.peerid), `[DHT(${appid})] Local peerid is invalid:${localPeerInfo.peerid}.`);
if (!remoteFilter) {
remoteFilter = {
isForbidden() {
return false;
}
};
}
let localPeer = new LocalPeer(localPeerInfo);
localPeer.___create_flag = 160809;
let packageFactory = new DHTPackageFactory(appid);
let taskMgr = new TaskMgr();
super(mixSocket, localPeer, packageFactory, taskMgr, remoteFilter);
this.m_taskMgr = taskMgr;
this.m_timer = null;
this.m_highFrequencyTimer = null;
this.m_piecePackageRebuilder = new PiecePackageRebuilder();
this.m_remoteFilter = remoteFilter;
}
get appid() {
return this.m_packageFactory.appid;
}
/**
* 启动DHT网络
* @param {boolean} manualActiveLocalPeer 手动激活本地PEER，如果置true，本地peer将不会被其他任何PEER找到，只能作为访问者访问DHT网络
*/
start(manualActiveLocalPeer = false) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) will start.`);
if (!this.m_timer) {
Stat.addLocalPeer(this.m_bucket.localPeer);
this.m_timer = setInterval(() => this._update(), 1000);
// 对进行中的任务启用更高频的定时器，让任务处理更及时，并且压力更分散
this.m_highFrequencyTimer = setInterval(() => {
this.m_taskExecutor.taskMgr.wakeUpAllTask();
this._logStatus();
}, 200);
if (!manualActiveLocalPeer) {
this.activeLocalPeer();
}
setImmediate(() => {
this._update();
this.emit(DHT.EVENT.start);
});
}
}
stop() {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) will stop.`);
if (this.m_timer) {
clearInterval(this.m_timer);
this.m_timer = null;
clearInterval(this.m_highFrequencyTimer);
this.m_highFrequencyTimer = null;
setImmediate(() => this.emit(DHT.EVENT.stop));
Stat.removeLocalPeer(this.m_bucket.localPeer);
}
this.___stopped_flag = 160809;
}
static stat() {
let {send: senderStat, recv: recvStat} = Stat.stat();
let map2Obj = __map => {
let obj = {};
__map.forEach((v, k) => obj[k] = v);
return obj;
};
let stat = {
udp: {
send: {
pkgs: senderStat.udp.pkgs,
bytes: senderStat.udp.bytes,
},
recv: {
pkgs: recvStat.udp.pkgs,
bytes: recvStat.udp.bytes,
},
req: recvStat.udp.req,
resp: recvStat.udp.resp,
},
tcp: {
send: {
pkgs: senderStat.tcp.pkgs,
bytes: senderStat.tcp.bytes,
},
recv: {
pkgs: recvStat.tcp.pkgs,
bytes: recvStat.tcp.bytes,
},
req: recvStat.tcp.req,
resp: recvStat.tcp.resp,
},
pkgs: {
send: map2Obj(senderStat.pkgs),
recv: map2Obj(recvStat.pkgs),
},
};
return stat;
}
process(socket, message, remoteAddr, localAddr) {
// LOG_DEBUG(`[DHT(${this.appid})] Got package from(${remoteAddr.address}:${remoteAddr.port})`);
let localPeer = this.m_bucket.localPeer;
let dhtDecoder = DHTPackageFactory.createDecoder(message, 0, message.length);
if (!dhtDecoder) {
LOG_ERROR(`[DHT(${this.appid})] LOCALPEER(${localPeer.peerid}:${this.servicePath}) Got Invalid message:${message}.`);
return DHTResult.INVALID_PACKAGE;
}
let cmdPackage = dhtDecoder.decode();
if (cmdPackage) {
cmdPackage.__isCombine = message.__isCombine;
}
return this.processPackage(socket, dhtDecoder, remoteAddr, localAddr);
}
processPackage(socket, dhtDecoder, remoteAddr, localAddr) {
// LOG_DEBUG(`[DHT(${this.appid})] Got package from(${remoteAddr.address}:${remoteAddr.port})`);
let localPeer = this.m_bucket.localPeer;
// <TODO> 检查数据包的合法性
let cmdPackage = dhtDecoder.decode();
if (cmdPackage) {
Stat.statRecvFlowrate(cmdPackage, remoteAddr, dhtDecoder.totalLength);
}
if (!cmdPackage || cmdPackage.appid !== this.m_packageFactory.appid) {
LOG_WARN(`[DHT(${this.appid})] LOCALPEER(${localPeer.peerid}:${this.servicePath}) Got invalid package from(${remoteAddr.address}:${remoteAddr.port})`);
return dhtDecoder.totalLength;
}
if (cmdPackage.servicePath && cmdPackage.servicePath.length) {
LOG_DEBUG(`[DHT(${this.appid})] `, 'servicePath: ',`${cmdPackage.servicePath}`);
}
const cmdType = cmdPackage.cmdType;
if ((cmdType !== DHTCommandType.PACKAGE_PIECE_REQ && (!cmdPackage.dest || cmdPackage.dest.peerid !== localPeer.peerid))
|| !HashDistance.checkEqualHash(cmdPackage.dest.hash, localPeer.hash)) {
LOG_WARN(`[DHT(${this.appid})] LOCALPEER(${localPeer.peerid}:${this.servicePath}) Got package(${DHTCommandType.toString(cmdType)}) `,
`to other peer(id:${cmdPackage.dest.peerid},hash:${cmdPackage.dest.hash}),`,
`localPeer is (id:${localPeer.peerid},hash:${localPeer.hash}),`,
`from:${cmdPackage.src.peerid}:${EndPoint.toString(remoteAddr)}, to:${cmdPackage.common.dest.ep}`);
return dhtDecoder.totalLength;
}
if (cmdType === DHTCommandType.PACKAGE_PIECE_REQ) {
this._processPackagePiece(socket, cmdPackage, remoteAddr, localAddr);
return dhtDecoder.totalLength;
}
if (typeof cmdPackage.src.peerid !== 'string' || cmdPackage.src.peerid.length === 0 ||
!HashDistance.checkEqualHash(cmdPackage.src.hash, HashDistance.hash(cmdPackage.src.peerid))) {
LOG_WARN(`[DHT(${this.appid})] LOCALPEER(${localPeer.peerid}:${this.servicePath}) Got package hash verify failed.(id:${cmdPackage.dest.peerid},hash:${cmdPackage.dest.hash}), localPeer is (id:${localPeer.peerid},hash:${localPeer.hash})`);
return dhtDecoder.totalLength;
}
if (this.m_remoteFilter.isForbidden(remoteAddr, cmdPackage.src.peerid)) {
return dhtDecoder.totalLength;
}
LOG_DEBUG(`[DHT(${this.appid})] LOCALPEER(${localPeer.peerid}:${this.servicePath}) Got package(${DHTPackage.CommandType.toString(cmdPackage.cmdType)}) from(${EndPoint.toString(remoteAddr)}|${cmdPackage.src.peerid})`);
if (cmdPackage.common.dest.ep) {
// maintain local peer valid internet address
localPeer.unionEplist([cmdPackage.common.dest.ep], socket.isReuseListener);
// 被公网IPV4地址连通的包才可以用以辅助识别公网IP地址
if (cmdPackage.src.peerid !== localPeer.peerid &&
net.isIPv4(remoteAddr.address) && !EndPoint.isNAT(remoteAddr)) {
localPeer.setSenderEP(cmdPackage.common.dest.ep, EndPoint.toString(localAddr));
}
}
let remotePeer = new Peer(cmdPackage.common.src);
remotePeer.address = remoteAddr;
// 本地PEER是否激活取决于本地逻辑，不取决于数据包内容
if (remotePeer.peerid !== localPeer.peerid) {
this._activePeer(remotePeer, false, true, true, null, cmdPackage);
}
remotePeer = this.m_bucket.findPeer(remotePeer.peerid) || remotePeer;
this._process(cmdPackage, remotePeer, remoteAddr, localAddr);
this.m_packageSender.onPackageRecved(cmdPackage, remotePeer, remoteAddr, localAddr);
Stat.onPackageRecved(cmdPackage, remotePeer, remoteAddr, localAddr);
this.m_routeTable.onRecvPackage(cmdPackage, socket, remotePeer, remoteAddr);
if (cmdPackage.nodes) {
cmdPackage.nodes.forEach(node => {
if (node.id === 'string' && node.id.length > 0 &&
this.m_bucket.isExpandable(node.id)) {
this.m_taskExecutor.handshakeSource({peerid: node.id, eplist: node.eplist}, remotePeer, false, true);
}
});
}
return dhtDecoder.totalLength;
}
// 为了减少对应用层活动PEER的ping包，初始化中传入的socket上发送/接收任何包，应该通知一下DHT；
// DHT模块可以减少对这些PEER的ping操作；
// 启动时的初始节点也通过该接口传入；
// remotePeerInfo：PEERINFO
activePeer(remotePeerInfo, address, isSent, isReceived) {
LOG_ASSERT(Peer.isValidPeerid(remotePeerInfo.peerid), `[DHT(${this.appid})] ActivePeer peerid is invalid:${remotePeerInfo.peerid}.`);
if (!Peer.isValidPeerid(remotePeerInfo.peerid)) {
return DHTResult.INVALID_ARGS;
}
let remotePeer = new Peer(remotePeerInfo);
remotePeer.address = address;
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) got new PEER(${remotePeerInfo.peerid}:${remotePeerInfo.eplist}) from user.`);
this._activePeer(remotePeer, isSent, isReceived, false);
return DHTResult.SUCCESS;
}
// 激活本地PEER
// options: {
// broadcast: true
// }
activeLocalPeer(enable = true, options) {
LOG_INFO(`[DHT(${this.appid})] local peer added in bucket.`);
let _options = {
broadcast: true,
};
if (options) {
Object.assign(_options, options);
}
let localPeer = this.m_bucket.localPeer;
localPeer.active(enable);
// _activePeer函数会执行添加或移除路由表
this._activePeer(localPeer, false, false, false);
// 向其他节点广播自己的状态
if (_options.broadcast) {
this.m_bucket.forEachPeer(peer => {
if (peer.peerid !== localPeer.peerid) {
this.m_routeTable.ping(peer);
}
});
}
}
ping(remotePeerInfo, immediate) {
LOG_ASSERT(Peer.isValidPeerid(remotePeerInfo.peerid), `[DHT(${this.appid})] ActivePeer peerid is invalid:${remotePeerInfo.peerid}.`);
if (!Peer.isValidPeerid(remotePeerInfo.peerid)) {
return DHTResult.INVALID_ARGS;
}
if (immediate || this.m_bucket.isExpandable(remotePeerInfo.peerid)) {
this.m_routeTable.ping(remotePeerInfo);
}
return DHTResult.SUCCESS;
}
/**
* 对某个节点发起主动握手
* @param {Peer} remotePeer 握手的目标PEER对象
* @param {Peer} agencyPeer 与对方握手时可能提供帮助的中间节点，用于穿透
* @param {function({dht, result, remotePeer, isIncoming})} callback 握手完成的回调函数，支持await，
* result=0表示成功，其他表示失败
* remotePeer: 表示对方PEER的对象
* isIncoming: 对方主动连入
*/
handshake(remotePeer, agencyPeer, callback) {
const generateCallback = (handler) => (result, targetPeer, isIncoming) => {
if (!handler) {
return;
}
return handler({dht: this, result, remotePeer: targetPeer, isIncoming});
}
if (callback) {
this.m_taskExecutor.handshakeSource(remotePeer, agencyPeer, false, false, null, generateCallback(callback));
return DHTResult.PENDING;
} else {
return new Promise(resolve => {
this.m_taskExecutor.handshakeSource(remotePeer, agencyPeer, false, false, null, generateCallback(resolve));
});
}
}
updateLocalPeerAdditionalInfo(keyName, newValue) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) updateLocalPeerAdditionalInfo (${keyName}:${newValue}).`);
this.m_bucket.localPeer.updateAdditionalInfo(keyName, newValue);
}
getLocalPeerAdditionalInfo(keyName) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) getLocalPeerAdditionalInfo (${keyName}).`);
return this.m_bucket.localPeer.getAdditionalInfo(keyName);
}
deleteLocalPeerAdditionalInfo(keyName) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) deleteLocalPeerAdditionalInfo (${keyName}).`);
return this.m_bucket.localPeer.deleteAdditionalInfo(keyName);
}
_update() {
this.m_piecePackageRebuilder.clearTimeoutTasks();
super._update()
}
_processPackagePiece(socket, cmdPackage, remoteAddr, localAddr) {
if (!cmdPackage.body ||
typeof cmdPackage.body.max === 'object' ||
typeof cmdPackage.body.no === 'object' ||
(!cmdPackage.body.max && cmdPackage.body.max !== 0) ||
(!cmdPackage.body.no && cmdPackage.body.no !== 0) ||
parseInt(cmdPackage.body.max) < parseInt(cmdPackage.body.no)) {
return;
}
LOG_DEBUG(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) got package piece (taskid:${cmdPackage.body.taskid},max:${cmdPackage.body.max},no:${cmdPackage.body.no}).`);
cmdPackage.body.max = parseInt(cmdPackage.body.max);
cmdPackage.body.no = parseInt(cmdPackage.body.no);
let respPackage = this.m_packageFactory.createPackage(DHTCommandType.PACKAGE_PIECE_RESP);
respPackage.common.packageID = cmdPackage.common.packageID;
respPackage.common.ackSeq = cmdPackage.common.seq;
respPackage.body = {
taskid: cmdPackage.body.taskid,
no: cmdPackage.body.no,
};
let remotePeerInfo = {
peerid: cmdPackage.body.peerid,
eplist: [EndPoint.toString(remoteAddr)],
};
this.m_packageSender.sendPackage(remotePeerInfo, respPackage);
let originalPackageBuffer = this.m_piecePackageRebuilder.onGotNewPiece(cmdPackage);
if (originalPackageBuffer) {
originalPackageBuffer.__isCombine = true;
process.nextTick(() => this.process(socket, originalPackageBuffer, remoteAddr, localAddr));
}
}
}
DHT.EVENT = {
start: 'start',
stop: 'stop',
};
DHT.RESULT = DHTResult;
DHT.Package = DHTPackage;
DHT.PackageFactory = DHTPackageFactory;
// DHT服务子网，在整体DHT网络中提供某种特定服务的节点构成的子DHT网络
class ServiceDHT extends DHTBase {
constructor(father, serviceID) {
super(father.m_packageSender.mixSocket,
father.m_bucket.localPeer,
father.m_packageFactory,
father.m_taskExecutor.taskMgr,
father.m_remoteFilter);
this.m_father = father;
this.m_serviceID = serviceID;
if (father.servicePath.length > 0) {
this.m_servicePath = [...father.servicePath, this.serviceID];
} else {
this.m_servicePath = [this.serviceID];
}
this.m_taskExecutor.servicePath = this.m_servicePath;
this.m_packageProcessor.servicePath = this.m_servicePath;
this.m_flags = 0;
}
get servicePath() {
return this.m_servicePath;
}
get serviceID() {
return this.m_serviceID;
}
signinVistor() {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) signinVistor.`);
let isRunningBefore = this.isRunning();
this.m_flags |= ServiceDHT.FLAGS_SIGNIN_VISTOR;
if (!isRunningBefore) {
this._onStartWork();
}
}
signoutVistor() {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) signoutVistor.`);
this.m_flags &= ~ServiceDHT.FLAGS_SIGNIN_VISTOR;
if (this.m_subServiceDHTs.size === 0 && !this.isRunning()) {
this.m_father._onSubServiceDHTOffWork(this);
}
}
signinServer() {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) signinServer.`);
let isRunningBefore = this.isRunning();
this.m_flags |= ServiceDHT.FLAGS_SIGNIN_SERVER;
let localPeer = this.m_bucket.localPeer;
localPeer.signinService(this.m_servicePath);
this.m_bucket.activePeer(localPeer);
if (!isRunningBefore) {
this._onStartWork();
}
}
signoutServer() {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) signoutServer.`);
this.m_flags &= ~ServiceDHT.FLAGS_SIGNIN_SERVER;
let localPeer = this.m_bucket.localPeer;
localPeer.signoutService(this.m_servicePath);
this.m_bucket.removePeer(localPeer.peerid);
if (this.m_subServiceDHTs.size === 0 && !this.isRunning()) {
this.m_father._onSubServiceDHTOffWork(this);
}
const serviceTableName = this.servicePath.join('@');
this.rootDHT.deleteValue(serviceTableName, localPeer.peerid);
}
updateServiceInfo(key, value) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) updateServiceInfo(${key}:${value}).`);
this.m_bucket.localPeer.updateServiceInfo(this.m_servicePath, key, value);
}
getServiceInfo(key) {
let value = this.m_bucket.localPeer.getServiceInfo(this.m_servicePath, key);
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) getServiceInfo(${key}:${value}).`);
return value;
}
deleteServiceInfo(key) {
LOG_INFO(`[DHT(${this.appid})] LOCALPEER(${this.m_bucket.localPeer.peerid}:${this.servicePath}) deleteServiceInfo(${key}).`);
this.m_bucket.localPeer.deleteServiceInfo(this.m_servicePath, key);
}
isRunning() {
return this.m_flags != 0;
}
_findPeer(peerid, callback, onStep) {
// 1.先在子网内搜索，成功则返回
const onFindPeerComplete = (result, peers = []) => {
const localPeer = this.m_bucket.localPeer;
if (peers.length === 0 ||
(peers.length === 1 && peers[0].peerid === localPeer.peerid)) {
// 2.没找到，或者只找到自己，搜索一下VALUE表中搜索
const serviceTableName = this.servicePath.join('@');
this.rootDHT._getValue(serviceTableName, localPeer.peerid, GetValueFlag.UpdateLatest,
({result, values}) => {
if (!values || values.size === 0) {
// 3.如果VALUE表中也没有搜索到，把自己写入VALUE表，失败返回
let isInService = !localPeer.inactive;
if (isInService) {
const serviceDescriptor = localPeer.findService(this.servicePath);
isInService = serviceDescriptor && serviceDescriptor.isSigninServer();
}
if (isInService) {
this.rootDHT.saveValue(serviceTableName, localPeer.peerid, localPeer.eplist);
}
callback(DHTResult.SUCCESS, []);
} else {
// 4.如果从VALUE表中找到节点信息，成功则把找到的节点放入本地路由表
let peersFromTable = [];
values.forEach((eplist, peerid) => {
let peer = new Peer({peerid, eplist});
this.rootDHT.ping(peer);
peersFromTable.push(peer);
});
callback(DHTResult.SUCCESS, peersFromTable);
}
});
} else {
callback(result, peers);
}
}
return super._findPeer(peerid, onFindPeerComplete, onStep);
}
_onStartWork() {
this.m_father._onSubServiceDHTStartWork(this);
if (this.m_subServiceDHTs) {
this.m_subServiceDHTs.forEach(subSrv => subSrv._onSuperServiceStartWork(this));
}
}
_onSuperServiceStartWork(superService) {
this.m_bucket.forEachPeer(peer => superService._activePeer(peer, false, false, false));
if (this.m_subServiceDHTs) {
this.m_subServiceDHTs.forEach(subSrv => subSrv._onSuperServiceStartWork(superService));
}
}
}
ServiceDHT.FLAGS_SIGNIN_VISTOR = 0x1;
ServiceDHT.FLAGS_SIGNIN_SERVER = 0x1 << 1;
module.exports = DHT;
|
import * as React from 'react';
const injectProp = WrappedComponent => props => <WrappedComponent {...props} injected={42} />;
const MyComponent = (shouldBePassed, injected) => shouldBePassed.toFixed() + injected.toFixed();
const MyEnhancedComponent = injectProp(MyComponent);
export const Usage = () => (
<div>
<MyEnhancedComponent shouldBePassed={-1} />
<MyEnhancedComponent shouldBePassed={'bla-bla'} /> {/* runtime error */}
<MyEnhancedComponent /> {/* runtime error */}
<MyEnhancedComponent shouldBePassed={-1} injected={3} /> {/* erase prop without any warnings */}
<MyEnhancedComponent shouldBePassed={-1} injected={'text'} /> {/* erase prop (with wrong type) without any warnings */}
<MyEnhancedComponent shouldBePassed={-1} otherProp={'text'} /> {/* unnecessary prop */}
</div>
);
|
// Configure paths for vendor libraries
require.config({
paths: {
jquery: '/vendor/require-jquery.js',
underscore: '/vendor/underscore-min.js',
backbone: '/vendor/backbone-min.js',
}
});
require(['app'], function(App) {
App.initialize();
})
|
angular.module("shop2App").controller('zyqj', ['$scope','$http','$stateParams', function($scope,$http,$stateParams){
$scope.zybool=true;
$scope.zy_img="images/zy-1.jpg"
$scope.zy_xiala=function(){
if ($scope.zybool) {
$scope.zy_img="images/zy-2.png"
$scope.zybool=false;
}else{
$scope.zy_img="images/zy-1.jpg"
$scope.zybool=true;
}
}
$http({
url:"http://47.88.16.225:412/qingjia",
method:"get"
}).then(function(e){
$scope.data=e.data
console.log($scope.data)
})
}]) |
import { isString } from 'lodash'
import { toUnit, toPrecision } from 'Utilities/convert'
const createStatus = (code, label, labelClass) => (detailsCode, details) => ({ code, label, labelClass, detailsCode, details })
const statusPending = createStatus('pending', 'Processing', 'text-primary')
const statusFailed = createStatus('failed', 'Failed', 'text-warning')
const statusComplete = createStatus('complete', 'Complete', 'text-success')
export const getSwapStatus = (swap) => {
const { error, rate, orderId, order, tx } = swap
if (error) {
if (isString(error) && error.toLowerCase().includes('insufficient funds')) {
return statusFailed('insufficient_funds', 'Insufficient funds')
}
return statusFailed('error', getSwapFriendlyError(swap))
}
if (!(order && orderId)) {
return statusPending('creating_order', 'Creating order')
}
if (order.error) {
return statusFailed('order_error', 'An error occured with this order, please contact support@faa.st')
}
if (order.status === 'failed' || order.status === 'cancelled') {
return statusFailed(`order_${order.status}`, 'Order was unsuccessful, please contact support@faa.st')
}
if (order.status === 'complete') {
return statusComplete('order_complete', 'Order completed successfully')
}
if (!rate) {
return statusPending('fetching_rate', 'Fetching market info')
}
if (!(tx && tx.walletId)) {
return statusPending('creating_tx', 'Generating deposit transaction')
}
if (!tx.receipt) {
if (tx.sendingError) {
return statusFailed('send_tx_error', 'Failed to send deposit transaction, please try again')
}
if (tx.sending) {
return statusPending('sending', 'Sending deposit transaction')
}
if (tx.sent) {
return statusPending('pending_receipt', 'Waiting for transaction confirmation')
}
if (tx.signingError) {
return statusFailed('sign_tx_error', 'Failed to sign deposit transaction, please try again')
}
if (tx.signing) {
return statusPending('signing', 'Awaiting signature')
}
if (tx.signed) {
return statusPending('signed', 'Ready to send')
}
if (!tx.signingSupported) {
return statusPending('signing_unsupported', 'Ready to send')
}
return statusPending('unsigned', 'Ready to sign')
}
return statusPending('processing', 'Processing swap')
}
export const statusAllSwaps = (swaps) => {
if (!swaps || !swaps.length) {
return null
}
const statusCodes = swaps.map(getSwapStatus).map(({ code }) => code)
if (statusCodes.includes('failed')) {
return 'failed'
}
if (statusCodes.includes('pending')) {
return 'pending'
}
if (statusCodes.every((status) => status === 'complete')) {
return 'complete'
}
return statusCodes[0]
}
export const getSwapFriendlyError = (swap) => {
const { error, errorType } = swap
if (!error) return error
if (isString(error)) {
if (errorType === 'pollTransactionReceipt') {
return 'Failed to check deposit txn status'
}
if (errorType === 'sendTransaction') {
return 'Error sending deposit txn'
}
if (isString(errorType)) {
return error
}
}
return 'Unknown error'
}
export const estimateReceiveAmount = (swap) => {
const { fee, rate, sendUnits, receiveAsset } = (swap || {})
if (fee && rate && sendUnits) {
const converted = toUnit(sendUnits, rate, receiveAsset.decimals)
return toPrecision(converted.minus(fee), receiveAsset.decimals)
}
}
|
import React, { PureComponent } from 'react';
import Head from 'next/head';
import Router from 'next/router';
import Masthead from 'molecules/masthead';
import MainNav from 'organisms/main-nav';
import Fonts from 'util/fonts.js';
import stylesheet from 'styles/style.scss';
class Header extends PureComponent {
async componentDidMount() {
Fonts();
}
handleMenuClose = () =>
Router.events.on( 'routeChangeComplete', () =>
this.props.handleMenuClose(),
);
render() {
const { menu, menuIsOpen, handleMenuChange, device } = this.props;
return (
<div>
<Head>
<style dangerouslySetInnerHTML={ { __html: stylesheet } } />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<meta charSet="utf-8" />
<title>Dash</title>
</Head>
<Masthead
handleMenuChange={ handleMenuChange }
handleMenuClose={ this.handleMenuClose }
menuIsOpen={ menuIsOpen }
/>
<MainNav
handleMenuChange={ handleMenuChange }
handleMenuClose={ this.handleMenuClose }
isVisible={ menuIsOpen }
menu={ menu }
/>
</div>
);
}
}
export default Header;
|
import Welcome from "../containers/Welcome/Welcome";
import Today from "../containers/Today/Today";
import Login from "../containers/Login/Login";
var dashRoutes = [
{
path: "/welcome",
name: "Welcome",
icon: "ui-1_bell-53",
component: Welcome
},
{
path: "/dashboard",
name: "Today",
icon: "design_app",
component: Today
},
{
pro: true,
path: "/login",
name: "Login",
icon: "objects_spaceship",
component: Login
},
];
export default dashRoutes;
|
$(function()
{
function Contenido(num){
var Botones =` <div class="btn-group" role="group" aria-label="...">
<button type="button" id="Binomial" class="btn btn-primary">Binomial</button>
<button type="button" id="Poisson" class="btn btn-primary">Poisson</button>
<button type="button" id="Normal" class="btn btn-primary">Normal Estándar</button>
</div> `
switch(num){
case 1:
var str = ` <div class='animated zoomInRight'>
<h1>Distribución Binomial</h1>
<p>
En estadística, la distribución binomial es una distribución de probabilidad discreta que cuenta el número de éxitos en una secuencia de n ensayos de Bernoulli independientes entre sí, con una probabilidad fija p de ocurrencia del éxito entre los ensayos. Un experimento de Bernoulli se caracteriza por ser dicotómico, esto es, sólo son posibles dos resultados. A uno de estos se denomina éxito y tiene una probabilidad de ocurrencia p y al otro, fracaso, con una probabilidad q = 1 - p. En la distribución binomial el anterior experimento se repite n veces, de forma independiente, y se trata de calcular la probabilidad de un determinado número de éxitos. Para n = 1, la binomial se convierte, de hecho, en una distribución de Bernoulli.
<button type="button" id="EjBinomial" class="btn btn-info Micss" data-toggle="modal" data-target="#MiVentana">Ejemplo</button>
</p>
<img src="http://4.bp.blogspot.com/-IFBNMkkc-d4/UZM--sjiw4I/AAAAAAAAD_Y/e6Gg6b_mV7c/s1600/Captura+de+pantalla+de+2013-05-15+09:51:54.png">
</div>
`
break;
case 2:
var str = ` <div class='animated lightSpeedIn'>
<h1>Distribución de Poisson</h1>
<p>
En teoría de probabilidad y estadística, la distribución de Poisson es una distribución de probabilidad discreta que expresa, a partir de una frecuencia de ocurrencia media, la probabilidad de que ocurra un determinado número de eventos durante cierto período de tiempo. Concretamente, se especializa en la probabilidad de ocurrencia de sucesos con probabilidades muy pequeñas, o sucesos "raros".
<button type="button" id="EjPoisson" class="btn btn-info Micss" data-toggle="modal" data-target="#MiVentana">Ejemplo</button>
</p>
<img src="https://descalzarte5678.files.wordpress.com/2014/12/poisson-2.jpg">
</div>
`
break;
case 3:
var str = ` <div class='animated fadeInLeftBig'>
<h1>Distribución Normal Estándar</h1>
<p>
En estadística y probabilidad se llama distribución normal, distribución de Gauss o distribución gaussiana, a una de las distribuciones de probabilidad de variable continua que con más frecuencia aparece aproximada en fenómenos reales.
<button type="button" id="EjNormal" class="btn btn-info Micss" data-toggle="modal" data-target="#MiVentana">Ejemplo</button>
</p>
<img src="https://qualitasaagg.files.wordpress.com/2015/01/curva-distribucic3b3n-normal.jpg">
</div>
`
break;
}
$('#Texto').html(Botones+str);
//Navegación
$('#Binomial').click(function(){
Contenido(1);
});
$('#Poisson').click(function(){
Contenido(2);
});
$('#Normal').click(function(){
Contenido(3);
});
$('#EjBinomial').click(function(){
Ejemplos(1,'Distribución Binomial');
});
$('#EjPoisson').click(function(){
Ejemplos(2,'Distribución de Poisson');
});
$('#EjNormal').click(function(){
Ejemplos(3,'Distribución Normal');
});
//Ejemplos
}Contenido(1);
function Ejemplos (num,title){
var head = `<div class="modal fade" id="MiVentana" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true" >
<div class="modal-dialog">
<div class="modal-content">
<div class="modal-header">
<button type="button" class="close" data-dismiss="modal">×</button>
<h4 class="modal-title">${title}</h4>
</div>
<div id="DatosModal" class="modal-body">
`
switch(num){
case 1:
Titulo = 'Distribución Binomial';
var str = "Ejemplo Binomial";
break;
case 2:
Titulo = 'Distribución de Poisson';
var str = "Ejemplo Poisson";
break;
case 3:
Titulo = 'Distribución Normal';
var str = "Ejemplo Normal";
break;
}
var footer = `</div>
<div class="modal-footer">
</div>
</div>
</div>
</div>`
$('#Ejemplos').html(head+str+footer);
}Ejemplos(1,'Distribución Binomial');
}) |
import React, { Component } from 'react';
import logo from './logo.svg';
import parseData from './helperFunctions';
import './App.css';
var config = require('./config.json');
class App extends Component {
state = {
isDragged: false,
img : "",
text: []
}
componentDidMount(){
}
handleImage(reader) {
const b64 = reader.split(',', 2)[1];
console.log(b64)
fetch(`https://vision.googleapis.com/v1/images:annotate?key=${config.visionApiKey}`, {
method: 'POST',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json'
},
body: JSON.stringify({
"requests":[
{
"image":{
"content": b64
},
"features":[
{
"type": "DOCUMENT_TEXT_DETECTION",
"maxResults":10
}
],
"imageContext": {
"languageHints": ["en"]
}
}
]
})
})
.then(res => res.json())
.then(data => {
// console.log(data)
const parsed = parseData(data.responses["0"].textAnnotations);;
if (data.responses.length) {
this.setState({
text: parsed
})
}
})
}
_fileHandle(e) {
e.preventDefault();
let reader = new FileReader();
let file = e.target.files[0];
reader.onloadend = () => {
this.handleImage(reader.result);
this.setState({
img: reader.result
})
}
reader.readAsDataURL(file)
this.state.isDragged = true;
}
copy = () =>{
const copyText = document.getElementById("txt");
const textArea = document.createElement("textarea");
textArea.value = copyText.textContent;
document.body.appendChild(textArea);
textArea.select(); // set variable then put it in docs textarea.select const file = textArea
//console.log(textArea)
document.execCommand("Copy");
textArea.remove();
}
render() {
const listItems = this.state.text.map((sentence) => {
<p> {sentence} </p>
})
return (
<div className="App">
<header>Picture Notes</header>
<div className ="adjust-button">
<input type='file' onChange={(e) => this._fileHandle(e)}/>
<br/>
</div>
<br/>
<div className="adjust-image">
<img className="real-img" src={this.state.img}/>
</div>
{this.state.isDragged ?(
<div className= "adjust-txt">
<br/>
<button onClick={() => this.copy()}>Copy to Clipboard</button>
<p id="txt"> {this.state.text.map((line) => <p> {line}</p>)} </p>
<input type ='text' id ='result' value ={this.state.text.map((line) => <p> {line}</p>)}></input>
</div>
):<div></div>
}
</div>
);
}
}
export default App;
|
import React from 'react';
import {
render,
} from '@testing-library/react-native';
import App from '../App';
let component;
describe('<App />', () => {
beforeEach(() => {
component = render(<App />);
});
it('It should render correctly', () => {
expect(component).toBeDefined();
});
it('it should render <NavigationContainer/>', () => {
expect(component.queryByTestId('nav-container')).toBeDefined();
});
it('It should render <Tabs/> component', () => {
expect(component.queryByTestId('screens')).toBeDefined();
});
});
|
import React from "react";
import { mount } from "enzyme";
import App from "../App";
import SearchBar from "../SearchBar";
import Root from "../../Root";
let wrapped;
beforeEach(() => {
wrapped = mount(
<Root>
<App />
</Root>
);
});
it("shows a search bar", () => {
expect(wrapped.find(SearchBar).length).toEqual(1);
});
|
import React from 'react';
import bootstrap from 'bootstrap/scss/bootstrap.scss';
import classes from './HeadingTitle.scss';
import Aux from '../../../hoc/Aux/Aux';
import { CURRENT_MESES } from '../../../scripts/config';
const HeadeingTitle = ({ title, date, detailsHead, categDetails }) => {
let details;
if (detailsHead === 1) {
details = (
<ul className={bootstrap['list-unstyled']}>
<li className={bootstrap['list-inline-item']}>
<i className="far fa-clock" />
{CURRENT_MESES || date}
</li>
<li className={bootstrap['list-inline-item']}>
<i className="far fa-eye" />
<span className={classes.Count}>15</span>
vistas
</li>
<li
className={[bootstrap['list-inline-item'], classes.Compartir].join(
' ',
)}
>
<i className="fas fa-share-alt" />
<span>compartir</span>
<div className={classes.toggleCompart}>
<ul className={bootstrap['list-unstyled']}>
<li>
<a href="/">
<i className="fab fa-facebook-square" />
Facebook
</a>
</li>
<li>
<a href="/">
<i className="fab fa-twitter" />
Twitter
</a>
</li>
<li>
<a href="/">
<i className="fab fa-linkedin-in" />
Linkedin
</a>
</li>
<li>
<a href="/">
<i className="fab fa-whatsapp" />
WhatsApp
</a>
</li>
<li>
<a href="/">
<i className="far fa-envelope" />
E-mail
</a>
</li>
</ul>
</div>
</li>
</ul>
);
} else if (detailsHead === 2) {
details = (
<div className={classes.detailsAdv}>
<ul
className={[bootstrap['list-unstyled'], classes.BaseAdv1].join(' ')}
>
<li className={bootstrap['list-inline-item']}>
<div className={classes.Categoria}>Blog</div>
</li>
<li className={bootstrap['list-inline-item']}>
<i className="far fa-clock" />
{CURRENT_MESES}
</li>
</ul>
<ul
className={[bootstrap['list-unstyled'], classes.BaseAdv2].join(' ')}
>
<li className={bootstrap['list-inline-item']}>
<i className="far fa-eye" />
<span className={classes.Count}>15</span>
vistas
</li>
<li className={bootstrap['list-inline-item']}>
<i className="fas fa-comments" />
<span className={classes.Count}>3</span>
comentarios
</li>
<li
className={[bootstrap['list-inline-item'], classes.Compartir].join(
' ',
)}
>
<i className="fas fa-share-alt" />
<span>compartir</span>
<div className={classes.toggleCompart}>
<ul className={bootstrap['list-unstyled']}>
<li>
<a href="/">
<i className="fab fa-facebook-square" />
Facebook
</a>
</li>
<li>
<a href="/">
<i className="fab fa-twitter" />
Twitter
</a>
</li>
<li>
<a href="/">
<i className="fab fa-linkedin-in" />
Linkedin
</a>
</li>
<li>
<a href="/">
<i className="fab fa-whatsapp" />
WhatsApp
</a>
</li>
<li>
<a href="/">
<i className="far fa-envelope" />
E-mail
</a>
</li>
</ul>
</div>
</li>
</ul>
</div>
);
} else {
details = null;
}
return (
<Aux>
<div className={classes.HeadeingTitle}>
<h2>
<span>{title}</span>
</h2>
</div>
<div className={classes.Details}>{details}</div>
</Aux>
);
};
export default HeadeingTitle;
|
18 gid=1329781531
17 uid=183816338
20 ctime=1441138964
20 atime=1441138971
23 SCHILY.dev=16777221
23 SCHILY.ino=32546114
18 SCHILY.nlink=1
|
class Player {
constructor(ctx) {
this.ctx = ctx;
this.x = 500;
this.y = 420;
this.width = 40;
this.height = 40;
this.distance = 15;
this.direction = 'right';
}
goRight() {
this.x += this.distance;
if (this.x > 900) {
this.x = 0;
}
};
goLeft() {
this.x -= this.distance;
if (this.x < 0) {
this.x = 900; //this.distance - 1;
}
};
drawPlayer() {
/*this.ctx.fillStyle = 'black';
this.ctx.fillRect(this.x, this.y, 40, 40);*/
let miImg = new Image();
miImg.src = "images/player.png";
this.ctx.drawImage(miImg, this.x, this.y)
};
generateVaccines() {
for (let i = 0; i < 50; i++) {
this.vaccinesArr.push(new Vaccines(this.ctx));
}
}
} |
import $ from '../../core/renderer';
import { extend } from '../../core/utils/extend';
import eventsEngine from '../../events/core/events_engine';
import { addNamespace } from '../../events/utils/index';
import { name as clickEventName } from '../../events/click';
import { getImageContainer } from '../../core/utils/icon';
import Overlay from '../overlay/ui.overlay';
import { render } from '../widget/utils.ink_ripple';
import { isMaterial } from '../themes';
import { isPlainObject } from '../../core/utils/type';
var FAB_CLASS = 'dx-fa-button';
var FAB_ICON_CLASS = 'dx-fa-button-icon';
var FAB_LABEL_CLASS = 'dx-fa-button-label';
var FAB_LABEL_WRAPPER_CLASS = 'dx-fa-button-label-wrapper';
var FAB_CONTENT_REVERSE_CLASS = 'dx-fa-button-content-reverse';
var OVERLAY_CONTENT_SELECTOR = '.dx-overlay-content';
class SpeedDialItem extends Overlay {
_getDefaultOptions() {
return extend(super._getDefaultOptions(), {
shading: false,
useInkRipple: false,
callOverlayRenderShading: false,
width: 'auto',
zIndex: 1500
});
}
_defaultOptionsRules() {
return super._defaultOptionsRules().concat([{
device() {
return isMaterial();
},
options: {
useInkRipple: true
}
}]);
}
_render() {
this.$element().addClass(FAB_CLASS);
this._renderIcon();
this._renderLabel();
super._render();
this.option('useInkRipple') && this._renderInkRipple();
this._renderClick();
}
_renderLabel() {
!!this._$label && this._$label.remove();
var labelText = this.option('label');
if (!labelText) {
this._$label = null;
return;
}
var $element = $('<div>').addClass(FAB_LABEL_CLASS);
var $wrapper = $('<div>').addClass(FAB_LABEL_WRAPPER_CLASS);
this._$label = $wrapper.prependTo(this.$content()).append($element.text(labelText));
this.$content().toggleClass(FAB_CONTENT_REVERSE_CLASS, this._isPositionLeft(this.option('parentPosition')));
}
_isPositionLeft(position) {
var currentLocation = '';
if (position) {
if (isPlainObject(position) && position.at) {
if (position.at.x) {
currentLocation = position.at.x;
} else {
currentLocation = position.at;
}
} else {
if (typeof position === 'string') {
currentLocation = position;
}
}
}
return currentLocation.split(' ')[0] === 'left';
}
_renderButtonIcon($element, icon, iconClass) {
!!$element && $element.remove();
$element = $('<div>').addClass(iconClass);
var $iconElement = getImageContainer(icon);
$element.append($iconElement).appendTo(this.$content());
return $element;
}
_renderIcon() {
this._$icon = this._renderButtonIcon(this._$icon, this._options.silent('icon'), FAB_ICON_CLASS);
}
_renderWrapper() {
if (this._options.silent('callOverlayRenderShading')) {
super._renderWrapper();
}
}
_getVisibleActions(actions) {
var currentActions = actions || this.option('actions') || [];
return currentActions.filter(action => action.option('visible'));
}
_getActionComponent() {
if (this._getVisibleActions().length === 1) {
return this._getVisibleActions()[0];
} else {
return this.option('actionComponent') || this.option('actions')[0];
}
}
_initContentReadyAction() {
this._contentReadyAction = this._getActionComponent()._createActionByOption('onContentReady', {
excludeValidators: ['disabled', 'readOnly']
}, true);
}
_fireContentReadyAction() {
this._contentReadyAction({
actionElement: this.$element()
});
}
_updateZIndexStackPosition() {
var zIndex = this.option('zIndex');
this._$wrapper.css('zIndex', zIndex);
this._$content.css('zIndex', zIndex);
}
_fixWrapperPosition() {
var $wrapper = this._$wrapper;
var $container = this._getContainer();
$wrapper.css('position', this._isWindow($container) ? 'fixed' : 'absolute');
}
_setClickAction() {
var eventName = addNamespace(clickEventName, this.NAME);
var overlayContent = this.$element().find(OVERLAY_CONTENT_SELECTOR);
eventsEngine.off(overlayContent, eventName);
eventsEngine.on(overlayContent, eventName, e => {
var clickActionArgs = {
event: e,
actionElement: this.element(),
element: this._getActionComponent().$element()
};
this._clickAction(clickActionArgs);
});
}
_defaultActionArgs() {
return {
component: this._getActionComponent()
};
}
_renderClick() {
this._clickAction = this._getActionComponent()._createActionByOption('onClick');
this._setClickAction();
}
_renderInkRipple() {
this._inkRipple = render();
}
_getInkRippleContainer() {
return this._$icon;
}
_toggleActiveState($element, value, e) {
super._toggleActiveState.apply(this, arguments);
if (!this._inkRipple) {
return;
}
var config = {
element: this._getInkRippleContainer(),
event: e
};
if (value) {
this._inkRipple.showWave(config);
} else {
this._inkRipple.hideWave(config);
}
}
_optionChanged(args) {
switch (args.name) {
case 'icon':
this._renderIcon();
break;
case 'onClick':
this._renderClick();
break;
case 'label':
this._renderLabel();
break;
case 'visible':
this._currentVisible = args.previousValue;
args.value ? this._show() : this._hide();
break;
case 'useInkRipple':
this._render();
break;
default:
super._optionChanged(args);
}
}
}
export default SpeedDialItem; |
input = [20, 0, 1, 11, 6, 3]
function elfMemoryGame(starting, target) {
let memory = new Map();
starting.forEach((num, idx) => {
memory.set(num, idx + 1);
})
let turn = starting.length + 1;
let currNum = 0;
while (turn <= target) {
if (turn === target) {
break;
}
if (memory.get(currNum) || memory.get(currNum) === 0) {
let lastSpoken = memory.get(currNum);
memory.set(currNum, turn);
currNum = turn - lastSpoken;
} else {
memory.set(currNum, turn);
currNum = 0;
}
turn++;
}
return currNum;
}
console.log(elfMemoryGame(input, 30000000)) |
import React, { useState, useEffect } from "react";
import { connect } from "react-redux";
import api from "../../utils/api";
//START Charlie
import { editClass } from "../../actions/classes";
import { deleteClass } from "../../actions/classes";
import ClassCard from "./ClassCard";
//END Charlie
const CardsList = props => {
// console.log(props.class_item[0], 'ClassList')
return (
<>
<div>
<h1>Your Classes</h1>
{/* <h1>Dashboard - Card List</h1> */}
<div style={{ display: "flex", flexDirection: "row" }}>
{props.class_details.map((item, index) => (
<ClassCard
key={index}
class_details={item}
editClass={props.editClass}
deleteClass={props.deleteClass}
/>
))}
</div>
</div>
</>
);
};
const mapStateToProps = state => {
return {
class_details: state.classes.classes
};
};
const mapDispatchToProps = {
editClass,
deleteClass
};
export default connect(mapStateToProps, mapDispatchToProps)(CardsList);
// export default CardsList; |
export default (sequelize, DataTypes) => {
const Category = sequelize.define('Category', {
id: {
type:DataTypes.STRING,
primaryKey:true,
unique:true,
},
name: {
type:DataTypes.STRING,
unique:true
}
});
Category.associate = function(models) {
Category.hasMany(models.News)
};
return Category;
}; |
export default [
{
prop: 'name',
label: '规格名称',
rule: { required: true, message: '请输入规格名称' },
render(h) {
return <i-input v-model={this.model} placeholder='请输入规格名称'></i-input>
}
},
{
prop: 'value',
label: '规格值',
rule: { required: true, message: '请输入规格值' },
render(h) {
h = this.$root.$createElement
return <tags-input v-model={this.model} btnName='添加规格值'></tags-input>
}
}
]
|
import support from "./support.js"; //
import Draggable from "./Draggable.js";
import "./polyfills/polyfill"; // перетаскивание плеера
import HLSPlayer from "./players/hls/HLSPlayer.js";
import SLDPPlayer from "./players/sldp/SLDPPlayer.js";
import NativePlayer from "./players/native/NativePlayer.js";
//import FlashPhonerPlayer from "./players/flashPhoner/FlashPhoner.js";
import FlashPhonerPlayer from "./players/IFlashPhoner/FlashPhoner.js";
//alert("hello world 2");
class WhenspeakStreamer {
constructor(params){
var width=screen.width, // ширина
height=screen.height; // высота
//alert([width, height]);
//========================================//
params = params ||{};
this.params = params;
this.wrapper = document.createElement("div");
this.wrapper.id ="sldp_player_wrapper";
this.wrapper.style.width = params.width || "400px";
this.wrapper.style.height = params.height || "270px";
this.wrapper.style.background = "black";
this.wrapper.style.position = "fixed";
this.wrapper.style.display = "none";
this.wrapper.style.right = "0px";
this.wrapper.style.bottom = "0px";
this.wrapper.style.userSelect= "none";
this.preloader = document.createElement("div");
this.preloader.style.position = "absolute";
this.preloader.style.width = this.wrapper.style.width;
this.preloader.style.height = this.wrapper.style.height;
this.preloader.style.left = "0px";
this.preloader.style.top = "0px";
this.preloader.style.left = "0px";
this.preloader.style.background = "black";
var image = document.createElement("img");
image.src = "/images/ajax-loader.svg";
image.style.paddingLeft="50%";
image.style.marginLeft="-50px";
image.style.paddingTop="50%";
image.style.marginTop="-100px";
image.style.zIndex="9999";
this.preloader.appendChild(image);
this.wrapper.appendChild(this.preloader);
document.body.appendChild( this.wrapper );
//протоколы
var v = support.is_safari ? support.getSafaryVersion().split(".")[0]:null;
this.sources = params.sources;
this.protocols = (support.is_safari && (support.iosX || Number(v)<9)) ? params.srcProtocolsOldSafary : params.srcProtocols;
this.protocolIndex = 0;
this.resetIndex();
//is play
this.isPlay = false;
//супервизор
this.onCanPlay = this.onCanPlay.bind(this);
this.supervizor = this.supervizor.bind(this);
this.supervizor(); //запускаем супервизор
//перетаскивание окна
this.dragManager = new Draggable(this.wrapper); //TODO draggable нельзя обьявлять здесь
//var fp =new FlashPhonerPlayer();
//console.log(fp);
//=====================================================================================
}
init (roomId) {
//alert("init " + roomId);
this.isPlay = true;
this.wrapper.style.display = "none";
//if(this.currentRoom !== roomId){
//this.protocolCount =0;
this.protocolIndex =0;
this.resetIndex();
console.log("!!!!! ВНИМАНИЕ Я СБРОСИЛ ДИГРАДАЦИИ !!!!")
this.currentRoom = roomId;
if(this.instance)
this.destroyPlayer();
this.instance = this.createPlayer( roomId );
//}
}
/*stop(){
console.log("playstop");
this.isPlay = false;
this.wrapper.style.display = "none";
this.destroyPlayer();
this.instance = null;
this.currentRoom = null;
}*/
play () {
//console.log("index-play");
this.wrapper.style.display = "block";
if(!this.instance.isPlay)
this.instance.play();
}
stop () {
//console.log("index-stop");
console.log(">>>>>>>>>>>>>>>>>>>>>>>>> STOP = ", this.instance.isPlay);
this.wrapper.style.display = "none";
if(this.instance.isPlay)
this.instance.pause();
}
playstop (roomId) {
if(!this.instance){
console.error("no player intance")
return;
}
if(this.instance.isPlay)
this.stop();
else
this.play(roomId);
}
//======================================= low level ========================================//
// hls - врубает hls плеер (в зависимости от устройства нативный или на JS EMS)
// ws - врубает плеер на веб сокетах
createPlayer( room ){
var protocol = this.protocols[ this.protocolIndex ].split(":"),
instance,
params = this.params;
if(!this.troubleTimeout){
this.troubleTimeout = setTimeout(function(){
/*if(params.onTrouble)
params.onTrouble()*/
}, 30000);
//console.log("запущено ожидание трабла");
}
//this.preloader.style.display="block";
this.preloader.style.display = "none";
//===============================================================//
//let src = this.params.sources["hls"][0];
//instance = new FlashPhonerPlayer(src, room, this.params);
//instance = new NativePlayer(src, room, this.params);
//===============================================================//
//console.log("============= создаю плеер -> ", protocol[0] )
if( protocol[0] == "FlashPhoner" ) {
//let src = this.params.sources["ws"][0]; //балансировка по серверам отсутствует, поэтому пока берем всегда первый
//console.log("instance flash phoner");
instance = new FlashPhonerPlayer("", room, this.params);
} else if( protocol[0] == "hls" ) {
//alert("пробую использовать HLS");
let src = this.params.sources["hls"][0]; //балансировка по серверам отсутствует, поэтому берем всегда первый
var v= support.is_safari && support.getSafaryVersion().split(".")[0];
if ((support.iosX && support.is_safari) || (support.is_safari && Number(v)<9)) {
//7alert("нативный плеер");
instance = new NativePlayer(src, room, this.params);
} else {
instance = new HLSPlayer(src, room, this.params);
//instance = new FlashPhonerPlayer("", room, this.params);
}
} else if( protocol[0] == "ws" ) {
let src = this.params.sources["ws"][0]; //балансировка по серверам отсутствует, поэтому пока берем всегда первый
instance = new SLDPPlayer(src, room, this.params);
}
if(instance){
this.instance = instance;
this.instance.onCanPlay = this.onCanPlay;
}
return instance;
};
destroyPlayer(){
if(this.instance){
this.instance.destroy();
}
}
supervizor () {
/*if(this.instance && this.instance.canPlay){
console.log("ПРячу прелоадер");
this.preloader.style.display="none";
}*/
if(this.instance && this.instance.needRestart){
this.protocolCount --;
//console.log(">>>", this.protocolCount);
if(this.protocolCount<1){
this.protocolIndex = this.protocolIndex+1<this.protocols.length ?this.protocolIndex + 1 : 0;
//console.log("protocol index = ", this.protocolIndex);
this.resetIndex();
}
this.destroyPlayer();
this.createPlayer( this.currentRoom );
this.instance.play();
}
setTimeout(this.supervizor, 3000)
}
onCanPlay(){
//alert("onCanplay");
clearTimeout(this.troubleTimeout);
//console.log("ожидание трабла остановлено");
this.troubleTimeout = null;
this.preloader.style.display="none";
}
resetIndex(){
var protocol = this.protocols[ this.protocolIndex ].split(":");
this.protocol = protocol[0];
this.protocolCount = Number(protocol[1]);
//console.log("protocol=", protocol);
}
}
window.WhenSpeakStreamer = WhenspeakStreamer; |
/**
* Socket.io configuration
*/
'use strict';
module.exports = config;
import _ from 'lodash';
// const statusSocket = require('../api/status/status.socket');
const remoteCommandsSocket = require('../api/remoteCommands/remoteCommands.socket');
const sockData = require('../components/sockData');
const session = require('../api/session/session.controller');
const jsDataSocket = require('../api/jsData/jsData.socket');
const authorizationForSocket = require('../components/auth').authorizationForSocket;
import {agentName, agentBuild} from '../components/util';
function onDisconnect(socket) {
console.info('DISCONNECTED',
'id:', socket.id,
'address:', socket.handshake.headers['x-real-ip'] || socket.handshake.address
);
}
function onConnect(socket) {
console.info('CONNECTED',
'id:', socket.id,
'address:', socket.handshake.headers['x-real-ip'] || socket.handshake.address
);
socket.setMaxListeners(20);
socket.userAgent = socket.handshake.headers['user-agent'];
session.register(socket);
socket.on('authorization', onAuthorizationCallback(socket));
socket.on('info', (data, clientAck) => {
let ack = (typeof clientAck === 'function') ? clientAck : function () {
};
ack((new Date()).toISOString());
console.info('info:', 'userId:', socket.userId, 'deviceUUID:', socket.deviceUUID, 'data:', JSON.stringify(data));
});
}
function onAuthorizationCallback(socket) {
return (data, clientAck) => {
let ack = _.isFunction(clientAck) ? clientAck : _.noop;
if (!data) {
return ack({isAuthorized: false});
}
if (data.bundleIdentifier && data.appVersion) {
socket.userAgent = data.bundleIdentifier + '/' + data.appVersion;
}
console.info('authorization:', socket.id, agentName(socket), agentBuild(socket), data.accessToken);
if (socket.isAuthorized && socket.accessToken === data.accessToken) {
return ack({
isAuthorized: true,
wasAuthorized: true
});
}
if (!socket.isAuthorized && data.accessToken) {
socket.accessToken = data.accessToken;
socket.deviceUUID = data.deviceUUID;
socket.deviceInfo = socket.deviceUUID ? data : undefined;
authorizationForSocket(socket)
.then(isAuthorized => {
socket.isAuthorized = !!isAuthorized;
if (isAuthorized) {
jsDataSocket.register(socket);
session.registerSubs(socket);
sockData.register(socket);
// statusSocket.register(socket);
remoteCommandsSocket.register(socket);
}
ack({isAuthorized: socket.isAuthorized});
})
.catch(error => {
if (error) {
console.error(error);
}
ack({error: error});
});
} else {
if (!data.accessToken) {
jsDataSocket.register(socket);
}
delete socket.accessToken;
delete socket.userId;
ack({isAuthorized: false});
}
};
}
function config(socketIO) {
socketIO.on('connection', function (socket) {
socket.address = socket.handshake.address !== null ?
socket.handshake.address.address + ':' + socket.handshake.address.port :
process.env.DOMAIN;
socket.connectedAt = new Date();
socket.on('disconnect', function () {
onDisconnect(socket);
});
onConnect(socket);
});
}
|
const mongoose = require('mongoose');
const printerSchema = mongoose.Schema({
_id: mongoose.Schema.Types.ObjectId,
type: {type: String},
models : {type: String},
marque: {type:String},
paper: {type: String},
});
module.exports = mongoose.model('Printer', printerSchema); |
var async = require('async');
var MongoClient = require('mongodb').MongoClient
, assert = require('assert');
// var url = 'mongodb://localhost:27017/myproject';
var crudFunctions = [];
var allResults = {};
module.exports = function(app, url) {
app.get('/testseed', function(req, res) {
// setup seed database
var seedArtefacts = [
{
title : "An artefact",
creator : "Test O'Testing",
subject : "Testing things",
description : "This is a description of a thing that is being tested now."
},
{
title : "Another artefact",
creator : "Tester Testerson",
subject : "A test of many things",
description : "What a day to be testing things."
},
{
title : "More artefacts",
creator : "T. E. Ster",
subject : "The fast testing of testable things",
description : "Prolonged sentence about the testing of things that are being tested, by me, the tester." ,
hello : "Hi there, I'm now not breaking the schema!"
}
];
var seedInstitutionProfile = {
dates : {
dateFrom : new Date("2014"),
dateTo : new Date("2012")
},
coordinates : {
latitude : -47.15,
longitude : -126.71666666666667,
addressNumber : "A number or name",
addressStreetName : "A street",
addressCity : "A city",
addressCounty : "A country",
addressPostcode : "P0 5T"
},
keyWords : {
keyWord : "Word"
},
webSites : {
webSite : "http://www.website.com",
},
artefacts : {
artefact : "an artefact"
}
};
var seedLocationProfile = {
coordinates : {
latitude : -47.15,
longitude : -126.71666666666667,
addressNumber : "A number or name",
addressStreetName : "A street",
addressCity : "A city",
addressCounty : "A country",
addressPostcode : "P0 5T"
},
name : "A name",
otherNames : "14",
dates : {
dateTo : new Date("October 13, 2014 11:13:00"),
dateFrom : new Date("October 13, 2016 11:13:00")
}
};
var seedPersonProfile = {
firstName : "Frank",
middleNames : "E",
surnames : "Pabodie",
birth : {
date : new Date("April 20, 1947"),
institution : "An institution"
},
death : {
date : new Date("February 14, 1967"),
institution : "Another institution"
},
address : {
dates : {
dateFrom: new Date("February 14, 1917"),
dateTo : new Date("February 14, 1967")
},
coordinates : {
latitude : -47.15,
longitude : -126.71666666666667,
addressNumber : "A number or name",
addressStreetName : "A street",
addressCity : "A city",
addressCounty : "A country",
addressPostcode : "P0 5T"
}
}
};
MongoClient.connect(url, function(err, db) {
db.collection('artefacts').drop();
console.log("dropped");
// db.createCollection('allofthedata');
// Insert multiple documents
db.collection('artefacts').insertMany(seedArtefacts, function(err, r) {
assert.equal(null, err);
assert.equal(3, r.insertedCount);
db.close();
});
MongoClient.connect(url, function(err, db) {
// define here which parts of the data should be searchable. Currently limited to the below, should be discussed further.
db.collection("artefacts").createIndex( { title : "text", description : "text" }, function(err, result) {
});
db.close();
});
});
res.redirect("./");
});
}; |
// classes
class Artist{
constructor(name){ // constructor is a reserved keyword
this.name = name;
}
perform(){
console.log(`${this.name} is perfroming on stage tonight`);
}
}
const artist = new Artist('Madan');
console.log(artist);
artist.perform();
// Inheritance
class Dancer extends Artist{
constructor(name, style){
super(name);
this.style = style;
}
dance(){
console.log(`${this.name} does ${this.style}`);
}
}
const dancer = new Dancer('John Doe','Hip-Hop');
dancer.perform();
dancer.dance(); |
import React, { Component } from 'react';
import './Card3.css';
class Card3 extends Component {
render() {
return (
<div
className="cardBg"
style={{
height: 480,
}}
></div>
);
}
}
export default Card3;
|
angular.module('starter')
.factory('remoteStorage', ['$q','$http', function($q, $http) {
var localStorage = {};
return {
set: function(key, value) {
return $q(function (resolve, reject) {
resolve(localStorage[key] = JSON.stringify(value));
resolve();
});
},
get: function(key) {
console.log('ask for ', key);
return $q(function (resolve, reject) {
var val = localStorage[key];
if (val)
resolve(JSON.parse(val));
else
reject('key not found')
});
}
}
}]);
|
/**
* Created by Administrator on 2017/7/10 0010.
*/
const URLPATH1 = "http://192.168.10.228:8080/jad-saas-mgmt/api/";
const URLPATH="src/assets/js/api/";
// const URLPATH1="http://192.168.132.134:8080/jad-saas-mgmt/api/";
// const URLPATH1="http://127.0.0.1:8080/jad-saas-mgmt/api/";
// const URLPATH1="http://127.0.0.1:8080/jad-saas-mgmt/api/";
//const URLPATH1="http://127.0.0.1:8080/jad-saas-mgmt/api/";
//const URLPATH1 = "http://192.168.134.111:8080/jad-saas-mgmt/api/";
import 'babel-polyfill' //解决ie浏览器无内置promise对象
import Vue from 'vue';
import axios from 'axios';
import router from './../../router'
let querystring = require('querystring');
export default class ajax {
static get(api, params, callback) {
let token =JSON.parse(sessionStorage.getItem('Token'))?JSON.parse(sessionStorage.getItem('Token')):'';
let url = `${URLPATH1}${api}?token=${token}`;
for (var key in params) {
url +='&'+ key + '=' + params[key]
}
axios({
method: 'get',
url: url,
})
.then(function (response) {
if(response.data.stateCode.code=="200"){
callback(response.data)
}else{
return router.push('/404');
}
})
.then(function (error) {
if (error) {
console.log(error)
}
});
}
static delete(api, params, callback) {
let token =JSON.parse(sessionStorage.getItem('Token'))?JSON.parse(sessionStorage.getItem('Token')):'';
let url = `${URLPATH1}${api}?token=${token}`;
console.log(url);
for (var key in params) {
url +='&'+ key + '=' + params[key]
}
axios({
method: 'delete',
url: url,
})
.then(function (response) {
if(response.data.stateCode.code==0) return alert(response.data.stateCode.message);
callback(response.data)
})
.then(function (error) {
if (error) {
console.log(error)
}
});
}
static post(api,params , callback) {
let url = `${URLPATH1}${api}`;
let token =JSON.parse(sessionStorage.getItem('Token'))?JSON.parse(sessionStorage.getItem('Token')):'';
let params1=Object.assign(params,{token:token});
let temp = querystring.stringify(params1);
axios.post(url,temp,
{headers: {'Content-Type': 'application/x-www-form-urlencoded'}})
.then(function (response) {
callback(response)
})
.then(function (error) {
if (error) {
console.log(error)
}
});
}
}
|
export default {
newValue({
commit
}, {
value,
operation
}) {
if (operation == 'buy')
commit('set_new_minor_value', value)
else
commit('set_new_higher_value', value)
}
} |
export default function betterContrastColor(hex) {
let threshold = 130; // about 256/2 - lower values results into darker text on dark background
let colorBrightness =
(hexToRed(hex) * 299 + hexToGreen(hex) * 587 + hexToBlue(hex) * 114) / 1000;
function cleanHex(h) {
return h.charAt(0) == "#" ? h.substring(1, 7) : h;
}
function hexToRed(h) {
return parseInt(cleanHex(h).substring(0, 2), 16);
}
function hexToGreen(h) {
return parseInt(cleanHex(h).substring(2, 4), 16);
}
function hexToBlue(h) {
return parseInt(cleanHex(h).substring(4, 6), 16);
}
return colorBrightness > threshold ? "#000000" : "#ffffff";
}
|
// ParkMe
// spot.js
// Apoorva Sharma - September 2014
// Class to represent one parking spot. Holds the information of
//
var EventEmitter = require("events").EventEmitter;
var EventSource = require('eventsource');
// spot_id: Unique-in-lot id of this spot
// device_id: Spark core id
// device_sensor_index: int of which sensor on the spark is mapped to this spot
function Spot(spot_id, device_id, device_sensor_index) {
// Subclass EventEmitter
EventEmitter.call(this);
this.m_id = spot_id;
this.m_device_id = device_id;
var accessToken = "9b818456900c9cc9224fbf9fe6c29e92e2e90210";
// string of event to subscribe to
this.m_eventName = "sensor" + device_sensor_index.toString();
var url = "https://"
this.m_eventSource = new EventSource("https://api.spark.io/v1/devices/"
+ this.m_device_id + "/events/"
+ this.m_eventName
+ "?access_token="+accessToken );
var self = this;
this.m_eventSource.addEventListener(this.m_eventName, function(e) {
var eventData = JSON.parse(e.data);
var data = {"spot_id": self.m_id, "state": eventData.data};
self.emit("change", data);
});
}
Spot.prototype.__proto__ = EventEmitter.prototype;
module.exports.Spot = Spot;
|
/// <reference path="../libs/jquery-1.10.2.js" />
/// <reference path="../libs/jquery-ui-1.10.3.js" />
/// <reference path="guidemanager.js" />
/// <reference path="TranslationsJs.js" />
/// <reference path="ui.js" />
/// <reference path="tabmanager.js" />
/// <reference path="utils.js" />
/// <reference path="validation.js" />
|
import React from 'react';
import { makeStyles } from '@material-ui/core/styles';
import TextField from '@material-ui/core/TextField';
import Button from '@material-ui/core/Button';
const useStyles = makeStyles((theme) => ({
root: {
'& > *': {
marginBottom: theme.spacing(1),
width: '25ch',
display: "flex",
flexDirection: "column",
},
},
}));
export default function BasicTextFields() {
const classes = useStyles();
return (
<form className={classes.root} noValidate autoComplete="off">
<TextField id="outlined-basic" label="Ваше имя" variant="filled" />
<TextField id="outlined-basic" label="Ваш email" variant="filled" />
<TextField style={{ width: "80%", marginBottom: "20px" }}
id="filled-multiline-static"
label="Текст отзыва"
multiline
rows={4}
variant="filled"
/>
<Button variant="contained" color="primary" style={{ marginLeft: "0", width: "250px"}}>
Оставить отзыв
</Button>
</form>
);
}
|
import React from 'react';
function BigButton (props) {
return (
<svg width='100' height='50' onClick={props.onClick}>
<rect width='100' height='50' rx='25' ry='25' stroke='black' fill='black'/>
<rect x='2' y='2' width='96' height='46' rx='23' ry='23' stroke='black' fill='white'/>
<text x='50' y='30' style={{'textAnchor': 'middle', 'fontFamily': 'arial'}}>{props.text}</text>
</svg>
);
}
export default BigButton; |
let pokemonRepository = (function () {
let pokemonContainer = [];
let apiUrl = "https://pokeapi.co/api/v2/pokemon/?limit=150";
//adds pokemon name and type from apiUrl
function add(pokemon) {
if (typeof pokemon === "object" && "name" in pokemon && "type") {
pokemonContainer.push(pokemon);
} else {
console.log("pokemon is not correct");
}
}
function getAll() {
return pokemonContainer;
}
// functions for loading spinner when fetching data
let spinner = document.querySelector("#spinner");
function showLoadingSpinner() {
spinner.removeAttribute("hidden");
}
function hideLoadingSpinner() {
spinner.setAttribute("hidden", "");
}
//creates button to display pokemon name
function addListItem(pokemon) {
let pokemonContainer = $("#pokemon-container");
let pokemonList = $("<li />");
let button = $("<button />");
button.text(pokemon.name);
button.attr("data-target", "#pokemonModal");
button.attr("data-toggle", "modal");
button.addClass("btn");
button.addClass("btn-danger");
button.addClass("col");
pokemonList.addClass("col-12");
pokemonList.addClass("col-md-4");
pokemonList.addClass("list-group-item-light");
pokemonList.addClass("list-group-item");
pokemonList.append(button);
pokemonContainer.append(pokemonList);
button.on("click", function (event) {
showDetails(pokemon);
$(".modal-header").css("background-color", "rgb(0, 51, 204)");
});
}
//JSON promise function to fetch pokemon apiUrl
function loadList() {
return fetch(apiUrl)
.then(function (response) {
return response.json();
})
.then(function (data) {
data.results.forEach(function (item) {
let pokemon = {
name: item.name,
detailsUrl: item.url,
};
add(pokemon);
loadDetails(pokemon);
});
});
}
//function to load the details of pokemon with fetch
function loadDetails(item) {
let url = item.detailsUrl;
return fetch(url)
.then(function (response) {
return response.json();
})
.then(function (details) {
// Now we add the details to the item
item.imageUrl = details.sprites.other.dream_world.front_default;
item.name = details.name;
item.height = details.height;
item.weight = details.weight;
item.types = [];
details.types.forEach(function (pokemonTypes) {
item.types.push(pokemonTypes.type.name);
});
});
}
//shows pokemon details
function showDetails(pokemon) {
loadDetails(pokemon).then(function () {
//shows details when clicked on
showModal(pokemon);
});
}
// function for declaring a space and type to types: string
function typeLength(pokemon) {
return pokemon.types.length > 1
? "Type: " + pokemon.types.join(", ")
: "Type: " + pokemon.types;
}
//function showModal
function showModal(pokemon) {
const modalBody = $(".modal-body");
const modalTitle = $(".modal-title");
modalBody.empty();
modalTitle.empty();
//creating img in modal
const imagePokemonFront = $('<img class="modal-img" style="width:50%">');
imagePokemonFront.attr("src", pokemon.imageUrl);
let pokemonName = $("<h1>" + pokemon.name + "</h1>");
console.log(pokemon.name);
let pokemonTypes = $("<p>" + typeLength(pokemon) + "</p>");
let pokemonHeight = $("<p>" + "Height: " + pokemon.height + "m" + "</p>");
let pokemonWeight = $("<p>" + "Weight: " + pokemon.weight + "kg" + "</p>");
modalTitle.append(pokemonName);
modalBody.append(imagePokemonFront);
modalBody.append(pokemonTypes);
modalBody.append(pokemonHeight);
modalBody.append(pokemonWeight);
$("pokemonModal").modal("show");
}
return {
add: add,
getAll: getAll,
addListItem: addListItem,
loadList: loadList,
loadDetails: loadDetails,
showDetails: showDetails,
showModal: showModal,
};
})();
pokemonRepository.loadList().then(function () {
pokemonRepository.getAll().forEach(function (pokemon) {
pokemonRepository.addListItem(pokemon);
});
});
|
import React from 'react'
import { Link } from 'react-router-dom'
import './Header.scss'
const Header = () => {
return (
<header className="portfolio-header">
<Link
to={'/'}>
<h1>Lucas Vocos</h1>
</Link>
<Link
to='/contact'>
Info
</Link>
</header>
)
}
export default Header
|
app.filter('isMine', function() {
'use strict';
return function(input) {
switch (input) {
case false: return "img/false.png";
case true: return "img/true.png";
}
};
}); |
Scoped.define("module:VideoRecorder.Dynamics.Controlbar", [
"dynamics:Dynamic",
"module:Templates",
"module:Assets",
"base:Timers.Timer"
], [
"dynamics:Partials.ShowPartial",
"dynamics:Partials.RepeatPartial"
], function (Class, Templates, Assets, Timer, scoped) {
return Class.extend({scoped: scoped}, function (inherited) {
return {
template: Templates.video_recorder_controlbar,
attrs: {
"css": "ba-videorecorder",
"hovermessage": "",
"recordingindication": true,
"covershot_accept_string": "image/*,image/png,image/jpg,image/jpeg"
},
create: function () {
this.auto_destroy(new Timer({
context: this,
fire: function () {
this.set("recordingindication", !this.get("recordingindication"));
},
delay: 500
}));
},
functions: {
selectCamera: function (cameraId) {
this.trigger("select-camera", cameraId);
},
selectMicrophone: function (microphoneId) {
this.trigger("select-microphone", microphoneId);
},
hover: function (text) {
this.set("hovermessage", text);
},
unhover: function () {
this.set("hovermessage", "");
},
record: function () {
this.trigger("invoke-record");
},
rerecord: function () {
this.trigger("invoke-rerecord");
},
stop: function () {
this.trigger("invoke-stop");
},
skip: function () {
this.trigger("invoke-skip");
},
uploadCovershot: function (domEvent) {
this.trigger("upload-covershot", domEvent[0].target);
}
}
};
})
.register("ba-videorecorder-controlbar")
.attachStringTable(Assets.strings)
.addStrings({
"settings": "Settings",
"camerahealthy": "Lighting is good",
"cameraunhealthy": "Lighting is not optimal",
"microphonehealthy": "Sound is good",
"microphoneunhealthy": "Cannot pick up any sound",
"record": "Record",
"record-tooltip": "Click here to record.",
"rerecord": "Redo",
"rerecord-tooltip": "Click here to redo.",
"upload-covershot": "Upload",
"upload-covershot-tooltip": "Click here to upload custom cover shot",
"stop": "Stop",
"stop-tooltip": "Click here to stop.",
"skip": "Skip",
"skip-tooltip": "Click here to skip."
});
}); |
'use strict';
const sql = require('mssql');
var config = {
user: 'dboBI',
password: 'UserSQL',
server: '172.10.1.4',
database: 'DWH_BI'
};
sql.connect( config, function (err, result ) {
if (err){
return console.log(err);
}
new sql.Request().query('SELECT * FROM DIM_TIEMPO WHERE AÑO = 2018 AND MES = 1 AND DIA BETWEEN 1 AND 5', function (err, result) {
console.log(JSON.stringify(result.recordset.length + ' - ' + result.recordsets.length));
});
});
|
/**
* Created by wei.shen on 2015/12/6.
*/
metaApp.controller('DetailCtrl',function($scope,$resource,restfulService) {
$scope.tableId = parserUrl("mid");
var model = restfulService.model.query({tableId:$scope.tableId});
model.$promise.then(function(data) {
$scope.model = data.model;
},function(error) {
alert('error!')
});
var columns = restfulService.column.query({tableId:$scope.tableId});
columns.$promise.then(function(data) {
if(data.isSuccess) {
$scope.columns = data.results;
}
});
/**
* 提交基础列更新
*/
$scope.updateColumns = function() {
$bt = $('#colUpdateBtn');
$bt.button('loading');
var cols = $scope.columns;
restfulService.columnsComment.save(
{
tableId:$scope.tableId,
columnIds:getColIds(cols),
columnComments:getComs(cols)
},
function(data) {
if(data.isSuccess) {
$scope.col_edit=!$scope.col_edit;
$bt.button('reset');
}
},
function() {
alert("列信息更新失败");
$bt.button('reset');
}
)
}
/**
* 按顺序获取列注释数组
* @param cols
* @returns {Array}
*/
var getComs = function(cols) {
var coms = [];
for(var i = 0;i < cols.length;i ++) {
if(cols[i].columnComment === null) {
coms.push("");
} else {
coms.push(cols[i].columnComment);
}
}
return coms;
}
/**
* 按顺序获取列id数组
* @param cols
* @returns {Array}
*/
var getColIds = function(cols) {
var ids = [];
for(var i = 0;i < cols.length;i ++) {
ids.push(cols[i].columnId);
}
return ids;
}
/**
* 解析url获得指定参数parm信息
* */
function parserUrl(parm) {
var url = decodeURI(window.location.search); //获得请求的url
if (url.indexOf('?') == -1) {
return 'none';
} else {
var args = url.split("?");
var params = args[1];
var paramsArray = params.split("&");
for (var i = 0; i < paramsArray.length; i++) {
params = paramsArray[i];
var arg = params.split("=");
if (arg.length <= 1) {
} else if (arg[0] == parm) {
var param = arg[1];
return param;
}
}
}
return 'none';
}
})
|
console.log("Blog");
Ochs.pageType = "blog";
$("a[name='top']").css("display", "none !important"); |
myApp= angular.module('myApp',[]);
myApp.controller("MyConTroller",['$scope',function($scope){
$scope.name="Troy is here!!!! yay!!!";
}]); |
var myMap = L.map('myMap').setView([34.419201, -119.698634], 12);
L.tileLayer('http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
{
attribution: 'Map data © <a href="http://openstreetmap.org">OpenStreetMap</a> contributors, <a href="http://creativecommons.org/licenses/by-sa/2.0/">CC-BY-SA</a>, Imagery © <a href="http://mapbox.com">Mapbox</a>',
maxZoom: 18
}).addTo(myMap);
var coffeeMarker = L.marker ([34.422427, -119.698366]);
coffeeMarker.bindPopup('Handlebar Coffee Roasters');
coffeeMarker.addTo(myMap);
var myHome = L.marker ([34.415012, -119.702456]);
myHome.bindPopup('Our House');
myHome.addTo(myMap);
var dailyGrind = L.marker([34.437837, -119.727060]);
dailyGrind.bindPopup('The Daily Grind');
dailyGrind.addTo(myMap);
var iceCream = L.marker ([34.419491, -119.698774]);
iceCream.bindPopup("McConnel's Ice Cream");
iceCream.addTo(myMap);
var restaurant = L.marker([34.420420, -119.702533]);
restaurant.bindPopup('Finch & Fork');
restaurant.addTo(myMap);
var gym = L.marker([34.420460, -119.699802]);
gym.bindPopup('24 Hour Fitness');
gym.addTo(myMap);
var theater = L.marker([34.424597, -119.706475]);
theater.bindPopup('Arlington Theater');
theater.addTo(myMap);
var barber = L.marker([34.420802, -119.644996]);
barber.bindPopup("Richie's Barbershop");
barber.addTo(myMap);
|
import React, {Component} from 'react';
import {Jumbotron,Button,Media } from 'reactstrap';
export default class Content extends Component {
render() {
return(
<Jumbotron>
<h1 className="display-6">«ОНА»: как мы придумали образы искусственного интеллекта</h1>
<p className="lead">как интернет-конкурс фотографии вырос в полноценную оффлайн-выставку</p>
<hr className="my-2" />
<p className="text-muted">Почти у каждого современного человека сегодня в кармане смартфон, поэтому, если говорить про искусственный интеллект,
то чаще всего пользователи сталкиваются в своей частной жизни с голосовым помощником. Помимо выполнения основной функции,
помощи пользователям, условные Siri или Алиса научились шутить, петь, рассказывать сказки, анекдоты и даже спорить. В основном,
они говорят приятными женскими голосами. Так мы определись с образом, а позже, и с названием выставки.</p>
<Media left>
<Media object src="1.jpg" alt="Не поняла как подключить сюда картинку" />
</Media>
<br/>
<p className="lead">
<Button color="info">Learn More</Button>
</p>
</Jumbotron>
)
}
} |
import axios from 'axios'
const baseUrl = '/api/login'
const login = async credentials => {
try {
const response = await axios.post(baseUrl, credentials)
return response.data
}catch(error){
console.log(error)
}
}
// eslint-disable-next-line import/no-anonymous-default-export
export default {login} |
var replaceWords = function(dict, sentence) {
let h = {};
dict.forEach(word => {
h[word] = true;
})
let newS = sentence.split(" ").map(word => {
for (let i = 1; i <= word.length; i++) {
if (h[word.slice(0,i)]) {
return word.slice(0,i)
}
}
return word
})
return newS.join(" ")
};
console.log(replaceWords(['cat','bat','rat'], "the cattle was rattled by the battery")) |
import test from "ava";
import TemplateLayout from "../src/TemplateLayout";
test("Layout", t => {
t.is(
new TemplateLayout("default", "./test/stubs").getFileName(),
"default.ejs"
);
});
test("Layout already has extension", t => {
t.is(
new TemplateLayout("default.ejs", "./test/stubs").getFileName(),
"default.ejs"
);
});
test("Layout subdir", t => {
t.is(
new TemplateLayout(
"layouts/inasubdir",
"./test/stubs/_includes"
).getFileName(),
"layouts/inasubdir.njk"
);
});
test("Layout subdir already has extension", t => {
t.is(
new TemplateLayout(
"layouts/inasubdir.njk",
"./test/stubs/_includes"
).getFileName(),
"layouts/inasubdir.njk"
);
});
test("Multiple layouts exist with the same file base, pick one", t => {
// pick the first one if multiple exist.
t.is(
new TemplateLayout("multiple", "./test/stubs").getFileName(),
"multiple.ejs"
);
});
test("Multiple layouts exist but we are being explicit—layout already has extension", t => {
t.is(
new TemplateLayout("multiple.ejs", "./test/stubs").getFileName(),
"multiple.ejs"
);
t.is(
new TemplateLayout("multiple.md", "./test/stubs").getFileName(),
"multiple.md"
);
});
test("Layout is aliased to a new location", t => {
let tl = new TemplateLayout("post", "./test/stubs/_includes");
tl.addLayoutAlias("post", "layouts/post.ejs");
tl.init();
t.is(tl.getFileName(), "layouts/post.ejs");
});
test("Layout has no alias and does not exist", async t => {
let tl = new TemplateLayout("default", "./test/stubs/_includes");
tl.addLayoutAlias("post", "layouts/post.ejs");
tl.init();
t.throws(() => {
tl.getFileName();
});
t.throws(() => {
tl.getFullPath();
});
});
|
import { Modal, Button } from 'antd';
import { useState } from 'react';
import ColumnDiagram from './ColumnDiagram';
function ColumnHeader({ title, colKey }) {
const [isModalVisible, setIsModalVisible] = useState(false);
const showModal = () => {
setIsModalVisible(true);
};
const handleOk = () => {
setIsModalVisible(false);
};
const handleCancel = () => {
setIsModalVisible(false);
};
return (
<>
<Button type="link" onClick={showModal}>
{title}
</Button>
<Modal visible={isModalVisible} onOk={handleOk} onCancel={handleCancel}>
<ColumnDiagram columnLabel={colKey} />
</Modal>
</>
);
}
export default ColumnHeader;
|
/**
* @author Amazzing
* @copyright Amazzing
* @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)*
*/
$(document).ready(function(){
if ($('.gbwa_posts.home_carousel, .gbwa_posts.col_carousel').length > 0){
$('head').append('<script src="'+carousel_js+'"></script>');
$('head').append('<link rel="stylesheet" href="'+carousel_css+'">');
$('head').append('<link rel="stylesheet" href="'+carousel_theme_css+'">');
// home
$('.gbwa_posts.home_carousel').owlCarousel({
slideSpeed : 300,
paginationSpeed : 400,
items : 2,
itemsDesktop : [1199,2],
itemsDesktopSmall : [980,2],
itemsTablet: [768,1],
itemsMobile : [479,1],
});
// columns
$('.gbwa_posts.col_carousel').owlCarousel({
slideSpeed : 300,
paginationSpeed : 400,
singleItem:true
});
// normalize heights in carousel
var carouselHeights = [];
$('.gbwa_posts.owl-carousel .post_content').each(function(){
if ($(this).prop('scrollHeight') != $(this).prop('offsetHeight'))
$(this).closest('.post').addClass('expandable');
carouselHeights.push($(this).outerHeight());
if ($(this).closest('.owl-item').next().length < 1){
var h = Math.max.apply(Math,carouselHeights);
$(this).css('height', h+'px').closest('.owl-item').prevAll().find('.post_content').css('height', h+'px');
carouselHeights = [];
}
});
}
if ($('.gbwa_posts.home_grid, .gbwa_posts.grid').length > 0){
normalizeColumns($('.gbwa_posts.grid'));
}
$('.gbwa_posts').on('click', '.expand', function(){
var parent = $(this).closest('.post');
var origHeight = parent.find('.content_wrapper').outerHeight();
parent.toggleClass('expanded');
var newHeight = parent.find('.content_wrapper').outerHeight();
var topPos = parent.offset().top;
var expanded = parent.hasClass('expanded');
//normalize columns in same row
parent.nextAll().each(function(){
if ($(this).offset().top != topPos)
return false;
if (expanded)
$(this).find('.content_wrapper').css('margin-bottom', (newHeight-origHeight)+'px');
else
$(this).find('.content_wrapper').css('margin-bottom', '0');
});
parent.prevAll().each(function(){
if ($(this).offset().top != topPos)
return false;
if (expanded)
$(this).find('.content_wrapper').css('margin-bottom', (newHeight-origHeight)+'px');
else
$(this).find('.content_wrapper').css('margin-bottom', '0');
});
})
});
var processedBlocksNum = 0;
// var rowNum = 0;
function normalizeColumns(wrapper){
var topPostion = 0;
var rowItemsNum = 0;
var rowHeights = [];
elements = wrapper.find('.post_content').slice(processedBlocksNum);
// elements = wrapper.find('.post_content');
elements.each(function(){
if ($(this).prop('scrollHeight') != $(this).prop('offsetHeight'))
$(this).closest('.post').addClass('expandable');
if ($(this).closest('.post').position().top != topPostion){
var h = Math.max.apply(Math,rowHeights);
$(this).closest('.post').prevAll().slice(0, rowItemsNum).find('.post_content').css('height', h+'px');
// rowNum++;
// $(this).closest('.post').prevAll().slice(0, rowItemsNum).find('.post_content').css('height', h+'px').find('h4').html('row: '+rowNum+'; height: '+h+'; offset:'+$(this).closest('.post').position().top);
// if(rowItemsNum < 2)
// $(this).closest('.post').find('h4').before('<i>less_than_2</i>');
rowItemsNum = 1;
topPostion = $(this).closest('.post').position().top;
rowHeights = [$(this).outerHeight()];
}
else{
rowItemsNum++;
rowHeights.push($(this).outerHeight());
}
processedBlocksNum++;
// last item
if ($(this).closest('.post').next().length < 1){
var h = Math.max.apply(Math,rowHeights);
$(this).css('height', h+'px').closest('.post').prevAll().slice(0, rowItemsNum-1).find('.post_content').css('height', h+'px');
processedBlocksNum = processedBlocksNum - rowItemsNum;
rowItemsNum = 0;
}
});
} |
import Vue from "vue";
export default function create(Component, props) {
// const vm = new Vue({
// render(h) {
// return h(Component, {props});
// }
// }).$mount();
// document.body.appendChild(vm.$el);
// const comp = vm.$children[0];
// comp.remove = () => {
// document.body.removeChild(vm.$el);
// vm.$destroy();
// }
// return comp;
// 优化
const Ctor = Vue.extend(Component);
const comp = new Ctor({propsData: props});
comp.$mount();
document.body.appendChild(comp.$el);
comp.remove = () => {
document.body.removeChild(comp.$el);
comp.$destroy();
}
return comp;
} |
const express = require('express');
const server = express();
const bodyParser = require('body-parser');
server.use(bodyParser.urlencoded({ extended: true }));
server.get('/', (req, res) => {
res.status(200).json({ msg: 'OK' });
});
// client POST localhost/data x-www-form-urlencoded
// value=223
// see corresponding NodeMCU code: nodemcu_connect_server.ino
server.post('/data', (req, res) => {
console.log(req.body.value);
res.status(200).json({
body_value: req.body.value
});
});
// client GET localhost/data?value=334
server.get('/data', (req, res) => {
const value = req.query.value;
console.log(value);
res.status(200).json({
query_value: req.query.value
});
});
// client GET localhost/data/:value
// eg: GET localhost/data/335
// https://stackoverflow.com/questions/15128849/using-multiple-parameters-in-url-in-express
server.get('/data/:value/:value2', (req, res) => {
res.status(200).json({
params_value: req.params.value,
params_value2: req.params.value2
});
});
server.listen(3000, () => {
console.log('server started on port 3000');
});
|
new Vue({
el: '#app',
data: {
number: null,
max: 12,
results: [],
},
methods: {
times: function() {
this.results = [];
if (! this.number || this.number === "0") {
return;
}
for (var i = 1; i <= this.max; i++) {
this.results.push(
this.number + ' × ' + i + ' = ' + this.number * i
);
}
},
},
}); |
import { connect } from "react-redux";
import withStyles from "@material-ui/core/styles/withStyles";
import BlogComponent from "../../views/Blog/blog";
import { fetchBlogs, postBlogDetails, putBlogDetails, deleteBlog } from "../../actions/actions_vendor_blog";
import { postImage } from "../../actions/actions_imageupload";
const styles = {
cardCategoryWhite: {
"&,& a,& a:hover,& a:focus": {
color: "white",
margin: "0",
fontSize: "14px",
marginTop: "0",
marginBottom: "0"
},
"& a,& a:hover,& a:focus": {
color: "#FFFFFF"
}
},
cardTitleWhite: {
color: "#FFFFFF",
marginTop: "0px",
minHeight: "auto",
fontWeight: "300",
fontFamily: "'Roboto', 'Helvetica', 'Arial', sans-serif",
marginBottom: "3px",
textDecoration: "none",
"& small": {
color: "#777",
fontSize: "65%",
fontWeight: "400",
lineHeight: "1"
}
}
};
const mapStateToProps = state => ({
blog: state.vendorBlog
});
const mapStateToDispatch= (dispatch, newProps) => {
return {
fetchBlogs: () => {
dispatch(fetchBlogs());
},
postBlogDetails: (blogDetails) => {
dispatch(postBlogDetails(blogDetails));
},
putBlogDetails: (blogDetails, blogId) => {
dispatch(putBlogDetails(blogDetails, blogId))
},
deleteBlog: (blogId) => {
dispatch(deleteBlog(blogId));
},
postImage: (imageDetails, mediaId)=>{
dispatch(postImage(imageDetails, mediaId))
}
}
}
const Blog = connect(
mapStateToProps,
mapStateToDispatch
)(BlogComponent);
export default withStyles(styles)(Blog);
|
import 'regenerator-runtime/runtime';
import { createBrowserHistory } from 'history';
import { applyMiddleware, compose, createStore } from 'redux';
import { routerMiddleware } from 'connected-react-router';
import createSagaMiddleware from 'redux-saga';
import createRootReducer from './reducers';
import { persistStore, persistReducer } from 'redux-persist';
import autoMergeLevel2 from 'redux-persist/lib/stateReconciler/autoMergeLevel2';
import storage from 'redux-persist/lib/storage';
import rootSaga from './sagas';
const persistConfig = {
key: 'root',
storage,
stateReconciler: autoMergeLevel2, // see "Merge Process" section for details.
whitelist: ['auth'],
};
const sagaMiddleware = createSagaMiddleware();
const history = createBrowserHistory();
const pReducer = persistReducer(persistConfig, createRootReducer(history));
const store = createStore(
pReducer, // root reducer with router state
// initialState,
compose(
applyMiddleware(
routerMiddleware(history), // for dispatching history actions
sagaMiddleware,
),
window.__REDUX_DEVTOOLS_EXTENSION__ && window.__REDUX_DEVTOOLS_EXTENSION__()
)
);
const persistor = persistStore(store);
sagaMiddleware.run(rootSaga);
module.exports = {
store,
history,
persistor,
};
// export default store;
|
const { performance } = require('perf_hooks')
function addUpto(num) {
let sum = 0
for (let i = 1; i < num; i++) {
sum += i
}
return sum
}
const t1 = performance.now()
console.log(addUpto(100000000))
const t2 = performance.now()
console.log(`Time: __${t2 - t1}__`)
// HOW THE RUN TIME OF FUNCTION GROWS AS THE INPUT GROWS, THIS RELATION IS CALLED BIG O
// HERE THE NUMBER OF OPERATIONS INCREASE WITH THE SIZE OF INPUT O(n)
/**
* Rather than the time for measuring the performance,
* we can count consider the number of operations.
*
* With the increase of n, performance time increases in above code
**/
|
import React from 'react'
import ReactDom from 'react-dom'
import MainPanel from './components/main_panel'
import MDSpinner from "react-md-spinner";
let urlencode = require('urlencode');
let iconv = require('iconv-lite');
let axios = require('axios');
let api = require('./constants/api');
class Icon extends React.Component{
render(){
return(
<i className="wi wi-day-sunny" style={{color:'blue',fontSize:'100px'}}></i>
)
}
}
class App extends React.Component {
constructor(props) {
super(props);
this.state = {
city:"北京",
loading:true,
text:"handsomehua",
result:{
daily:Array(5).fill({
date:'',
week:'',
sunrise:'',
sunset:'',
day:{
weather:'',
temphigh:'',
winddirect:'',
windpower:'',
img:''
},
night:{
templow:''
}
})
},
data:"",
id:0
};
this.handleDate=this.handleDate.bind(this);
this.handleText=this.handleText.bind(this);
this.handleSubmit=this.handleSubmit.bind(this);
}
componentDidMount() {
new Promise((resolve, reject)=>{
axios.post('/iplookup')
.then((response)=>{
let result = JSON.stringify(response.data);
let cityinfo = result.split("\\t");
this.setState({city:cityinfo[5],loading:false});
resolve(this.state.city)
})
.catch((err)=>{
console.log(err);
reject(this.state.city)
});
})
.then((city)=>{
axios.get(api.path + api.querys + urlencode(city) + api.postfix,{
headers:{
'Authorization':'APPCODE ' + api.appcode
}
})
.then((response) => {
this.setState({result:response.data.result});
})
.catch((err) =>{
console.log(err)
})
}
)
}
handleDate(index){
this.setState({id:index});
}
handleText(event){
this.setState({text:event.target.value});
}
handleSubmit(){
this.setState({city:this.state.text,loading:true});
axios.get(api.path + api.querys + urlencode(this.state.city) + api.postfix,{
headers:{
'Authorization':'APPCODE ' + api.appcode
}
})
.then((response) => {
this.setState({result:response.data.result});
this.setState({loading:false});
})
.catch((err) =>{
console.log(err)
})
}
render()
{
const loadingstyle = {
textAlign: 'center',
lineHeight:'60px',
marginTop:'95px'
};
if(this.state.loading)
{
return(
<div style={loadingstyle}>
<MDSpinner size="75"/>
<br/>
<h1 style={{color:"#9BFD58"}}>Loading</h1>
</div>
)
}
else {
return (
<div>
<MainPanel city={this.state.city} id={this.state.id} result={this.state.result}
handleDate={this.handleDate} handleText={this.handleText} handleSubmit={this.handleSubmit}/>
</div>
)
}
}
}
ReactDom.render(
<App />,
document.getElementById('app')
);
|
import React from "react";
import {StyledHeaderUserName} from "../../../layout/header/user/StyledHeaderUserName";
class HeaderUserName extends React.Component {
render () {
return <StyledHeaderUserName>
Alessandro Gonzales
</StyledHeaderUserName>
}
}
export default HeaderUserName |
// Calculate median given an array and length of the array
module.exports = {
calculate: function(dataArray, len) {
var lowerIndex = Math.floor((len-1)/2);
var upperIndex = Math.ceil((len-1)/2);
var median;
if((len) % 2 != 0)
median = dataArray[lowerIndex];
else
median = (dataArray[lowerIndex] + dataArray[upperIndex])/2;
return median;
}
}; |
"use strict";
exports.themeReadyCallback = void 0;
var _callbacks = _interopRequireDefault(require("../core/utils/callbacks"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var themeReadyCallback = new _callbacks.default();
exports.themeReadyCallback = themeReadyCallback; |
const jwt = require('json-web-token');
const PosterModel = require('../MongoDB/PosterModel');
class PosterService {
constructor() {
}
async newPost(body) {
return {
"aa": "aaa"
};
}
}
module.exports = new PosterService();
|
const app = require('app');
const logger = require('services/logger');
const port = process.env.EXPRESS_PORT;
app.listen(port, () => {
logger.info('Server running on port: ' + port);
});
|
"use strict";
const serialize = obj => {
var str = []
for(let p in obj)
if (obj.hasOwnProperty(p) && obj[p]) {
str.push(encodeURIComponent(p) + '=' + encodeURIComponent(obj[p]))
}
return str.join('&')
}
const requiredObjParams = (obj, required) => {
return (req, res, next) =>{
// Check if obj present
if (!req.body[obj]) {
let err = new Error(`No ${obj} provided`)
err.status = 403
return next(err)
}
// Check if object has all required params
if (required && required.length) {
for (let arg of required) {
if (!req.body[obj][arg]) {
let err = new Error(`No ${obj}[${arg}] provided`)
err.status = 403
return next(err)
}
}
}
next()
}
}
const getIp = req =>{
return req.headers['x-forwarded-for'] || req.connection.remoteAddress;
}
const unique = arr => {
let a = arr.concat()
for(let i = 0; i < a.length; ++i) {
for(let j = i + 1; j < a.length; ++j) {
if(a[i] === a[j]) a.splice(j--, 1)
}
}
return a
}
const getObjectFields = object => Object.getOwnPropertyNames(object).sort()
const getUniqueFields = objects => {
let result = getObjectFields(objects[0])
objects.forEach(object => {
const fields = getObjectFields(object)
result = unique(result.concat(fields))
})
return result
}
const addDays = days => {
let date = new Date()
date.setDate(date.getDate() + days)
return date
}
const getDatesBeforeNow = days => {
let dates = []
for (let i = days; i >= 0; i--) {
dates.push(addDays(-i))
}
return dates
}
module.exports = {
getObjectFields,
getUniqueFields,
requiredObjParams,
unique,
serialize,
getIp,
addDays,
getDatesBeforeNow
}
|
var map;
var markers=[];
function initmap(){
map=new google.maps.Map(document.getElementById('map'),{
center: {lat: 40.7413549, lng: -73.9980244},
zoom:13,
styles:[{elementType: 'geometry', stylers: [{color: '#242f3e'}]},
{elementType: 'labels.text.stroke', stylers: [{color: '#242f3e'}]},
{elementType: 'labels.text.fill', stylers: [{color: '#746855'}]},
{
featureType: 'administrative.locality',
elementType: 'labels.text.fill',
stylers: [{color: '#d59563'}]
},
{
featureType: 'poi',
elementType: 'labels.text.fill',
stylers: [{color: '#d59563'}]
},
{
featureType: 'poi.park',
elementType: 'geometry',
stylers: [{color: '#263c3f'}]
},
{
featureType: 'poi.park',
elementType: 'labels.text.fill',
stylers: [{color: '#6b9a76'}]
},
{
featureType: 'road',
elementType: 'geometry',
stylers: [{color: '#38414e'}]
},
{
featureType: 'road',
elementType: 'geometry.stroke',
stylers: [{color: '#212a37'}]
},
{
featureType: 'road',
elementType: 'labels.text.fill',
stylers: [{color: '#9ca5b3'}]
},
{
featureType: 'road.highway',
elementType: 'geometry',
stylers: [{color: '#746855'}]
},
{
featureType: 'road.highway',
elementType: 'geometry.stroke',
stylers: [{color: '#1f2835'}]
},
{
featureType: 'road.highway',
elementType: 'labels.text.fill',
stylers: [{color: '#f3d19c'}]
},
{
featureType: 'transit',
elementType: 'geometry',
stylers: [{color: '#2f3948'}]
},
{
featureType: 'transit.station',
elementType: 'labels.text.fill',
stylers: [{color: '#d59563'}]
},
{
featureType: 'water',
elementType: 'geometry',
stylers: [{color: '#17263c'}]
},
{
featureType: 'water',
elementType: 'labels.text.fill',
stylers: [{color: '#515c6d'}]
},
{
featureType: 'water',
elementType: 'labels.text.stroke',
stylers: [{color: '#17263c'}]
}
],
mapTypeControl: false
});
var locations = [
{title: 'Park Ave Penthouse', location: {lat: 40.7713024, lng: -73.9632393}},
{title: 'Chelsea Loft', location: {lat: 40.7444883, lng: -73.9949465}},
{title: 'Union Square Open Floor Plan', location: {lat: 40.7347062, lng: -73.9895759}},
{title: 'East Village Hip Studio', location: {lat: 40.7281777, lng: -73.984377}},
{title: 'TriBeCa Artsy Bachelor Pad', location: {lat: 40.7195264, lng: -74.0089934}},
{title: 'Chinatown Homey Space', location: {lat: 40.7180628, lng: -73.9961237}}
];
var largeInfowindow= new google.maps.InfoWindow();
var bounds= new google.maps.LatLngBounds();
var defaulticon = 'http://maps.google.com/mapfiles/ms/icons/red-dot.png';
var hovericon ='http://maps.google.com/mapfiles/ms/icons/green-dot.png';
for (var i =0;i<locations.length;i++){
var position = locations[i].location;
var title= locations[i].title;
var marker = new google.maps.Marker({
map: map,
title: title,
position: position,
animation: google.maps.Animation.DROP,
icon: defaulticon
// icon: {
// path: google.maps.SymbolPath.FORWARD_CLOSED_ARROW,
// strokeColor: "red",
// scale: 3
// }
});
markers.push(marker);
bounds.extend (marker.position);
marker.addListener('click',function (){
populateInfoWindow(this, largeInfowindow);
});
marker.addListener('mouseover', function (){
this.setIcon(hovericon);
});
marker.addListener('mouseout',function (){
this.setIcon(defaulticon);
});
//map.fitBounds(bounds);
}
document.getElementById('zoom-to-area').addEventListener('click',function (){
zoomToArea();
});
document.getElementById('search-within-time').addEventListener('click', function (){
searchWithinTime();
});
function zoomToArea(){
var geocoder = new google.maps.Geocoder();
var address= document.getElementById('zoom-to-area-text').value;
console.log('Address='+address);
if (address==''){
window.alert('You must provide an address');
}
else{
geocoder.geocode(
{address:address,
componentRestrictions : {locality:'New York'}},
function (result, status){
if (status== google.maps.GeocoderStatus.OK){
formattedAddress=result[0].formatted_address;
var latitude=result[0].geometry.location.lat() ;
var longitude=result[0].geometry.location.lng();
var fa = document.getElementById('formattedAddress');
fa.innerHTML += `Formatted Address= ${formattedAddress}`;
var latlng= document.getElementById('latlng');
latlng.innerHTML +=`Latitude=${latitude} , Longitude=${longitude}`;
map.setCenter(result[0].geometry.location);
map.setZoom(15);
}else{
window.alert('Address not reachable');
}
}
);
}
};
function populateInfoWindow (marker, infoWindow){
if (infoWindow.marker!=marker)
{
infoWindow.marker=marker;
infoWindow.setContent('<div>'+marker.position+'</div>');
infoWindow.open (map, marker);
infoWindow.addListener('click',function (){
infoWindow.setMarker(null);
});
var streetViewService= new google.maps.StreetViewService();
var radius=50;
streetViewService.getPanaromaByLocation (marker.position, radius,getstreetview);
function getstreetview(){
var nearStreetViewLocation =data.location.latlng;
var heading = google.maps.geometry.spherical.computeHeading(nearStreetViewLocation,marker.position);
}
}
}
function searchWithinTime(){
var distanceMatrixService= new google.maps.DistanceMatrixService();
var address= document.getElementById('search-within-time-text').value;
if (address==''){
window.alert('Please enter an address');
}
else{
var origins=[];
for (var i=0;i<markers.length;i++){
origins[i]=markers[i].position ;
}
var destination =address;
var mode= document.getElementById('mode').value;
distanceMatrixService.getDistanceMatrix({
origins:origins,
destinations:[destination],
travelMode: google.maps.TravelMode[mode],
unitSystem: google.maps.UnitSystem.IMPERIAL,
}, function (response, status){
if(status!=google.maps.DistanceMatrixStatus.OK){
console.log(status);
window.alert('error was: '+status);
}else{
displayMarkersWithinTime(response);
}
});
}
};
function displayMarkersWithinTime(response){
var maxDuration = document.getElementById('max-duration').value;
var origin = response.originAddresses;
var destination= response.destinationAddresses;
var atleastOne=false;
for (var i=0;i<origin.length;i++){
var results= response.rows[i].elements;
for (var j=0;j<results.length;j++){
var element = results[j];
if (element.status==='OK'){
var distanceText = element.distance.text;
var duration = element.duration.value/60;
var durationText=element.duration.text;
if (duration <= maxDuration){
markers[i].setMap(map);
atleastOne=true;
var infowindow = new google.maps.InfoWindow({
content: durationText + ' away, ' + distanceText +
'<div><input type=\"button\" value=\"View Route\" onClick =' +
'\"displayDirections("' + origin[i] + '");\"></input></div>'
});
// document.getElementById('viewRoute').addEventListener('click',function (){
// displayDirections(origins[i]);
// })
infowindow.open(map,markers[i]);
markers[i].infowindow=infowindow;
google.maps.event.addListener(markers[i], 'click', function() {
this.infowindow.close();
});
}
}
}
} }
};
function displayDirections(origin){
var directionsService = new google.maps.DirectionsService();
var destinationAddress=document.getElementById('search-within-time-text').value;
var mode= document.getElementById('mode').value;
directionsService.route({
origin:origin,
destination:destinationAddress,
travelMode: google.maps.TravelMode[mode]
}, function (response, status){
if (status===google.maps.DirectionsStatus.OK)
{
var directionsDisplay= new google.maps.DirectionsRenderer({
map:map,
directions:response,
draggabble:true,
polylineOPtions: {strokeColor: 'green'
}
});
}else{
window.alert('direction request failed due to '+status);
}
});
};
initmap();
|
import Counter from './Counter'
import Todos from './Todos'
const Api = {
Counter,
Todos,
}
export {
Counter,
Todos,
}
export default Api
|
import UserApikey from "./UserApikey";
export {UserApikey}
export default UserApikey |
function activate(id, id_class_object)
{
sendData({
url:'modules/activateObject.php',
statbox:'status',
method:'POST',
data:
{
id_object: id,
id_class_object: id_class_object
},
success:function(data)
{
elem=document.getElementById('object'+id);
elem.parentNode.removeChild(elem);
document.getElementById('content').innerHTML = "Объект успешно активирован.";
document.getElementById('count_objects').innerHTML = document.getElementById('count_objects').innerHTML-1;
}
});
}
|
/*
* Copyright (C) 2021 Radix IoT LLC. All rights reserved.
*/
PageFactory.$inject = ['maJsonStore', 'MA_UI_PAGES_XID', 'maUtil', '$q', 'maDialogHelper', 'maUser'];
function PageFactory(JsonStore, MA_UI_PAGES_XID, Util, $q, maDialogHelper, maUser) {
class Page {
getPages() {
return JsonStore.get({
xid: MA_UI_PAGES_XID
}).$promise;
}
loadPage(xid) {
return JsonStore.get({
xid: xid
}).$promise.then(null, error => {
const user = maUser.current;
// the whole purpose of this section is to remove missing pages from the list of pages
if (error.status === 404 && user) {
this.getPages().then(pagesStore => {
if (user.hasPermission(pagesStore.editPermission)) {
const pages = pagesStore.jsonData.pages;
let pageRemovedFromList = false;
for (let i = 0; i < pages.length;) {
if (pages[i].xid === xid) {
pages.splice(i, 1);
pageRemovedFromList = true;
continue;
}
i++;
}
if (pageRemovedFromList) {
pagesStore.$save();
}
}
});
}
maDialogHelper.errorToast(['ui.app.errorGettingPage', error.mangoStatusText]);
return $q.reject(error);
});
}
newPageContent() {
const storeObject = new JsonStore();
storeObject.xid = Util.uuid();
storeObject.jsonData = {
markup: ''
};
storeObject.editPermission = [];
storeObject.readPermission = [];
return storeObject;
}
}
return new Page();
}
export default PageFactory;
|
function index(req, res){
res.json(
{
message: "Available Endpoints for Asset Management Tool - updated 30Jul2019",
documentation_url: "https://github.com/rccacho/asset_management_tool",
base_url: "localhost:3000",
endpoints: [
{
method: "GET",
path: "/api",
description: "describes available endpoints"
}
]
}
);
};
module.exports = {
index: index
}
|
ricoApp.controller('CustomerSearchControll', function($scope, $uibModal, PeristentFactory,IndexedDb){
$scope.search={customerOrNo:""};
$scope.customersShortList=[];
$scope.searchCompany=function(){
if($scope.search.customerOrNo.length>=0){
$scope.customersShortList=[];
PeristentFactory.search($scope.search.customerOrNo).then(
function(data){
if(data == undefined){
}else if (data.length > 1){
for(var i=0;i<data.length;i++){
$scope.customersShortList.push(data[i]);
};
}else if (data.length == 1){
var customer=data[0];
IndexedDb.saveCustomer(customer).then(function(value) {
$scope.$parent.$broadcast('readCustomerCache');
openCustomerData($scope,$uibModal, customer);
}, function(reason) {
alert(reason);
});
}else{alert("keine Daten")};
},function(reason){
alert(reason);
});
};
};
$scope.loadCompanyFromDb=function(customer){
IndexedDb.saveCustomer(customer).then(
function(e) {
$scope.$parent.$broadcast('readCustomerCache');
openCustomerData($scope,$uibModal, customer);
}, function(reason) {
alert(reason);
});
};
});
|
//
const localStorage = window.localStorage
export function getStorageByKey(key) {
return localStorage.getItem(key)
}
export function setStorageByKey(key, data) {
return localStorage.setItem(key, data)
}
|
const express = require('express');
const router = express.Router();
const {register,login,getUser,logout,imageUpload,forgotPassword,resetPassword,editDetails} = require('../contorllers/auth');
const {getAccessToRoute} = require('../middlewares/authorization/auth');
const profileİmage = require('../middlewares/libraries/profileİmageUpload')
router.post('/register',register);
router.post('/login',login);
router.get('/logout',getAccessToRoute,logout);
router.get('/profile',getAccessToRoute,getUser);
router.post("/forgotPassword",forgotPassword);
router.put("/resetpassword",resetPassword);
router.put("/edit",getAccessToRoute,editDetails);
router.post("/upload",[getAccessToRoute,profileİmage.single("profile_image")],imageUpload)
module.exports = router; |
import React from "react";
import Page from "../components/layouts/main";
import Head from "next/head";
export default () => (
<Page
activePath="contact"
title="Contact"
description="Een afspraak maken bij kinesitherapeut Kevin Bal te Kontich kan telefonisch of online"
>
<Head>
<link rel="canonical" href="http://kinebal.be/contact/" />
</Head>
<section className="container m-auto flex flex-col py-10 max-w-xl text-center px-6">
<label
htmlFor="tagline"
className="uppercase tracking-wide text-grey-dark font-bold"
>
Een afpsraak maken?
</label>
<h1 className="my-4 font-normal">Dat kan telefonisch of online.</h1>
<hr className="border-b w-8 m-auto my-6" />
<p className="text-justify text-lg leading-normal mb-4 text-grey-darkest mt-1 lg:mt-4 max-w-lg m-auto">
Indien de afspraakmogelijkheden die online worden aangeboden naar uw
gevoel te ver in de toekomst liggen en u liever sneller behandeld wordt,
kan u mij steeds telefonisch contacteren. We trachten dan in wederzijds
overleg zo spoedig als mogelijk een behandelmoment in te plannen.
</p>
</section>
<div className="font-sans text-center py-12 px-4 lg:px-0 bg-kevin-green">
<div className="container flex flex-col md:flex-row bg-white max-w-xl m-auto shadow-md md:p-10">
<div className="container m-auto flex flex-col py-2 max-w-xl text-center px-6">
<div className="w-full w-1/2 flex flex-row justify-between md:justify-center items-center md:p-2 md:p-8 items-center md:items-start">
<div className="flex items-center border-r p-4 w-1/2">
<div>
<h2 className="text-kevin-green pb-2 font-medium">
Telefonisch
</h2>
<p className="text-grey-darkest text-lg leading-normal">
Op het nummer{" "}
<a
href="tel:0468473190"
className="no-underine text-kevin-green"
title="0468 47 31 90"
>
0468 47 31 90
</a>
</p>
</div>
</div>
<div className="flex items-center p-4 w-1/2 ">
<div>
<h2 className="text-kevin-green pb-2 font-medium">Online</h2>
<p className="text-grey-darkest text-lg leading-normal pb-4">
<b>Let op:</b> duid de juiste locatie aan (Kevin Bal Kontich).
</p>
<div>
<a
href="http://www.q-top.be/Online-planner/NL/?root=kq35040"
target="_blank"
title="Een online afspraak maken bij Kevin Bal"
className="inline-block no-underline bg-kevin-green border border-transparent shadow font-semibold py-3 px-5 text-white hover:bg-transparent hover:text-kevin-green hover:border-kevin-green"
>
Online afspraak maken
</a>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</Page>
);
|
/**
* @param {} options
*/
module.exports = (function(Tsunaruts) {
return Tsunaruts.Model.extend({
schema : {
uuid : { type : String, index: true },
region : { type : String, index: true },
mstUserId : { type : String, index: true },
name : String,
accountId : String,
state: String,
sourceChannel: {
uuid: String,
name: String,
code: String,
description: String },
accountType: {
id: String,
name: String,
displayName: String,
description: String },
spendLimit: Number,
initialDeposit: Number,
spendBudget: Number,
owner: {
firstName: String,
lastName: String,
username: String,
uuid: String },
address: {
city: String,
country: String,
postalCode: String,
state: String },
secondaryAddress: String,
currency: {
currencyCode: String,
currencyName: String,
memo: String,
trialAccount: String,
tenantExtraInformation: String,
deposit: String,
remoteAddress: String,
removed: String,
removedBy: String,
imagePath: String,
faviconPath: String,
usernameSuffix: String,
users: [ { firstName: String,
lastName: String,
username: String,
uuid: String },
{ firstName: String,
lastName: String,
username: String,
uuid: String },
{ firstName: String,
lastName: String,
username: String,
uuid: String }
]
}
}
});
});
|
import React, { useState, useEffect } from "react";
import Button from "../styledComponents/Button";
import styled from "styled-components";
const BtnContainer = styled.div`
display: flex;
flex-direction: row;
justify-content: space-around;
align-items: center;
width: 90%;
margin: auto;
gap: 30px;
`;
const TimeContainer = styled.div`
display: grid;
grid-template-columns: 1fr 1fr 1fr 1fr;
justify-content: space-around;
align-items: center;
width: 90%;
margin: auto;
gap: 30px;
`;
const Timer = () => {
const [miliseconds, setMiliseconds] = useState(0);
const [seconds, setSeconds] = useState(0);
const [mins, setMins] = useState(0);
const [hrs, setHrs] = useState(0);
const [isActive, setIsActive] = useState(false);
function toggle() {
setIsActive(!isActive);
}
function reset() {
setSeconds(0);
setMiliseconds(0);
setMins(0);
setHrs(0);
setIsActive(false);
}
useEffect(() => {
let interval = null;
if (isActive) {
// console.log("running");
interval = setInterval(() => {
setMiliseconds((miliseconds) => miliseconds + 1);
if (miliseconds === 99) {
clearInterval(interval);
setMiliseconds(0);
setSeconds((seconds) => seconds + 1);
}
if (seconds === 60) {
clearInterval(interval);
setMiliseconds(0);
setSeconds(0);
setMins((mins) => mins + 1);
}
if (mins === 60) {
clearInterval(interval);
setMiliseconds(0);
setSeconds(0);
setMins(0);
setHrs((hrs) => hrs + 1);
}
}, 10);
} else if (!isActive) {
clearInterval(interval);
// console.log(seconds, hrs, mins, miliseconds);
// console.log("stopped");
}
return () => clearInterval(interval);
}, [isActive, seconds, miliseconds, mins, hrs]);
return (
<div>
<h1>Hi, I'm Stopwatch!</h1>
<TimeContainer>
<h1>{hrs < 10 ? `0${hrs}` : hrs} hr</h1>
<h1>{mins < 10 ? `0${mins}` : mins} mins</h1>
<h1>{seconds < 10 ? `0${seconds}` : seconds} s</h1>
<h1>{miliseconds < 10 ? `0${miliseconds}` : miliseconds} ms</h1>
</TimeContainer>
<BtnContainer>
<Button label={isActive ? "Stop" : "Start"} onClick={toggle} />
<Button label="Reset" onClick={reset} />
</BtnContainer>
</div>
);
};
export default Timer;
|
/**
* Plugin wrapper.
* @param {Object} config_opts configuration options
* @constructor
*/
annotorious.plugin.PolygonSelector = function(config_opts) {
if (config_opts)
this._activate = config_opts.activate;
}
/**
* Attach a new selector onInitAnnotator.
*/
annotorious.plugin.PolygonSelector.prototype.onInitAnnotator = function(annotator) {
annotator.addSelector(new annotorious.plugin.PolygonSelector.Selector());
if (this._activate)
annotator.setCurrentSelector('polygon');
}
/**
* A polygon selector.
* @constructor
*/
annotorious.plugin.PolygonSelector.Selector = function() { }
annotorious.plugin.PolygonSelector.Selector.prototype.init = function(annotator, canvas) {
/** @private **/
this._annotator = annotator;
/** @private **/
this._canvas = canvas;
/** @private **/
this._g2d = canvas.getContext('2d');
/** @private **/
this._anchor;
/** @private **/
this._points = [];
/** @private **/
this._mouse;
/** @private **/
this._enabled = false;
/** @private **/
this._mouseMoveListener;
/** @private **/
this._mouseUpListener;
}
/**
* Attaches MOUSEUP and MOUSEMOVE listeners to the editing canvas.
* @private
*/
annotorious.plugin.PolygonSelector.Selector.prototype._attachListeners = function() {
var self = this;
var refresh = function(last, highlight_last) {
self._g2d.clearRect(0, 0, self._canvas.width, self._canvas.height);
// Outer line
self._g2d.lineWidth = 2.5;
self._g2d.strokeStyle = '#000000';
self._g2d.beginPath();
self._g2d.moveTo(self._anchor.x, self._anchor.y);
// TODO replace with goog.array.forEach
for (var i=0; i<self._points.length; i++) {
self._g2d.lineTo(self._points[i].x, self._points[i].y);
};
self._g2d.lineTo(last.x, last.y);
self._g2d.stroke();
/* Outer line
g2d.lineWidth = 1.4;
g2d.strokeStyle = '#000000';
var outline = annotorious.shape.expand(shape, 1).points;
g2d.beginPath();
g2d.moveTo(outline[0].x, outline[0].y);
for (var i=1; i<outline.length; i++) {
g2d.lineTo(outline[i].x, outline[i].y);
}
g2d.lineTo(outline[0].x, outline[0].y);
g2d.stroke();
*/
// Inner line
self._g2d.lineWidth = 1.4;
self._g2d.strokeStyle = '#ffffff';
self._g2d.beginPath();
self._g2d.moveTo(self._anchor.x, self._anchor.y);
// TODO replace with goog.array.forEach
for (var i=0; i<self._points.length; i++) {
self._g2d.lineTo(self._points[i].x, self._points[i].y);
};
self._g2d.lineTo(last.x, last.y);
self._g2d.stroke();
// Last coord highlight (if needed)
if (highlight_last) {
self._g2d.lineWidth = 1.0;
self._g2d.fillStyle = '#ffffff';
self._g2d.strokeStyle = '#000000';
self._g2d.beginPath();
self._g2d.arc(last.x, last.y, 3.5, 0, 2 * Math.PI, false);
self._g2d.fill();
self._g2d.stroke();
}
};
var isClosable = function(x, y) {
return (self._points.length > 1 && Math.abs(x - self._anchor.x) < 5 && Math.abs(y - self._anchor.y) < 5);
};
this._mouseMoveListener = function(event) {
if (self._enabled) {
if (event.offsetX == undefined) {
event.offsetX = event.layerX;
event.offsetY = event.layerY;
}
self._mouse = { x: event.offsetX, y: event.offsetY };
refresh(self._mouse, isClosable(event.offsetX, event.offsetY));
}
};
this._canvas.addEventListener('mousemove', this._mouseMoveListener);
this._mouseUpListener = function(event) {
if (event.offsetX == undefined) {
event.offsetX = event.layerX;
event.offsetY = event.layerY;
}
if (isClosable(event.offsetX, event.offsetY)) {
self._enabled = false;
refresh(self._anchor);
self._annotator.fireEvent('onSelectionCompleted',
{ mouseEvent: event, shape: self.getShape(), viewportBounds: self.getViewportBounds() });
} else {
self._points.push({ x: event.offsetX, y: event.offsetY });
}
};
this._canvas.addEventListener('mouseup', this._mouseUpListener);
}
/**
* Detaches MOUSEUP and MOUSEMOVE listeners from the editing canvas.
* @private
*/
annotorious.plugin.PolygonSelector.Selector.prototype._detachListeners = function() {
var self = this;
if (this._mouseMoveListener) {
this._canvas.removeEventListener("mousemove", self._mouseMoveListener);
}
if (this._mouseUpListener) {
this._canvas.removeEventListener("mouseup", self._mouseUpListener);
}
}
/**
* Selector API method: returns the selector name.
* @returns the selector name
*/
annotorious.plugin.PolygonSelector.Selector.prototype.getName = function() {
return 'polygon';
}
/**
* Selector API method: returns the supported shape type.
*
* TODO support for multiple shape types?
*
* @return the supported shape type
*/
annotorious.plugin.PolygonSelector.Selector.prototype.getSupportedShapeType = function() {
return 'polygon';
}
/**
* Selector API method: starts the selection at the specified coordinates.
* @param {number} x the X coordinate
* @param {number} y the Y coordinate
*/
annotorious.plugin.PolygonSelector.Selector.prototype.startSelection = function(x, y) {
this._enabled = true;
this._attachListeners();
this._anchor = { x: x, y: y };
this._annotator.fireEvent('onSelectionStarted', { offsetX: x, offsetY: y });
// goog.style.setStyle(document.body, '-webkit-user-select', 'none');
}
/**
* Selector API method: stops the selection.
*/
annotorious.plugin.PolygonSelector.Selector.prototype.stopSelection = function() {
this._points = [];
this._detachListeners();
this._g2d.clearRect(0, 0, this._canvas.width, this._canvas.height);
// goog.style.setStyle(document.body, '-webkit-user-select', 'auto');
}
/**
* Selector API method: returns the currently edited shape.
* @returns {annotorious.shape.Shape} the shape
*/
annotorious.plugin.PolygonSelector.Selector.prototype.getShape = function() {
var points = [];
points.push(this._annotator.toItemCoordinates(this._anchor));
var self = this;
// goog.array.forEach(this._points, function(pt) {
for (var i=0; i<this._points.length; i++) {
points.push(self._annotator.toItemCoordinates(this._points[i]));
}
return { type: 'polygon', geometry: { points: points } };
}
/**
* Selector API method: returns the bounds of the selected shape, in viewport (= pixel) coordinates.
* @returns {object} the shape viewport bounds
*/
annotorious.plugin.PolygonSelector.Selector.prototype.getViewportBounds = function() {
var right = this._anchor.x;
var left = this._anchor.x;
var top = this._anchor.y;
var bottom = this._anchor.y;
// TODO replace with goog.array.forEach
for (var i=0; i<this._points.length; i++) {
var pt = this._points[i];
if (pt.x > right)
right = pt.x;
if (pt.x < left)
left = pt.x;
if (pt.y > bottom)
bottom = pt.y;
if (pt.y < top)
top = pt.y;
};
return { top: top, right: right, bottom: bottom, left: left };
}
/**
* TODO not sure if this is really the best way/architecture to handle viewer shape drawing
*/
var i = 100;
annotorious.plugin.PolygonSelector.Selector.prototype.drawShape = function(g2d, shape, highlight) {
var color;
if (highlight) {
color = '#fff000';
} else {
color = '#ffffff';
}
// TODO check if it's really a polyogn
// Outer line
g2d.lineWidth = 1.3;
g2d.strokeStyle = '#000000';
g2d.beginPath();
g2d.moveTo(0 + i, 0 + i);
g2d.lineTo(500,1500);
g2d.stroke();
// Inner line
g2d.lineWidth = 1.2;
g2d.strokeStyle = color;
g2d.beginPath();
g2d.moveTo(200,300);
g2d.lineTo(1200, 1200);
g2d.stroke();
i = i + 20;
}
|
import React from 'react';
import { Redirect } from 'react-router-dom';
import { Grid, Row, Col, Button } from 'react-bootstrap';
import { PageWrapper } from '../../constants/constants';
import PrimaryMenu from '../menus/PrimaryMenu';
export default class HomePage extends React.Component {
render = () => {
if (localStorage.getItem('start-page')) {
return (
<PageWrapper>
<PrimaryMenu />
<Grid className="post-list">
Home page with information about etc.
There is an option to choose some settings.
TODO: add API status of settings and add to condition
</Grid>
</PageWrapper>
);
}
return (
<Redirect to="/post" />
);
}
}
|
import React, { Component } from 'react'
import {BrowserRouter, Route, Switch} from 'react-router-dom'
import {connect} from 'react-redux'
import {keepLogin} from '../actions'
import HomePage from './HomePage'
import Register from './Register'
import Login from './Login'
import Welcome from './Welcome'
import Header from './Header'
import Event from './CreateEvent'
import Profile from './Profile'
import Dashboard from './Dashboard'
import inputArchiving from './archiving/inputArchiving'
import RecapSurat from './archiving/recapSurat'
import RecapProposal from './archiving/recapProposal'
import RecapMou from './archiving/recapMou'
import RecapNotulensi from './archiving/recapNotulensi'
import InputFinance from './finance/inputFinance'
import RecapCashFlow from './finance/recapCashflow'
import RecapRab from './finance/recapRAB'
import Timeline from './timeline/timeline'
export class Apps extends Component {
componentDidMount(){
let userData = JSON.parse(localStorage.getItem('userData'))
if(userData){
this.props.keepLogin(userData)
}
}
render() {
return (
<div>
<BrowserRouter>
<Header/>
<Switch>
<Route path="/" exact component={HomePage}/>
<Route path="/login" component={Login}/>
<Route path="/register" component={Register}/>
<Route path="/welcome_page" component={Welcome}/>
<Route path="/create_event" component={Event}/>
<Route path="/Profile" component={Profile}/>
<Route path="/dashboard" component={Dashboard}/>
<Route path="/input_archiving" component={inputArchiving}/>
<Route path="/recap_surat" component={RecapSurat}/>
<Route path="/recap_proposal" component={RecapProposal}/>
<Route path="/recap_mou" component={RecapMou}/>
<Route path="/recap_notulensi" component={RecapNotulensi}/>
<Route path="/input_finance" component={InputFinance}/>
<Route path="/recap_cashflow" component={RecapCashFlow}/>
<Route path="/recap_rab" component={RecapRab}/>
<Route path="/timeline" component={Timeline}/>
</Switch>
</BrowserRouter>
</div>
)
}
}
export default connect(null, {keepLogin})(Apps)
|
import React from 'react'
import R from 'ramda'
import autobind from 'autobind-decorator'
import type { HandleSubmitType, DispatchType, UserType } from 'flow/types'
import { Field, reduxForm } from 'redux-form'
import validator, { required, passwordLength } from 'src/lib/validator'
import { connectWithRequests } from 'mystand-redux-requests'
import logo from 'assets/logo.svg'
import spin from 'components/shared/button/spinner.svg'
import { signUp } from 'actions/userActions'
import Button from 'components/shared/button/Button'
import { InputFormWrapper } from 'components/shared/form/input/Input'
import userIcon from './user.svg'
import infoIcon from './info.svg'
import styles from './sign-up.styl'
type PropsType = {
handleSubmit: HandleSubmitType,
dispatch: DispatchType,
currentUser?: UserType
}
type StateType = {
status?: string
}
@autobind
class SignUpPage extends React.Component {
props: PropsType
state: StateType
constructor(props: PropsType) {
super(props)
this.state = { status: '' }
}
componentDidMount() { this._mounted = true }
componentWillUnmount() { this._mounted = false }
onBeginProcessing() {
if (this._mounted) this.setState({ status: 'processing' })
}
onEndProcessing() { if (this._mounted) this.setState({ status: '' }) }
render() {
const { handleSubmit, dispatch, currentUser } = this.props
const onSubmit = handleSubmit((values) => {
console.log(currentUser)
if (currentUser && currentUser.email) {
dispatch(signUp({ onEnd: this.onEndProcessing,
onBegin: this.onBeginProcessing, email: currentUser.email, ...values }))
}
})
const disabled = this.state.status == 'processing'
return(
<div className={styles.root}>
<div>
<img className={styles.logo} src={logo}/>
<a className={styles.signinButton} href="/login">sign in</a>
</div>
<div className={styles.content}>
<div className={styles.bigTitle}>Take action</div>
<div className={styles.smallTitle}>You're on your way to making impact!</div>
<div className={styles.formContainer}>
<form onSubmit={onSubmit}>
<input type='hidden' name='name' value='idk'/>
<input type='hidden' name='password' value='idk'/>
<Field
name="name"
className={styles.formInput}
placeholder="Full name"
component={InputFormWrapper}
/>
<div className={styles.inputHint}>
<img src={userIcon} className={styles.iconHint}/>
{'Will show publicly but you can choose to hide later'}
</div>
<Field
name="password"
className={styles.formInput}
placeholder="Password"
component={InputFormWrapper}
type="password"
/>
<div className={styles.inputHint}>
<img src={infoIcon} className={styles.iconHint}/>
{'Password must be greater than 6 characters'}
</div>
<Button submit icon={disabled ? spin : null} className={styles.signupButton}>FINISH</Button>
</form>
</div>
</div>
</div>
)
}
}
const validate = validator({
password: [required('Password is required'), passwordLength('Passwords must be at least 6 characters in length')]
})
export default R.compose(
reduxForm({
form: 'signup',
validate
}),
connectWithRequests([{
key: 'signup',
cacheKey: () => null
}], state => ({ currentUser: state.currentUser }))
)(SignUpPage)
|
import React, { Component } from 'react';
import Table from './components/Table';
import Toolbar from './components/Toolbar';
import Icon from './components/Icon';
import data from './model';
class App extends Component {
constructor(props) {
super(props);
this.updateTableState = this.updateTableState.bind(this);
this.resetAll = this.resetAll.bind(this);
this.saveCounter = this.saveCounter.bind(this);
this.errorCounter = this.errorCounter.bind(this);
this.state = {
tableStatus: 'sync',
storedData: data,
opportunities: data,
saveCount: 0,
errorCount: 0
}
}
updateTableState(changeCounter, errorCounter) {
if(errorCounter > 0) {
return this.setState({ tableStatus: 'error' });
}
if(changeCounter > 0) {
return this.setState({ tableStatus: 'save' });
}
return this.setState({ tableStatus: 'sync'})
}
saveCounter(value) {
let newCount = this.state.saveCount + value;
this.setState({ saveCount: newCount});
return this.updateTableState(newCount, this.state.errorCount);
}
errorCounter(value) {
let newCount = this.state.errorCount + value;
this.setState({ errorCount: newCount});
return this.updateTableState(this.state.saveCount, newCount)
}
resetAll() {
console.log('text')
return this.setState({
opportunities: this.state.storedData,
errorCount: 0,
saveCount: 0
});
}
render() {
return (
<div className="app">
<Toolbar tableStatus={this.state.tableStatus} resetAll={this.resetAll} />
<div className="listview-container slds-table_edit_container slds-is-relative">
<h2>My Opportunities in FY20</h2>
<span className="slds-badge">
<span className="slds-badge__icon slds-badge__icon_left">
<span className="slds-icon_container slds-current-color quip-icon" title="Description of icon when needed">
<Icon object="new_opportunity" type="action" size="x-small" />
</span>
</span>Opportunity
</span>
<Table updateTableState={this.updateTableState} storedData={this.state.storedData} opportunities={this.state.opportunities} saveCounter={this.saveCounter} errorCounter={this.errorCounter}/>
</div>
</div>
);
}
}
export default App;
|
class PubSubHandler {
constructor (){
this.eventPool = new Map()
}
off (name){
this.eventPool.delete(name)
}
trigger (name, ...args){
this.eventPool.get(name) &&
this.eventPool.get(name).forEach(callback => callback(...args));
}
on (name, callback){
let topic = this.eventPool.get(name)
if(!topic){
this.eventPool.set(name) = []
}
this.eventPool[name].push(callback)
}
} |
const VSHADER_SOURCE = `
uniform float u_time;
void main() {
gl_Position = vec4(fract(sin(u_time)), 0.0, 0.0, 1.0);
gl_PointSize = 10.0;
}
`;
const FSHADER_SOURCE = `
void main() {
gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0);
}
`
function main() {
const canvas = document.querySelector("#canvas");
const gl = getWebGLContext(canvas);
const initFlag = initShaders(gl, VSHADER_SOURCE, FSHADER_SOURCE);
run(gl);
}
/**
* @param {WebGLRenderingContext} gl
*/
function run(gl) {
gl.clearColor(0.0, 0.0, 0.0, 1.0);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.drawArrays(gl.POINTS, 0, 10);
} |
import React from "react";
import TextInput from "../../forms/inputs/text";
import TextareaInput from "../../forms/inputs/textarea";
import RadioInput from "../../forms/inputs/radio";
import CheckboxInput from "../../forms/inputs/checkbox";
//import SelectInput from "../../forms/inputs/select";
class Options extends React.Component {
render() {
let html;
let selectHtml;
let items = this.props.options;
console.log(items);
if (!items) return <div></div>;
if (!items.length) return <div></div>;
html = items.map((option, k) => {
return option.input_type === "radio" ? (
<RadioInput key={k} option={option} />
) : (
""
);
});
//check other input types if nothing has a match yet
let htmlVal = Object.keys(html[0]);
/* if (htmlVal.length === 0) {
selectHtml = items.map((option, k) => {
return option.input_type === "select" ? (
<SelectInput key={k} option={option} value={this.props.value}/>
) : (
""
);
});
html = selectHtml;
} */
htmlVal = Object.keys(html[0]);
if (htmlVal.length === 0) {
html = items.map((option, k) => {
return option.input_type === "checkbox" ? (
<CheckboxInput key={k} option={option} option-id={option.id}/>
) : (
""
);
});
}
htmlVal = Object.keys(html[0]);
if (htmlVal.length === 0) {
html = items.map((option, k) => {
return option.input_type === "text" ? (
<TextInput key={k} option={option} />
) : (
""
);
});
}
htmlVal = Object.keys(html[0]);
if (htmlVal.length === 0) {
html = items.map((option, k) => {
return option.input_type === "textarea" ? (
<TextareaInput key={k} option={option} />
) : (
""
);
});
}
return typeof selectHtml === "object" &&
Object.keys(selectHtml[0]).length ? (
<select
className="form-control"
value={this.props.value}
name="serious"
onChange={this.props.onChange}
>
{selectHtml}
</select>
) : (
html
);
}
}
export default Options;
|
class DataManager {
/**
* l'adresse du serveur
* @type {String|null}
*/
src = null;
/**
* l'ensemble des produits
* @type {Array|null}
*/
products = null;
constructor() {
this.src = "http://localhost:3000/api/teddies/";
}
/**
*permet de récupérer tous les produits
*
* @return {Array} tous les produits
*/
async getAllProducts() {
if (this.products === null) {
this.products = await fetch(this.src);
if (this.products.ok) {
this.products = await this.products.json();
} else {
alert('Erreur : ' + this.products.status);
}
}
return this.products; //si liste présente mais pas à jour? combien de temps et ou les données restent?
}
/**
* permet d'avoir les caractéristiques d'un produit
*
* @param {String} idProduct id du produit dont on veut les caractériques
*
* @return {Object} les spécifications du produit
*/
async getProductInfo(idProduct) {
if (this.products !== null) {
for (let i = 0; i < this.products.length; i++) {
if (idProduct === this.products[i]._id) {
return this.products[i];
};
};
}
let productInfo = await fetch(this.src + idProduct);
productInfo = await productInfo.json();
if (this.products === null) this.products = [];
this.products.push(productInfo);
return productInfo;
}
/**
* récupère les info formulaire, le panier et renvoi un numéro de commande
* @param {object} contact info contact du formulaire
* @param {array} products tableau d'id des produits commandés
* @return {Object} info passées plus n° de commande
* */
async postOrderRequest(contact, products) {
var orderConfirm = await fetch(this.src + 'order', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify ({contact, products})
});
orderConfirm = await orderConfirm.json();
return orderConfirm;
}
/**
* affiche et met à jour le nombre d'article dans le panier dans la barre de navigation
*
*/
cartCounter() {
document.querySelector('#cart').innerText = `Panier (${localStorage.length})`;
}
saveOrder(idOrder, orderInfo, total){
sessionStorage.setItem(idOrder, JSON.stringify({...orderInfo, "total" : total}));
}
getOrder(id){
return JSON.parse(sessionStorage.getItem(id));
}
/**
* vide le stockage local après confirmation commande
*
*/
clearLocalData(){
localStorage.clear();
sessionStorage.clear();
}
} |
import React from 'react'
import * as booksActions from '../../state/ducks/booksDuck'
import * as booksSelectors from '../../state/selectors/booksSelectors'
import { bindActionCreators } from 'redux'
import { connect } from 'react-redux'
import { Row, Col } from 'antd'
import styled from 'styled-components'
import Book from './Book'
import emptyImage from '../../assets/no-books.png'
export class BooksList extends React.Component {
async componentWillMount() {
try {
await this.props.booksActions.getBooks()
} catch (error) {
console.log(error)
}
}
render() {
const { books } = this.props
if (!books.length)
return (
<Container>
<EmptyContainer>
<Image src={emptyImage} />
<EmptyTitle>It seems like there are no books :(</EmptyTitle>
</EmptyContainer>
</Container>
)
return (
<Container>
<AntRow gutter={24}>
{books.map(book => (
<AntCol key={book.id} sm={24} md={12}>
<Book book={book} />
</AntCol>
))}
</AntRow>
</Container>
)
}
}
const Image = styled.img`
width: 300px;
height: auto;
`
Image.displayName = 'Image'
const EmptyContainer = styled.div`
display: flex;
flex-direction: column;
align-items: center;
`
EmptyContainer.displayName = 'EmptyContainer'
const EmptyTitle = styled.h2`
color: #838f93;
`
EmptyTitle.displayName = 'EmptyTitle'
const Container = styled.div`
flex: 1;
padding: 0 30px;
`
Container.displayName = 'Container'
const AntRow = styled(Row)`
margin: -24px 0;
`
AntRow.displayName = 'AntRow'
const AntCol = styled(Col)`
padding: 24px 12px;
`
AntCol.displayName = 'AntCol'
const mapState = state => ({
books: booksSelectors.getBooksByCategorySelected(state)
})
const mapDispatch = dispatch => ({
booksActions: bindActionCreators(booksActions, dispatch)
})
export default connect(
mapState,
mapDispatch
)(BooksList)
|
const questions = [
['How many planets are in the Solar System?', '8'],
['How many continents are there?', '7'],
['How many legs does an insect have?', '6'],
['What year was JavaScript created?', '1995']
];
// This stores the correct questions
const correct = [];
const inncorrect = [];
let correctAnswers = 0;
for (let i = 0; i < questions.length; i++) {
let question = questions[i][0];
let answer = questions[i][1];
let response = prompt(question);
if (response === answer) {
correctAnswers += 1;
correct.push(question);
} else {
inncorrect.push(question);
};
};
function createListItems(arr) {
let items = '';
for (let i = 0; i < arr.length; i++) {
items += `<li>${arr[i]}</li>`;
}
return items;
}
// Shows correct answers to end user
let html = `
<h1>Your correct answers: ${correctAnswers} out of a possible ${questions.length}</h1>
<h2>You got these questions right:</h2>
<ol>${createListItems(correct)}</ol>
<h2>You got these questions wrong:</h2>
<ol>${createListItems(inncorrect)}</ol>
`;
document.querySelector('main').innerHTML = html; |
import add from "./add";
console.log(add(3, 5));
|
/*
* Copyright (C) 2021 Radix IoT LLC. All rights reserved.
*/
applyThemeDirective.$inject = ['maTheming'];
function applyThemeDirective(maTheming) {
class ApplyThemeController {
static get $$ngIsClass() { return true; }
static get $inject() { return ['$element']; }
constructor($element) {
this.$element = $element;
}
$doCheck() {
const theme = maTheming.getThemes()[this.theme];
if (theme !== this.prevTheme) {
maTheming.themeElement(this.$element[0], this.theme);
this.prevTheme = theme;
}
}
}
return {
restrict: 'A',
controller: ApplyThemeController,
bindToController: {
theme: '@maApplyTheme'
},
scope: false
};
}
export default applyThemeDirective; |
import { atom } from 'jotai';
export const userData = atom({});
export const logged = atom(false);
|
class Drop{
constructor(x,y){
this.x = x;
this.y = y;
var options = {
friction: 0.001,
restitution:0.1
}
this.drop = Bodies.circle(x,y,3, options)
World.add(world,this.drop)
this.radius = 10
this.image = loadImage("drop.png");
}
showDrop(){
/* fill("blue")
ellipseMode(RADIUS)
ellipse(this.drop.position.x,this.drop.position.y,this.radius,this.radius) */
imageMode(CENTER)
image(this.image,this.drop.position.x,this.drop.position.y,this.radius,this.radius)
}
fall(){
if(this.drop.position.y > height){
Matter.Body.setPosition(this.drop, {x: random(0,width),y:random(0,height)})
}
}
} |
angular
.module('djapp')
.factory('offersCountService', function () {
var self = this;
self.NewOffersCount = 0;
self.offers = [];
self.getNewOffersCount = function () {
self.NewOffersCount = 0;
angular.forEach(self.offers, function(offerItem) {
if (offerItem.Status === "New") {
self.NewOffersCount++;
};
});
return self.NewOffersCount;
};
self.updateOffer = function (offer) {
angular.forEach(self.offers, function (offerItem, index) {
if (offerItem.Id === offer.Id) {
self.offers[index] = offer;
};
});
}
return self;
}); |
const { errorManager } = require('./errorManager.js');
const { readFileSync } = require('fs');
const { assert } = require('./utility.js');
function isDigit(c) {
return c >= '0' && c <= '9';
}
function isLetter(c) {
return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
}
const puncts = ['==', '!=', '>=', '<='];
const keywords = ['int', 'return'];
class FileScanner {
constructor(source, path) {
this.source = source;
this.path = path;
this.ln = 1;
this.col = 1;
this.index = 0;
this.tokenList = [];
}
peek() {
if (this.index >= this.source.length) {
throw 'EOF';
}
return this.source[this.index];
}
read() {
const c = this.peek();
if (c === '\n') {
++this.ln;
this.col = 1;
} else {
++this.col;
}
++this.index;
return c;
}
pushNumber() {
const { col, ln, source, path } = this;
const start = this.index;
let end = start;
while (this.index < this.source.length) {
const c = this.peek();
if (!isDigit(c)) {
break;
}
this.read();
end += 1;
}
const kind = 'INT';
const raw = source.substring(start, end);
const token = {
kind, raw, start, end, source, path, ln, col
};
this.tokenList.push(token);
}
pushIdentifier() {
const { col, ln, source, path } = this;
const start = this.index;
let end = start + 1;
this.read();
while (this.index < this.source.length) {
const c = this.peek();
if (!isLetter(c) && !isDigit(c) && c !== '_') {
break;
}
this.read();
end += 1;
}
const raw = source.substring(start, end);
const kind = keywords.indexOf(raw) !== -1 ? 'KEYWORD' : 'IDENTIFIER';
const token = {
kind, raw, start, end, source, path, ln, col
};
this.tokenList.push(token);
}
pushPunct() {
const { col, ln, path, source } = this;
const start = this.index;
this.read();
const kind = 'PUNCT';
let end = start + 1;
for (let i = 0; i < puncts.length; ++i) {
const punct = puncts[i];
if (source.startsWith(punct, start)) {
end = start + punct.length;
for (let j = 1; j < punct.length; ++j) {
this.read();
}
break;
}
}
const raw = source.substring(start, end);
const token = {
kind, raw, start, end, source, path, ln, col
};
this.tokenList.push(token);
}
scan() {
while (this.index < this.source.length) {
const c = this.peek();
if (' \r\n\t'.includes(c)) {
this.read();
continue;
}
if (isDigit(c)) {
this.pushNumber();
continue;
}
if (isLetter(c) || c === '_') {
this.pushIdentifier();
continue;
}
if ('+-*/%=><(){},;!?'.includes(c)) {
this.pushPunct();
continue;
}
// unrecognized character
const msg = `strayed character '${c}'`;
const { path, source, ln, col } = this;
const err = { msg, path, source, ln, col, span: 1 };
errorManager.pushError(err);
this.read();
}
return this.tokenList;
}
}
function scanSource(fileSource, filePath) {
filePath = filePath || '<unknown>';
const tokenList = new FileScanner(fileSource, filePath).scan();
const last = tokenList[tokenList.length - 1];
const { path, source, ln, col, raw } = last;
tokenList.push({ kind: 'EOF', raw: '$', path, source, ln, col: col + raw.length });
return tokenList;
}
function scan(filePath) {
try {
const fileSource = readFileSync(filePath, 'utf8');
return scanSource(fileSource, filePath);
} catch (err) {
console.error(`failed to open file "${filePath}"`);
console.error(err);
process.exit(1);
}
}
exports.scanSource = scanSource;
exports.scan = scan;
|
import debug from 'debug';
const logger = debug('sdmx:data');
const init = context => { // eslint-disable-line
const promise = new Promise(resolve => {
logger('Data loaded');
resolve(context);
});
return promise;
};
export default init;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.